Файловый менеджер

8889841c Файловый менеджер

Файловый менеджер - Редактировать - /home/clixcotz/mars.clix.co.tz/node_modules/vue/packages/compiler-sfc/dist/compiler-sfc.js

Назад
'use strict'; Object.defineProperty(exports, '__esModule', { value: true }); var require$$0 = require('source-map'); var parser$1 = require('@babel/parser'); var url = require('url'); var path = require('path'); var require$$0$1 = require('fs'); var require$$2 = require('util'); function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } var require$$0__default$1 = /#__PURE__/_interopDefaultLegacy(require$$0); var path__default = /#__PURE__/_interopDefaultLegacy(path); var require$$0__default = /#__PURE__/_interopDefaultLegacy(require$$0$1); var require$$2__default = /#__PURE__/_interopDefaultLegacy(require$$2); var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; function getDefaultExportFromCjs (x) { return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; } var splitRE$2 = /\r?\n/g; var emptyRE$1 = /^\s$/; var needFixRE = /^(\r?\n)[\t\s]/; var deIndent = function deindent (str) { if (!needFixRE.test(str)) { return str } var lines = str.split(splitRE$2); var min = Infinity; var type, cur, c; for (var i = 0; i < lines.length; i++) { var line = lines[i]; if (!emptyRE$1.test(line)) { if (!type) { c = line.charAt(0); if (c === ' ' \|\| c === '\t') { type = c; cur = count(line, type); if (cur < min) { min = cur; } } else { return str } } else { cur = count(line, type); if (cur < min) { min = cur; } } } } return lines.map(function (line) { return line.slice(min) }).join('\n') }; function count (line, type) { var i = 0; while (line.charAt(i) === type) { i++; } return i } const emptyObject = Object.freeze({}); const isArray = Array.isArray; // These helpers produce better VM code in JS engines due to their // explicitness and function inlining. function isUndef(v) { return v === undefined \|\| v === null; } function isDef(v) { return v !== undefined && v !== null; } function isTrue(v) { return v === true; } function isFalse(v) { return v === false; } /** * Check if value is primitive. / function isPrimitive(value) { return (typeof value === 'string' \|\| typeof value === 'number' \|\| // $flow-disable-line typeof value === 'symbol' \|\| typeof value === 'boolean'); } function isFunction(value) { return typeof value === 'function'; } /* * Quick object check - this is primarily used to tell * objects from primitive values when we know the value * is a JSON-compliant type. / function isObject$1(obj) { return obj !== null && typeof obj === 'object'; } /* * Get the raw type string of a value, e.g., [object Object]. / const _toString = Object.prototype.toString; function toRawType(value) { return _toString.call(value).slice(8, -1); } /* * Strict object type check. Only returns true * for plain JavaScript objects. / function isPlainObject(obj) { return _toString.call(obj) === '[object Object]'; } /* * Check if val is a valid array index. / function isValidArrayIndex(val) { const n = parseFloat(String(val)); return n >= 0 && Math.floor(n) === n && isFinite(val); } function isPromise(val) { return (isDef(val) && typeof val.then === 'function' && typeof val.catch === 'function'); } /* * Convert a value to a string that is actually rendered. / function toString$2(val) { return val == null ? '' : Array.isArray(val) \|\| (isPlainObject(val) && val.toString === _toString) ? JSON.stringify(val, null, 2) : String(val); } /* * Convert an input value to a number for persistence. * If the conversion fails, return original string. / function toNumber(val) { const n = parseFloat(val); return isNaN(n) ? val : n; } /* * Make a map and return a function for checking if a key * is in that map. / function makeMap(str, expectsLowerCase) { const map = Object.create(null); const list = str.split(','); for (let i = 0; i < list.length; i++) { map[list[i]] = true; } return expectsLowerCase ? val => map[val.toLowerCase()] : val => map[val]; } /* * Check if a tag is a built-in tag. / const isBuiltInTag = makeMap('slot,component', true); /* * Check if an attribute is a reserved attribute. / const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); /* * Check whether an object has the property. / const hasOwnProperty$1 = Object.prototype.hasOwnProperty; function hasOwn(obj, key) { return hasOwnProperty$1.call(obj, key); } /* * Create a cached version of a pure function. / function cached(fn) { const cache = Object.create(null); return function cachedFn(str) { const hit = cache[str]; return hit \|\| (cache[str] = fn(str)); }; } /* * Camelize a hyphen-delimited string. / const camelizeRE = /-(\w)/g; const camelize = cached((str) => { return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); }); /* * Capitalize a string. / const capitalize = cached((str) => { return str.charAt(0).toUpperCase() + str.slice(1); }); /* * Hyphenate a camelCase string. / const hyphenateRE = /\B([A-Z])/g; const hyphenate = cached((str) => { return str.replace(hyphenateRE, '-$1').toLowerCase(); }); /* * Mix properties into target object. / function extend(to, _from) { for (const key in _from) { to[key] = _from[key]; } return to; } /* * Merge an Array of Objects into a single Object. / function toObject(arr) { const res = {}; for (let i = 0; i < arr.length; i++) { if (arr[i]) { extend(res, arr[i]); } } return res; } / eslint-disable no-unused-vars / /* * Perform no operation. * Stubbing args to make Flow happy without leaving useless transpiled code * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/). / function noop(a, b, c) { } /* * Always return false. / const no = (a, b, c) => false; / eslint-enable no-unused-vars / /* * Return the same value. / const identity = (_) => _; /* * Generate a string containing static keys from compiler modules. / function genStaticKeys$1(modules) { return modules .reduce((keys, m) => { return keys.concat(m.staticKeys \|\| []); }, []) .join(','); } /* * Check if two values are loosely equal - that is, * if they are plain objects, do they have the same shape? / function looseEqual(a, b) { if (a === b) return true; const isObjectA = isObject$1(a); const isObjectB = isObject$1(b); if (isObjectA && isObjectB) { try { const isArrayA = Array.isArray(a); const isArrayB = Array.isArray(b); if (isArrayA && isArrayB) { return (a.length === b.length && a.every((e, i) => { return looseEqual(e, b[i]); })); } else if (a instanceof Date && b instanceof Date) { return a.getTime() === b.getTime(); } else if (!isArrayA && !isArrayB) { const keysA = Object.keys(a); const keysB = Object.keys(b); return (keysA.length === keysB.length && keysA.every(key => { return looseEqual(a[key], b[key]); })); } else { / istanbul ignore next / return false; } } catch (e) { / istanbul ignore next / return false; } } else if (!isObjectA && !isObjectB) { return String(a) === String(b); } else { return false; } } /* * Return the first index at which a loosely equal value can be * found in the array (if value is a plain object, the array must * contain an object of the same shape), or -1 if it is not present. / function looseIndexOf(arr, val) { for (let i = 0; i < arr.length; i++) { if (looseEqual(arr[i], val)) return i; } return -1; } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill function hasChanged(x, y) { if (x === y) { return x === 0 && 1 / x !== 1 / y; } else { return x === x \|\| y === y; } } const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' + 'link,meta,param,source,track,wbr'); // Elements that you can, intentionally, leave open // (and which close themselves) const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'); // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' + 'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' + 'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' + 'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' + 'title,tr,track'); /* * unicode letters used for parsing html tags, component names and property paths. * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname * skipping \u10000-\uEFFFF due to it freezing up PhantomJS / const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/; /* * Define a property. / function def(obj, key, val, enumerable) { Object.defineProperty(obj, key, { value: val, enumerable: !!enumerable, writable: true, configurable: true }); } /* * Not type-checking this file because it's mostly vendor code. / // Regular Expressions for parsing tags and attributes const attribute$2 = /^\s([^\s"'<>\/=]+)(?:\s(=)\s(?:"([^"])"+\|'([^'])'+\|([^\s"'=<>`]+)))?/; const dynamicArgAttribute = /^\s((?:v-[\w-]+:\|@\|:\|#)\[[^=]+?\][^\s"'<>\/=])(?:\s(=)\s(?:"([^"])"+\|'([^'])'+\|([^\s"'=<>`]+)))?/; const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]`; const qnameCapture = `((?:${ncname}\\:)?${ncname})`; const startTagOpen = new RegExp(`^<${qnameCapture}`); const startTagClose = /^\s(\/?)>/; const endTag = new RegExp(`^<\\/${qnameCapture}[^>]>`); const doctype = /^<!DOCTYPE [^>]+>/i; // #7298: escape - to avoid being passed as HTML comment when inlined in page const comment$3 = /^<!\--/; const conditionalComment = /^<!\[/; // Special Elements (can contain anything) const isPlainTextElement = makeMap('script,style,textarea', true); const reCache = {}; const decodingMap = { '<': '<', '>': '>', '"': '"', '&': '&', ' ': '\n', ' ': '\t', ''': "'" }; const encodedAttr = /&(?:lt\|gt\|quot\|amp\|#39);/g; const encodedAttrWithNewLines = /&(?:lt\|gt\|quot\|amp\|#39\|#10\|#9);/g; // #5992 const isIgnoreNewlineTag = makeMap('pre,textarea', true); const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; function decodeAttr(value, shouldDecodeNewlines) { const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr; return value.replace(re, match => decodingMap[match]); } function parseHTML(html, options) { const stack = []; const expectHTML = options.expectHTML; const isUnaryTag = options.isUnaryTag \|\| no; const canBeLeftOpenTag = options.canBeLeftOpenTag \|\| no; let index = 0; let last, lastTag; while (html) { last = html; // Make sure we're not in a plaintext content element like script/style if (!lastTag \|\| !isPlainTextElement(lastTag)) { let textEnd = html.indexOf('<'); if (textEnd === 0) { // Comment: if (comment$3.test(html)) { const commentEnd = html.indexOf('-->'); if (commentEnd >= 0) { if (options.shouldKeepComment && options.comment) { options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3); } advance(commentEnd + 3); continue; } } // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment if (conditionalComment.test(html)) { const conditionalEnd = html.indexOf(']>'); if (conditionalEnd >= 0) { advance(conditionalEnd + 2); continue; } } // Doctype: const doctypeMatch = html.match(doctype); if (doctypeMatch) { advance(doctypeMatch[0].length); continue; } // End tag: const endTagMatch = html.match(endTag); if (endTagMatch) { const curIndex = index; advance(endTagMatch[0].length); parseEndTag(endTagMatch[1], curIndex, index); continue; } // Start tag: const startTagMatch = parseStartTag(); if (startTagMatch) { handleStartTag(startTagMatch); if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) { advance(1); } continue; } } let text, rest, next; if (textEnd >= 0) { rest = html.slice(textEnd); while (!endTag.test(rest) && !startTagOpen.test(rest) && !comment$3.test(rest) && !conditionalComment.test(rest)) { // < in plain text, be forgiving and treat it as text next = rest.indexOf('<', 1); if (next < 0) break; textEnd += next; rest = html.slice(textEnd); } text = html.substring(0, textEnd); } if (textEnd < 0) { text = html; } if (text) { advance(text.length); } if (options.chars && text) { options.chars(text, index - text.length, index); } } else { let endTagLength = 0; const stackedTag = lastTag.toLowerCase(); const reStackedTag = reCache[stackedTag] \|\| (reCache[stackedTag] = new RegExp('([\\s\\S]?)(</' + stackedTag + '[^>]>)', 'i')); const rest = html.replace(reStackedTag, function (all, text, endTag) { endTagLength = endTag.length; if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') { text = text .replace(/<!\--([\s\S]?)-->/g, '$1') // #7298 .replace(/<!\[CDATA\[([\s\S]?)]]>/g, '$1'); } if (shouldIgnoreFirstNewline(stackedTag, text)) { text = text.slice(1); } if (options.chars) { options.chars(text); } return ''; }); index += html.length - rest.length; html = rest; parseEndTag(stackedTag, index - endTagLength, index); } if (html === last) { options.chars && options.chars(html); if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) { options.warn(`Mal-formatted tag at end of template: "${html}"`, { start: index + html.length }); } break; } } // Clean up any remaining tags parseEndTag(); function advance(n) { index += n; html = html.substring(n); } function parseStartTag() { const start = html.match(startTagOpen); if (start) { const match = { tagName: start[1], attrs: [], start: index }; advance(start[0].length); let end, attr; while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) \|\| html.match(attribute$2))) { attr.start = index; advance(attr[0].length); attr.end = index; match.attrs.push(attr); } if (end) { match.unarySlash = end[1]; advance(end[0].length); match.end = index; return match; } } } function handleStartTag(match) { const tagName = match.tagName; const unarySlash = match.unarySlash; if (expectHTML) { if (lastTag === 'p' && isNonPhrasingTag(tagName)) { parseEndTag(lastTag); } if (canBeLeftOpenTag(tagName) && lastTag === tagName) { parseEndTag(tagName); } } const unary = isUnaryTag(tagName) \|\| !!unarySlash; const l = match.attrs.length; const attrs = new Array(l); for (let i = 0; i < l; i++) { const args = match.attrs[i]; const value = args[3] \|\| args[4] \|\| args[5] \|\| ''; const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href' ? options.shouldDecodeNewlinesForHref : options.shouldDecodeNewlines; attrs[i] = { name: args[1], value: decodeAttr(value, shouldDecodeNewlines) }; if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) { attrs[i].start = args.start + args[0].match(/^\s/).length; attrs[i].end = args.end; } } if (!unary) { stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end }); lastTag = tagName; } if (options.start) { options.start(tagName, attrs, unary, match.start, match.end); } } function parseEndTag(tagName, start, end) { let pos, lowerCasedTagName; if (start == null) start = index; if (end == null) end = index; // Find the closest opened tag of the same type if (tagName) { lowerCasedTagName = tagName.toLowerCase(); for (pos = stack.length - 1; pos >= 0; pos--) { if (stack[pos].lowerCasedTag === lowerCasedTagName) { break; } } } else { // If no tag name is provided, clean shop pos = 0; } if (pos >= 0) { // Close all the open elements, up the stack for (let i = stack.length - 1; i >= pos; i--) { if (process.env.NODE_ENV !== 'production' && (i > pos \|\| !tagName) && options.warn) { options.warn(`tag <${stack[i].tag}> has no matching end tag.`, { start: stack[i].start, end: stack[i].end }); } if (options.end) { options.end(stack[i].tag, start, end); } } // Remove the open elements from the stack stack.length = pos; lastTag = pos && stack[pos - 1].tag; } else if (lowerCasedTagName === 'br') { if (options.start) { options.start(tagName, [], true, start, end); } } else if (lowerCasedTagName === 'p') { if (options.start) { options.start(tagName, [], false, start, end); } if (options.end) { options.end(tagName, start, end); } } } } const DEFAULT_FILENAME = 'anonymous.vue'; const splitRE$1 = /\r?\n/g; const replaceRE = /./g; const isSpecialTag = makeMap('script,style,template', true); /** * Parse a single-file component (.vue) file into an SFC Descriptor Object. / function parseComponent(source, options = {}) { const sfc = { source, filename: DEFAULT_FILENAME, template: null, script: null, scriptSetup: null, styles: [], customBlocks: [], cssVars: [], errors: [], shouldForceReload: null // attached in parse() by compiler-sfc }; let depth = 0; let currentBlock = null; let warn = msg => { sfc.errors.push(msg); }; if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) { warn = (msg, range) => { const data = { msg }; if (range.start != null) { data.start = range.start; } if (range.end != null) { data.end = range.end; } sfc.errors.push(data); }; } function start(tag, attrs, unary, start, end) { if (depth === 0) { currentBlock = { type: tag, content: '', start: end, end: 0, attrs: attrs.reduce((cumulated, { name, value }) => { cumulated[name] = value \|\| true; return cumulated; }, {}) }; if (typeof currentBlock.attrs.src === 'string') { currentBlock.src = currentBlock.attrs.src; } if (isSpecialTag(tag)) { checkAttrs(currentBlock, attrs); if (tag === 'script') { const block = currentBlock; if (block.attrs.setup) { block.setup = currentBlock.attrs.setup; sfc.scriptSetup = block; } else { sfc.script = block; } } else if (tag === 'style') { sfc.styles.push(currentBlock); } else { sfc[tag] = currentBlock; } } else { // custom blocks sfc.customBlocks.push(currentBlock); } } if (!unary) { depth++; } } function checkAttrs(block, attrs) { for (let i = 0; i < attrs.length; i++) { const attr = attrs[i]; if (attr.name === 'lang') { block.lang = attr.value; } if (attr.name === 'scoped') { block.scoped = true; } if (attr.name === 'module') { block.module = attr.value \|\| true; } } } function end(tag, start) { if (depth === 1 && currentBlock) { currentBlock.end = start; let text = source.slice(currentBlock.start, currentBlock.end); if (options.deindent === true \|\| // by default, deindent unless it's script with default lang or (j/t)sx? (options.deindent !== false && !(currentBlock.type === 'script' && (!currentBlock.lang \|\| /^(j\|t)sx?$/.test(currentBlock.lang))))) { text = deIndent(text); } // pad content so that linters and pre-processors can output correct // line numbers in errors and warnings if (currentBlock.type !== 'template' && options.pad) { text = padContent(currentBlock, options.pad) + text; } currentBlock.content = text; currentBlock = null; } depth--; } function padContent(block, pad) { if (pad === 'space') { return source.slice(0, block.start).replace(replaceRE, ' '); } else { const offset = source.slice(0, block.start).split(splitRE$1).length; const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'; return Array(offset).join(padChar); } } parseHTML(source, { warn, start, end, outputSourceRange: options.outputSourceRange }); return sfc; } function pad (hash, len) { while (hash.length < len) { hash = '0' + hash; } return hash; } function fold (hash, text) { var i; var chr; var len; if (text.length === 0) { return hash; } for (i = 0, len = text.length; i < len; i++) { chr = text.charCodeAt(i); hash = ((hash << 5) - hash) + chr; hash \|= 0; } return hash < 0 ? hash * -2 : hash; } function foldObject (hash, o, seen) { return Object.keys(o).sort().reduce(foldKey, hash); function foldKey (hash, key) { return foldValue(hash, o[key], key, seen); } } function foldValue (input, value, key, seen) { var hash = fold(fold(fold(input, key), toString$1(value)), typeof value); if (value === null) { return fold(hash, 'null'); } if (value === undefined) { return fold(hash, 'undefined'); } if (typeof value === 'object' \|\| typeof value === 'function') { if (seen.indexOf(value) !== -1) { return fold(hash, '[Circular]' + key); } seen.push(value); var objHash = foldObject(hash, value, seen); if (!('valueOf' in value) \|\| typeof value.valueOf !== 'function') { return objHash; } try { return fold(objHash, String(value.valueOf())) } catch (err) { return fold(objHash, '[valueOf exception]' + (err.stack \|\| err.message)) } } return fold(hash, value.toString()); } function toString$1 (o) { return Object.prototype.toString.call(o); } function sum (o) { return pad(foldValue(0, o, '', []).toString(16), 8); } var hashSum = sum; var iterator; var hasRequiredIterator; function requireIterator () { if (hasRequiredIterator) return iterator; hasRequiredIterator = 1; iterator = function (Yallist) { Yallist.prototype[Symbol.iterator] = function* () { for (let walker = this.head; walker; walker = walker.next) { yield walker.value; } }; }; return iterator; } var yallist = Yallist$1; Yallist$1.Node = Node; Yallist$1.create = Yallist$1; function Yallist$1 (list) { var self = this; if (!(self instanceof Yallist$1)) { self = new Yallist$1(); } self.tail = null; self.head = null; self.length = 0; if (list && typeof list.forEach === 'function') { list.forEach(function (item) { self.push(item); }); } else if (arguments.length > 0) { for (var i = 0, l = arguments.length; i < l; i++) { self.push(arguments[i]); } } return self } Yallist$1.prototype.removeNode = function (node) { if (node.list !== this) { throw new Error('removing node which does not belong to this list') } var next = node.next; var prev = node.prev; if (next) { next.prev = prev; } if (prev) { prev.next = next; } if (node === this.head) { this.head = next; } if (node === this.tail) { this.tail = prev; } node.list.length--; node.next = null; node.prev = null; node.list = null; return next }; Yallist$1.prototype.unshiftNode = function (node) { if (node === this.head) { return } if (node.list) { node.list.removeNode(node); } var head = this.head; node.list = this; node.next = head; if (head) { head.prev = node; } this.head = node; if (!this.tail) { this.tail = node; } this.length++; }; Yallist$1.prototype.pushNode = function (node) { if (node === this.tail) { return } if (node.list) { node.list.removeNode(node); } var tail = this.tail; node.list = this; node.prev = tail; if (tail) { tail.next = node; } this.tail = node; if (!this.head) { this.head = node; } this.length++; }; Yallist$1.prototype.push = function () { for (var i = 0, l = arguments.length; i < l; i++) { push(this, arguments[i]); } return this.length }; Yallist$1.prototype.unshift = function () { for (var i = 0, l = arguments.length; i < l; i++) { unshift(this, arguments[i]); } return this.length }; Yallist$1.prototype.pop = function () { if (!this.tail) { return undefined } var res = this.tail.value; this.tail = this.tail.prev; if (this.tail) { this.tail.next = null; } else { this.head = null; } this.length--; return res }; Yallist$1.prototype.shift = function () { if (!this.head) { return undefined } var res = this.head.value; this.head = this.head.next; if (this.head) { this.head.prev = null; } else { this.tail = null; } this.length--; return res }; Yallist$1.prototype.forEach = function (fn, thisp) { thisp = thisp \|\| this; for (var walker = this.head, i = 0; walker !== null; i++) { fn.call(thisp, walker.value, i, this); walker = walker.next; } }; Yallist$1.prototype.forEachReverse = function (fn, thisp) { thisp = thisp \|\| this; for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { fn.call(thisp, walker.value, i, this); walker = walker.prev; } }; Yallist$1.prototype.get = function (n) { for (var i = 0, walker = this.head; walker !== null && i < n; i++) { // abort out of the list early if we hit a cycle walker = walker.next; } if (i === n && walker !== null) { return walker.value } }; Yallist$1.prototype.getReverse = function (n) { for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { // abort out of the list early if we hit a cycle walker = walker.prev; } if (i === n && walker !== null) { return walker.value } }; Yallist$1.prototype.map = function (fn, thisp) { thisp = thisp \|\| this; var res = new Yallist$1(); for (var walker = this.head; walker !== null;) { res.push(fn.call(thisp, walker.value, this)); walker = walker.next; } return res }; Yallist$1.prototype.mapReverse = function (fn, thisp) { thisp = thisp \|\| this; var res = new Yallist$1(); for (var walker = this.tail; walker !== null;) { res.push(fn.call(thisp, walker.value, this)); walker = walker.prev; } return res }; Yallist$1.prototype.reduce = function (fn, initial) { var acc; var walker = this.head; if (arguments.length > 1) { acc = initial; } else if (this.head) { walker = this.head.next; acc = this.head.value; } else { throw new TypeError('Reduce of empty list with no initial value') } for (var i = 0; walker !== null; i++) { acc = fn(acc, walker.value, i); walker = walker.next; } return acc }; Yallist$1.prototype.reduceReverse = function (fn, initial) { var acc; var walker = this.tail; if (arguments.length > 1) { acc = initial; } else if (this.tail) { walker = this.tail.prev; acc = this.tail.value; } else { throw new TypeError('Reduce of empty list with no initial value') } for (var i = this.length - 1; walker !== null; i--) { acc = fn(acc, walker.value, i); walker = walker.prev; } return acc }; Yallist$1.prototype.toArray = function () { var arr = new Array(this.length); for (var i = 0, walker = this.head; walker !== null; i++) { arr[i] = walker.value; walker = walker.next; } return arr }; Yallist$1.prototype.toArrayReverse = function () { var arr = new Array(this.length); for (var i = 0, walker = this.tail; walker !== null; i++) { arr[i] = walker.value; walker = walker.prev; } return arr }; Yallist$1.prototype.slice = function (from, to) { to = to \|\| this.length; if (to < 0) { to += this.length; } from = from \|\| 0; if (from < 0) { from += this.length; } var ret = new Yallist$1(); if (to < from \|\| to < 0) { return ret } if (from < 0) { from = 0; } if (to > this.length) { to = this.length; } for (var i = 0, walker = this.head; walker !== null && i < from; i++) { walker = walker.next; } for (; walker !== null && i < to; i++, walker = walker.next) { ret.push(walker.value); } return ret }; Yallist$1.prototype.sliceReverse = function (from, to) { to = to \|\| this.length; if (to < 0) { to += this.length; } from = from \|\| 0; if (from < 0) { from += this.length; } var ret = new Yallist$1(); if (to < from \|\| to < 0) { return ret } if (from < 0) { from = 0; } if (to > this.length) { to = this.length; } for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { walker = walker.prev; } for (; walker !== null && i > from; i--, walker = walker.prev) { ret.push(walker.value); } return ret }; Yallist$1.prototype.splice = function (start, deleteCount /, ...nodes /) { if (start > this.length) { start = this.length - 1; } if (start < 0) { start = this.length + start; } for (var i = 0, walker = this.head; walker !== null && i < start; i++) { walker = walker.next; } var ret = []; for (var i = 0; walker && i < deleteCount; i++) { ret.push(walker.value); walker = this.removeNode(walker); } if (walker === null) { walker = this.tail; } if (walker !== this.head && walker !== this.tail) { walker = walker.prev; } for (var i = 2; i < arguments.length; i++) { walker = insert(this, walker, arguments[i]); } return ret; }; Yallist$1.prototype.reverse = function () { var head = this.head; var tail = this.tail; for (var walker = head; walker !== null; walker = walker.prev) { var p = walker.prev; walker.prev = walker.next; walker.next = p; } this.head = tail; this.tail = head; return this }; function insert (self, node, value) { var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self); if (inserted.next === null) { self.tail = inserted; } if (inserted.prev === null) { self.head = inserted; } self.length++; return inserted } function push (self, item) { self.tail = new Node(item, self.tail, null, self); if (!self.head) { self.head = self.tail; } self.length++; } function unshift (self, item) { self.head = new Node(item, null, self.head, self); if (!self.tail) { self.tail = self.head; } self.length++; } function Node (value, prev, next, list) { if (!(this instanceof Node)) { return new Node(value, prev, next, list) } this.list = list; this.value = value; if (prev) { prev.next = this; this.prev = prev; } else { this.prev = null; } if (next) { next.prev = this; this.next = next; } else { this.next = null; } } try { // add if support for Symbol.iterator is present requireIterator()(Yallist$1); } catch (er) {} // A linked list to keep track of recently-used-ness const Yallist = yallist; const MAX = Symbol('max'); const LENGTH = Symbol('length'); const LENGTH_CALCULATOR = Symbol('lengthCalculator'); const ALLOW_STALE = Symbol('allowStale'); const MAX_AGE = Symbol('maxAge'); const DISPOSE = Symbol('dispose'); const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet'); const LRU_LIST = Symbol('lruList'); const CACHE = Symbol('cache'); const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet'); const naiveLength = () => 1; // lruList is a yallist where the head is the youngest // item, and the tail is the oldest. the list contains the Hit // objects as the entries. // Each Hit object has a reference to its Yallist.Node. This // never changes. // // cache is a Map (or PseudoMap) that matches the keys to // the Yallist.Node object. class LRUCache { constructor (options) { if (typeof options === 'number') options = { max: options }; if (!options) options = {}; if (options.max && (typeof options.max !== 'number' \|\| options.max < 0)) throw new TypeError('max must be a non-negative number') // Kind of weird to have a default max of Infinity, but oh well. this[MAX] = options.max \|\| Infinity; const lc = options.length \|\| naiveLength; this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc; this[ALLOW_STALE] = options.stale \|\| false; if (options.maxAge && typeof options.maxAge !== 'number') throw new TypeError('maxAge must be a number') this[MAX_AGE] = options.maxAge \|\| 0; this[DISPOSE] = options.dispose; this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet \|\| false; this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet \|\| false; this.reset(); } // resize the cache when the max changes. set max (mL) { if (typeof mL !== 'number' \|\| mL < 0) throw new TypeError('max must be a non-negative number') this[MAX] = mL \|\| Infinity; trim(this); } get max () { return this[MAX] } set allowStale (allowStale) { this[ALLOW_STALE] = !!allowStale; } get allowStale () { return this[ALLOW_STALE] } set maxAge (mA) { if (typeof mA !== 'number') throw new TypeError('maxAge must be a non-negative number') this[MAX_AGE] = mA; trim(this); } get maxAge () { return this[MAX_AGE] } // resize the cache when the lengthCalculator changes. set lengthCalculator (lC) { if (typeof lC !== 'function') lC = naiveLength; if (lC !== this[LENGTH_CALCULATOR]) { this[LENGTH_CALCULATOR] = lC; this[LENGTH] = 0; this[LRU_LIST].forEach(hit => { hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key); this[LENGTH] += hit.length; }); } trim(this); } get lengthCalculator () { return this[LENGTH_CALCULATOR] } get length () { return this[LENGTH] } get itemCount () { return this[LRU_LIST].length } rforEach (fn, thisp) { thisp = thisp \|\| this; for (let walker = this[LRU_LIST].tail; walker !== null;) { const prev = walker.prev; forEachStep(this, fn, walker, thisp); walker = prev; } } forEach (fn, thisp) { thisp = thisp \|\| this; for (let walker = this[LRU_LIST].head; walker !== null;) { const next = walker.next; forEachStep(this, fn, walker, thisp); walker = next; } } keys () { return this[LRU_LIST].toArray().map(k => k.key) } values () { return this[LRU_LIST].toArray().map(k => k.value) } reset () { if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) { this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value)); } this[CACHE] = new Map(); // hash of items by key this[LRU_LIST] = new Yallist(); // list of items in order of use recency this[LENGTH] = 0; // length of items in the list } dump () { return this[LRU_LIST].map(hit => isStale(this, hit) ? false : { k: hit.key, v: hit.value, e: hit.now + (hit.maxAge \|\| 0) }).toArray().filter(h => h) } dumpLru () { return this[LRU_LIST] } set (key, value, maxAge) { maxAge = maxAge \|\| this[MAX_AGE]; if (maxAge && typeof maxAge !== 'number') throw new TypeError('maxAge must be a number') const now = maxAge ? Date.now() : 0; const len = this[LENGTH_CALCULATOR](value, key); if (this[CACHE].has(key)) { if (len > this[MAX]) { del(this, this[CACHE].get(key)); return false } const node = this[CACHE].get(key); const item = node.value; // dispose of the old one before overwriting // split out into 2 ifs for better coverage tracking if (this[DISPOSE]) { if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value); } item.now = now; item.maxAge = maxAge; item.value = value; this[LENGTH] += len - item.length; item.length = len; this.get(key); trim(this); return true } const hit = new Entry(key, value, len, now, maxAge); // oversized objects fall out of cache automatically. if (hit.length > this[MAX]) { if (this[DISPOSE]) this[DISPOSE](key, value); return false } this[LENGTH] += hit.length; this[LRU_LIST].unshift(hit); this[CACHE].set(key, this[LRU_LIST].head); trim(this); return true } has (key) { if (!this[CACHE].has(key)) return false const hit = this[CACHE].get(key).value; return !isStale(this, hit) } get (key) { return get(this, key, true) } peek (key) { return get(this, key, false) } pop () { const node = this[LRU_LIST].tail; if (!node) return null del(this, node); return node.value } del (key) { del(this, this[CACHE].get(key)); } load (arr) { // reset the cache this.reset(); const now = Date.now(); // A previous serialized cache has the most recent items first for (let l = arr.length - 1; l >= 0; l--) { const hit = arr[l]; const expiresAt = hit.e \|\| 0; if (expiresAt === 0) // the item was created without expiration in a non aged cache this.set(hit.k, hit.v); else { const maxAge = expiresAt - now; // dont add already expired items if (maxAge > 0) { this.set(hit.k, hit.v, maxAge); } } } } prune () { this[CACHE].forEach((value, key) => get(this, key, false)); } } const get = (self, key, doUse) => { const node = self[CACHE].get(key); if (node) { const hit = node.value; if (isStale(self, hit)) { del(self, node); if (!self[ALLOW_STALE]) return undefined } else { if (doUse) { if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now(); self[LRU_LIST].unshiftNode(node); } } return hit.value } }; const isStale = (self, hit) => { if (!hit \|\| (!hit.maxAge && !self[MAX_AGE])) return false const diff = Date.now() - hit.now; return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && (diff > self[MAX_AGE]) }; const trim = self => { if (self[LENGTH] > self[MAX]) { for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;) { // We know that we're about to delete this one, and also // what the next least recently used key will be, so just // go ahead and set it now. const prev = walker.prev; del(self, walker); walker = prev; } } }; const del = (self, node) => { if (node) { const hit = node.value; if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value); self[LENGTH] -= hit.length; self[CACHE].delete(hit.key); self[LRU_LIST].removeNode(node); } }; class Entry { constructor (key, value, length, now, maxAge) { this.key = key; this.value = value; this.length = length; this.now = now; this.maxAge = maxAge \|\| 0; } } const forEachStep = (self, fn, node, thisp) => { let hit = node.value; if (isStale(self, hit)) { del(self, node); if (!self[ALLOW_STALE]) hit = undefined; } if (hit) fn.call(thisp, hit.value, hit.key, self); }; var lruCache = LRUCache; var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='; function encode(decoded) { var sourceFileIndex = 0; // second field var sourceCodeLine = 0; // third field var sourceCodeColumn = 0; // fourth field var nameIndex = 0; // fifth field var mappings = ''; for (var i = 0; i < decoded.length; i++) { var line = decoded[i]; if (i > 0) mappings += ';'; if (line.length === 0) continue; var generatedCodeColumn = 0; // first field var lineMappings = []; for (var _i = 0, line_1 = line; _i < line_1.length; _i++) { var segment = line_1[_i]; var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn); generatedCodeColumn = segment[0]; if (segment.length > 1) { segmentMappings += encodeInteger(segment[1] - sourceFileIndex) + encodeInteger(segment[2] - sourceCodeLine) + encodeInteger(segment[3] - sourceCodeColumn); sourceFileIndex = segment[1]; sourceCodeLine = segment[2]; sourceCodeColumn = segment[3]; } if (segment.length === 5) { segmentMappings += encodeInteger(segment[4] - nameIndex); nameIndex = segment[4]; } lineMappings.push(segmentMappings); } mappings += lineMappings.join(','); } return mappings; } function encodeInteger(num) { var result = ''; num = num < 0 ? (-num << 1) \| 1 : num << 1; do { var clamped = num & 31; num >>>= 5; if (num > 0) { clamped \|= 32; } result += chars[clamped]; } while (num > 0); return result; } var BitSet = function BitSet(arg) { this.bits = arg instanceof BitSet ? arg.bits.slice() : []; }; BitSet.prototype.add = function add (n) { this.bits[n >> 5] \|= 1 << (n & 31); }; BitSet.prototype.has = function has (n) { return !!(this.bits[n >> 5] & (1 << (n & 31))); }; var Chunk = function Chunk(start, end, content) { this.start = start; this.end = end; this.original = content; this.intro = ''; this.outro = ''; this.content = content; this.storeName = false; this.edited = false; // we make these non-enumerable, for sanity while debugging Object.defineProperties(this, { previous: { writable: true, value: null }, next: { writable: true, value: null }, }); }; Chunk.prototype.appendLeft = function appendLeft (content) { this.outro += content; }; Chunk.prototype.appendRight = function appendRight (content) { this.intro = this.intro + content; }; Chunk.prototype.clone = function clone () { var chunk = new Chunk(this.start, this.end, this.original); chunk.intro = this.intro; chunk.outro = this.outro; chunk.content = this.content; chunk.storeName = this.storeName; chunk.edited = this.edited; return chunk; }; Chunk.prototype.contains = function contains (index) { return this.start < index && index < this.end; }; Chunk.prototype.eachNext = function eachNext (fn) { var chunk = this; while (chunk) { fn(chunk); chunk = chunk.next; } }; Chunk.prototype.eachPrevious = function eachPrevious (fn) { var chunk = this; while (chunk) { fn(chunk); chunk = chunk.previous; } }; Chunk.prototype.edit = function edit (content, storeName, contentOnly) { this.content = content; if (!contentOnly) { this.intro = ''; this.outro = ''; } this.storeName = storeName; this.edited = true; return this; }; Chunk.prototype.prependLeft = function prependLeft (content) { this.outro = content + this.outro; }; Chunk.prototype.prependRight = function prependRight (content) { this.intro = content + this.intro; }; Chunk.prototype.split = function split (index) { var sliceIndex = index - this.start; var originalBefore = this.original.slice(0, sliceIndex); var originalAfter = this.original.slice(sliceIndex); this.original = originalBefore; var newChunk = new Chunk(index, this.end, originalAfter); newChunk.outro = this.outro; this.outro = ''; this.end = index; if (this.edited) { // TODO is this block necessary?... newChunk.edit('', false); this.content = ''; } else { this.content = originalBefore; } newChunk.next = this.next; if (newChunk.next) { newChunk.next.previous = newChunk; } newChunk.previous = this; this.next = newChunk; return newChunk; }; Chunk.prototype.toString = function toString () { return this.intro + this.content + this.outro; }; Chunk.prototype.trimEnd = function trimEnd (rx) { this.outro = this.outro.replace(rx, ''); if (this.outro.length) { return true; } var trimmed = this.content.replace(rx, ''); if (trimmed.length) { if (trimmed !== this.content) { this.split(this.start + trimmed.length).edit('', undefined, true); } return true; } else { this.edit('', undefined, true); this.intro = this.intro.replace(rx, ''); if (this.intro.length) { return true; } } }; Chunk.prototype.trimStart = function trimStart (rx) { this.intro = this.intro.replace(rx, ''); if (this.intro.length) { return true; } var trimmed = this.content.replace(rx, ''); if (trimmed.length) { if (trimmed !== this.content) { this.split(this.end - trimmed.length); this.edit('', undefined, true); } return true; } else { this.edit('', undefined, true); this.outro = this.outro.replace(rx, ''); if (this.outro.length) { return true; } } }; var btoa = function () { throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.'); }; if (typeof window !== 'undefined' && typeof window.btoa === 'function') { btoa = function (str) { return window.btoa(unescape(encodeURIComponent(str))); }; } else if (typeof Buffer === 'function') { btoa = function (str) { return Buffer.from(str, 'utf-8').toString('base64'); }; } var SourceMap = function SourceMap(properties) { this.version = 3; this.file = properties.file; this.sources = properties.sources; this.sourcesContent = properties.sourcesContent; this.names = properties.names; this.mappings = encode(properties.mappings); }; SourceMap.prototype.toString = function toString () { return JSON.stringify(this); }; SourceMap.prototype.toUrl = function toUrl () { return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString()); }; function guessIndent(code) { var lines = code.split('\n'); var tabbed = lines.filter(function (line) { return /^\t+/.test(line); }); var spaced = lines.filter(function (line) { return /^ {2,}/.test(line); }); if (tabbed.length === 0 && spaced.length === 0) { return null; } // More lines tabbed than spaced? Assume tabs, and // default to tabs in the case of a tie (or nothing // to go on) if (tabbed.length >= spaced.length) { return '\t'; } // Otherwise, we need to guess the multiple var min = spaced.reduce(function (previous, current) { var numSpaces = /^ +/.exec(current)[0].length; return Math.min(numSpaces, previous); }, Infinity); return new Array(min + 1).join(' '); } function getRelativePath(from, to) { var fromParts = from.split(/[/\\]/); var toParts = to.split(/[/\\]/); fromParts.pop(); // get dirname while (fromParts[0] === toParts[0]) { fromParts.shift(); toParts.shift(); } if (fromParts.length) { var i = fromParts.length; while (i--) { fromParts[i] = '..'; } } return fromParts.concat(toParts).join('/'); } var toString = Object.prototype.toString; function isObject(thing) { return toString.call(thing) === '[object Object]'; } function getLocator(source) { var originalLines = source.split('\n'); var lineOffsets = []; for (var i = 0, pos = 0; i < originalLines.length; i++) { lineOffsets.push(pos); pos += originalLines[i].length + 1; } return function locate(index) { var i = 0; var j = lineOffsets.length; while (i < j) { var m = (i + j) >> 1; if (index < lineOffsets[m]) { j = m; } else { i = m + 1; } } var line = i - 1; var column = index - lineOffsets[line]; return { line: line, column: column }; }; } var Mappings = function Mappings(hires) { this.hires = hires; this.generatedCodeLine = 0; this.generatedCodeColumn = 0; this.raw = []; this.rawSegments = this.raw[this.generatedCodeLine] = []; this.pending = null; }; Mappings.prototype.addEdit = function addEdit (sourceIndex, content, loc, nameIndex) { if (content.length) { var segment = [this.generatedCodeColumn, sourceIndex, loc.line, loc.column]; if (nameIndex >= 0) { segment.push(nameIndex); } this.rawSegments.push(segment); } else if (this.pending) { this.rawSegments.push(this.pending); } this.advance(content); this.pending = null; }; Mappings.prototype.addUneditedChunk = function addUneditedChunk (sourceIndex, chunk, original, loc, sourcemapLocations) { var originalCharIndex = chunk.start; var first = true; while (originalCharIndex < chunk.end) { if (this.hires \|\| first \|\| sourcemapLocations.has(originalCharIndex)) { this.rawSegments.push([this.generatedCodeColumn, sourceIndex, loc.line, loc.column]); } if (original[originalCharIndex] === '\n') { loc.line += 1; loc.column = 0; this.generatedCodeLine += 1; this.raw[this.generatedCodeLine] = this.rawSegments = []; this.generatedCodeColumn = 0; first = true; } else { loc.column += 1; this.generatedCodeColumn += 1; first = false; } originalCharIndex += 1; } this.pending = null; }; Mappings.prototype.advance = function advance (str) { if (!str) { return; } var lines = str.split('\n'); if (lines.length > 1) { for (var i = 0; i < lines.length - 1; i++) { this.generatedCodeLine++; this.raw[this.generatedCodeLine] = this.rawSegments = []; } this.generatedCodeColumn = 0; } this.generatedCodeColumn += lines[lines.length - 1].length; }; var n = '\n'; var warned = { insertLeft: false, insertRight: false, storeName: false, }; var MagicString = function MagicString(string, options) { if ( options === void 0 ) options = {}; var chunk = new Chunk(0, string.length, string); Object.defineProperties(this, { original: { writable: true, value: string }, outro: { writable: true, value: '' }, intro: { writable: true, value: '' }, firstChunk: { writable: true, value: chunk }, lastChunk: { writable: true, value: chunk }, lastSearchedChunk: { writable: true, value: chunk }, byStart: { writable: true, value: {} }, byEnd: { writable: true, value: {} }, filename: { writable: true, value: options.filename }, indentExclusionRanges: { writable: true, value: options.indentExclusionRanges }, sourcemapLocations: { writable: true, value: new BitSet() }, storedNames: { writable: true, value: {} }, indentStr: { writable: true, value: guessIndent(string) }, }); this.byStart[0] = chunk; this.byEnd[string.length] = chunk; }; MagicString.prototype.addSourcemapLocation = function addSourcemapLocation (char) { this.sourcemapLocations.add(char); }; MagicString.prototype.append = function append (content) { if (typeof content !== 'string') { throw new TypeError('outro content must be a string'); } this.outro += content; return this; }; MagicString.prototype.appendLeft = function appendLeft (index, content) { if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); } this._split(index); var chunk = this.byEnd[index]; if (chunk) { chunk.appendLeft(content); } else { this.intro += content; } return this; }; MagicString.prototype.appendRight = function appendRight (index, content) { if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); } this._split(index); var chunk = this.byStart[index]; if (chunk) { chunk.appendRight(content); } else { this.outro += content; } return this; }; MagicString.prototype.clone = function clone () { var cloned = new MagicString(this.original, { filename: this.filename }); var originalChunk = this.firstChunk; var clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone()); while (originalChunk) { cloned.byStart[clonedChunk.start] = clonedChunk; cloned.byEnd[clonedChunk.end] = clonedChunk; var nextOriginalChunk = originalChunk.next; var nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone(); if (nextClonedChunk) { clonedChunk.next = nextClonedChunk; nextClonedChunk.previous = clonedChunk; clonedChunk = nextClonedChunk; } originalChunk = nextOriginalChunk; } cloned.lastChunk = clonedChunk; if (this.indentExclusionRanges) { cloned.indentExclusionRanges = this.indentExclusionRanges.slice(); } cloned.sourcemapLocations = new BitSet(this.sourcemapLocations); cloned.intro = this.intro; cloned.outro = this.outro; return cloned; }; MagicString.prototype.generateDecodedMap = function generateDecodedMap (options) { var this$1$1 = this; options = options \|\| {}; var sourceIndex = 0; var names = Object.keys(this.storedNames); var mappings = new Mappings(options.hires); var locate = getLocator(this.original); if (this.intro) { mappings.advance(this.intro); } this.firstChunk.eachNext(function (chunk) { var loc = locate(chunk.start); if (chunk.intro.length) { mappings.advance(chunk.intro); } if (chunk.edited) { mappings.addEdit( sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1 ); } else { mappings.addUneditedChunk(sourceIndex, chunk, this$1$1.original, loc, this$1$1.sourcemapLocations); } if (chunk.outro.length) { mappings.advance(chunk.outro); } }); return { file: options.file ? options.file.split(/[/\\]/).pop() : null, sources: [options.source ? getRelativePath(options.file \|\| '', options.source) : null], sourcesContent: options.includeContent ? [this.original] : [null], names: names, mappings: mappings.raw, }; }; MagicString.prototype.generateMap = function generateMap (options) { return new SourceMap(this.generateDecodedMap(options)); }; MagicString.prototype.getIndentString = function getIndentString () { return this.indentStr === null ? '\t' : this.indentStr; }; MagicString.prototype.indent = function indent (indentStr, options) { var pattern = /^[^\r\n]/gm; if (isObject(indentStr)) { options = indentStr; indentStr = undefined; } indentStr = indentStr !== undefined ? indentStr : this.indentStr \|\| '\t'; if (indentStr === '') { return this; } // noop options = options \|\| {}; // Process exclusion ranges var isExcluded = {}; if (options.exclude) { var exclusions = typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude; exclusions.forEach(function (exclusion) { for (var i = exclusion[0]; i < exclusion[1]; i += 1) { isExcluded[i] = true; } }); } var shouldIndentNextCharacter = options.indentStart !== false; var replacer = function (match) { if (shouldIndentNextCharacter) { return ("" + indentStr + match); } shouldIndentNextCharacter = true; return match; }; this.intro = this.intro.replace(pattern, replacer); var charIndex = 0; var chunk = this.firstChunk; while (chunk) { var end = chunk.end; if (chunk.edited) { if (!isExcluded[charIndex]) { chunk.content = chunk.content.replace(pattern, replacer); if (chunk.content.length) { shouldIndentNextCharacter = chunk.content[chunk.content.length - 1] === '\n'; } } } else { charIndex = chunk.start; while (charIndex < end) { if (!isExcluded[charIndex]) { var char = this.original[charIndex]; if (char === '\n') { shouldIndentNextCharacter = true; } else if (char !== '\r' && shouldIndentNextCharacter) { shouldIndentNextCharacter = false; if (charIndex === chunk.start) { chunk.prependRight(indentStr); } else { this._splitChunk(chunk, charIndex); chunk = chunk.next; chunk.prependRight(indentStr); } } } charIndex += 1; } } charIndex = chunk.end; chunk = chunk.next; } this.outro = this.outro.replace(pattern, replacer); return this; }; MagicString.prototype.insert = function insert () { throw new Error( 'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)' ); }; MagicString.prototype.insertLeft = function insertLeft (index, content) { if (!warned.insertLeft) { console.warn( 'magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead' ); // eslint-disable-line no-console warned.insertLeft = true; } return this.appendLeft(index, content); }; MagicString.prototype.insertRight = function insertRight (index, content) { if (!warned.insertRight) { console.warn( 'magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead' ); // eslint-disable-line no-console warned.insertRight = true; } return this.prependRight(index, content); }; MagicString.prototype.move = function move (start, end, index) { if (index >= start && index <= end) { throw new Error('Cannot move a selection inside itself'); } this._split(start); this._split(end); this._split(index); var first = this.byStart[start]; var last = this.byEnd[end]; var oldLeft = first.previous; var oldRight = last.next; var newRight = this.byStart[index]; if (!newRight && last === this.lastChunk) { return this; } var newLeft = newRight ? newRight.previous : this.lastChunk; if (oldLeft) { oldLeft.next = oldRight; } if (oldRight) { oldRight.previous = oldLeft; } if (newLeft) { newLeft.next = first; } if (newRight) { newRight.previous = last; } if (!first.previous) { this.firstChunk = last.next; } if (!last.next) { this.lastChunk = first.previous; this.lastChunk.next = null; } first.previous = newLeft; last.next = newRight \|\| null; if (!newLeft) { this.firstChunk = first; } if (!newRight) { this.lastChunk = last; } return this; }; MagicString.prototype.overwrite = function overwrite (start, end, content, options) { if (typeof content !== 'string') { throw new TypeError('replacement content must be a string'); } while (start < 0) { start += this.original.length; } while (end < 0) { end += this.original.length; } if (end > this.original.length) { throw new Error('end is out of bounds'); } if (start === end) { throw new Error( 'Cannot overwrite a zero-length range – use appendLeft or prependRight instead' ); } this._split(start); this._split(end); if (options === true) { if (!warned.storeName) { console.warn( 'The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string' ); // eslint-disable-line no-console warned.storeName = true; } options = { storeName: true }; } var storeName = options !== undefined ? options.storeName : false; var contentOnly = options !== undefined ? options.contentOnly : false; if (storeName) { var original = this.original.slice(start, end); Object.defineProperty(this.storedNames, original, { writable: true, value: true, enumerable: true }); } var first = this.byStart[start]; var last = this.byEnd[end]; if (first) { var chunk = first; while (chunk !== last) { if (chunk.next !== this.byStart[chunk.end]) { throw new Error('Cannot overwrite across a split point'); } chunk = chunk.next; chunk.edit('', false); } first.edit(content, storeName, contentOnly); } else { // must be inserting at the end var newChunk = new Chunk(start, end, '').edit(content, storeName); // TODO last chunk in the array may not be the last chunk, if it's moved... last.next = newChunk; newChunk.previous = last; } return this; }; MagicString.prototype.prepend = function prepend (content) { if (typeof content !== 'string') { throw new TypeError('outro content must be a string'); } this.intro = content + this.intro; return this; }; MagicString.prototype.prependLeft = function prependLeft (index, content) { if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); } this._split(index); var chunk = this.byEnd[index]; if (chunk) { chunk.prependLeft(content); } else { this.intro = content + this.intro; } return this; }; MagicString.prototype.prependRight = function prependRight (index, content) { if (typeof content !== 'string') { throw new TypeError('inserted content must be a string'); } this._split(index); var chunk = this.byStart[index]; if (chunk) { chunk.prependRight(content); } else { this.outro = content + this.outro; } return this; }; MagicString.prototype.remove = function remove (start, end) { while (start < 0) { start += this.original.length; } while (end < 0) { end += this.original.length; } if (start === end) { return this; } if (start < 0 \|\| end > this.original.length) { throw new Error('Character is out of bounds'); } if (start > end) { throw new Error('end must be greater than start'); } this._split(start); this._split(end); var chunk = this.byStart[start]; while (chunk) { chunk.intro = ''; chunk.outro = ''; chunk.edit(''); chunk = end > chunk.end ? this.byStart[chunk.end] : null; } return this; }; MagicString.prototype.lastChar = function lastChar () { if (this.outro.length) { return this.outro[this.outro.length - 1]; } var chunk = this.lastChunk; do { if (chunk.outro.length) { return chunk.outro[chunk.outro.length - 1]; } if (chunk.content.length) { return chunk.content[chunk.content.length - 1]; } if (chunk.intro.length) { return chunk.intro[chunk.intro.length - 1]; } } while ((chunk = chunk.previous)); if (this.intro.length) { return this.intro[this.intro.length - 1]; } return ''; }; MagicString.prototype.lastLine = function lastLine () { var lineIndex = this.outro.lastIndexOf(n); if (lineIndex !== -1) { return this.outro.substr(lineIndex + 1); } var lineStr = this.outro; var chunk = this.lastChunk; do { if (chunk.outro.length > 0) { lineIndex = chunk.outro.lastIndexOf(n); if (lineIndex !== -1) { return chunk.outro.substr(lineIndex + 1) + lineStr; } lineStr = chunk.outro + lineStr; } if (chunk.content.length > 0) { lineIndex = chunk.content.lastIndexOf(n); if (lineIndex !== -1) { return chunk.content.substr(lineIndex + 1) + lineStr; } lineStr = chunk.content + lineStr; } if (chunk.intro.length > 0) { lineIndex = chunk.intro.lastIndexOf(n); if (lineIndex !== -1) { return chunk.intro.substr(lineIndex + 1) + lineStr; } lineStr = chunk.intro + lineStr; } } while ((chunk = chunk.previous)); lineIndex = this.intro.lastIndexOf(n); if (lineIndex !== -1) { return this.intro.substr(lineIndex + 1) + lineStr; } return this.intro + lineStr; }; MagicString.prototype.slice = function slice (start, end) { if ( start === void 0 ) start = 0; if ( end === void 0 ) end = this.original.length; while (start < 0) { start += this.original.length; } while (end < 0) { end += this.original.length; } var result = ''; // find start chunk var chunk = this.firstChunk; while (chunk && (chunk.start > start \|\| chunk.end <= start)) { // found end chunk before start if (chunk.start < end && chunk.end >= end) { return result; } chunk = chunk.next; } if (chunk && chunk.edited && chunk.start !== start) { throw new Error(("Cannot use replaced character " + start + " as slice start anchor.")); } var startChunk = chunk; while (chunk) { if (chunk.intro && (startChunk !== chunk \|\| chunk.start === start)) { result += chunk.intro; } var containsEnd = chunk.start < end && chunk.end >= end; if (containsEnd && chunk.edited && chunk.end !== end) { throw new Error(("Cannot use replaced character " + end + " as slice end anchor.")); } var sliceStart = startChunk === chunk ? start - chunk.start : 0; var sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length; result += chunk.content.slice(sliceStart, sliceEnd); if (chunk.outro && (!containsEnd \|\| chunk.end === end)) { result += chunk.outro; } if (containsEnd) { break; } chunk = chunk.next; } return result; }; // TODO deprecate this? not really very useful MagicString.prototype.snip = function snip (start, end) { var clone = this.clone(); clone.remove(0, start); clone.remove(end, clone.original.length); return clone; }; MagicString.prototype._split = function _split (index) { if (this.byStart[index] \|\| this.byEnd[index]) { return; } var chunk = this.lastSearchedChunk; var searchForward = index > chunk.end; while (chunk) { if (chunk.contains(index)) { return this._splitChunk(chunk, index); } chunk = searchForward ? this.byStart[chunk.end] : this.byEnd[chunk.start]; } }; MagicString.prototype._splitChunk = function _splitChunk (chunk, index) { if (chunk.edited && chunk.content.length) { // zero-length edited chunks are a special case (overlapping replacements) var loc = getLocator(this.original)(index); throw new Error( ("Cannot split a chunk that has already been edited (" + (loc.line) + ":" + (loc.column) + " – \"" + (chunk.original) + "\")") ); } var newChunk = chunk.split(index); this.byEnd[index] = chunk; this.byStart[index] = newChunk; this.byEnd[newChunk.end] = newChunk; if (chunk === this.lastChunk) { this.lastChunk = newChunk; } this.lastSearchedChunk = chunk; return true; }; MagicString.prototype.toString = function toString () { var str = this.intro; var chunk = this.firstChunk; while (chunk) { str += chunk.toString(); chunk = chunk.next; } return str + this.outro; }; MagicString.prototype.isEmpty = function isEmpty () { var chunk = this.firstChunk; do { if ( (chunk.intro.length && chunk.intro.trim()) \|\| (chunk.content.length && chunk.content.trim()) \|\| (chunk.outro.length && chunk.outro.trim()) ) { return false; } } while ((chunk = chunk.next)); return true; }; MagicString.prototype.length = function length () { var chunk = this.firstChunk; var length = 0; do { length += chunk.intro.length + chunk.content.length + chunk.outro.length; } while ((chunk = chunk.next)); return length; }; MagicString.prototype.trimLines = function trimLines () { return this.trim('[\\r\\n]'); }; MagicString.prototype.trim = function trim (charType) { return this.trimStart(charType).trimEnd(charType); }; MagicString.prototype.trimEndAborted = function trimEndAborted (charType) { var rx = new RegExp((charType \|\| '\\s') + '+$'); this.outro = this.outro.replace(rx, ''); if (this.outro.length) { return true; } var chunk = this.lastChunk; do { var end = chunk.end; var aborted = chunk.trimEnd(rx); // if chunk was trimmed, we have a new lastChunk if (chunk.end !== end) { if (this.lastChunk === chunk) { this.lastChunk = chunk.next; } this.byEnd[chunk.end] = chunk; this.byStart[chunk.next.start] = chunk.next; this.byEnd[chunk.next.end] = chunk.next; } if (aborted) { return true; } chunk = chunk.previous; } while (chunk); return false; }; MagicString.prototype.trimEnd = function trimEnd (charType) { this.trimEndAborted(charType); return this; }; MagicString.prototype.trimStartAborted = function trimStartAborted (charType) { var rx = new RegExp('^' + (charType \|\| '\\s') + '+'); this.intro = this.intro.replace(rx, ''); if (this.intro.length) { return true; } var chunk = this.firstChunk; do { var end = chunk.end; var aborted = chunk.trimStart(rx); if (chunk.end !== end) { // special case... if (chunk === this.lastChunk) { this.lastChunk = chunk.next; } this.byEnd[chunk.end] = chunk; this.byStart[chunk.next.start] = chunk.next; this.byEnd[chunk.next.end] = chunk.next; } if (aborted) { return true; } chunk = chunk.next; } while (chunk); return false; }; MagicString.prototype.trimStart = function trimStart (charType) { this.trimStartAborted(charType); return this; }; // @ts-check /** @typedef { import('estree').BaseNode} BaseNode / /* @typedef {{ skip: () => void; remove: () => void; replace: (node: BaseNode) => void; }} WalkerContext / class WalkerBase { constructor() { /* @type {boolean} / this.should_skip = false; /* @type {boolean} / this.should_remove = false; /* @type {BaseNode \| null} / this.replacement = null; /* @type {WalkerContext} / this.context = { skip: () => (this.should_skip = true), remove: () => (this.should_remove = true), replace: (node) => (this.replacement = node) }; } /* * * @param {any} parent * @param {string} prop * @param {number} index * @param {BaseNode} node / replace(parent, prop, index, node) { if (parent) { if (index !== null) { parent[prop][index] = node; } else { parent[prop] = node; } } } /* * * @param {any} parent * @param {string} prop * @param {number} index / remove(parent, prop, index) { if (parent) { if (index !== null) { parent[prop].splice(index, 1); } else { delete parent[prop]; } } } } // @ts-check /* @typedef { import('estree').BaseNode} BaseNode / /* @typedef { import('./walker.js').WalkerContext} WalkerContext / /* @typedef {( * this: WalkerContext, * node: BaseNode, * parent: BaseNode, * key: string, * index: number * ) => void} SyncHandler / class SyncWalker extends WalkerBase { /* * * @param {SyncHandler} enter * @param {SyncHandler} leave / constructor(enter, leave) { super(); /* @type {SyncHandler} / this.enter = enter; /* @type {SyncHandler} / this.leave = leave; } /* * * @param {BaseNode} node * @param {BaseNode} parent * @param {string} [prop] * @param {number} [index] * @returns {BaseNode} / visit(node, parent, prop, index) { if (node) { if (this.enter) { const _should_skip = this.should_skip; const _should_remove = this.should_remove; const _replacement = this.replacement; this.should_skip = false; this.should_remove = false; this.replacement = null; this.enter.call(this.context, node, parent, prop, index); if (this.replacement) { node = this.replacement; this.replace(parent, prop, index, node); } if (this.should_remove) { this.remove(parent, prop, index); } const skipped = this.should_skip; const removed = this.should_remove; this.should_skip = _should_skip; this.should_remove = _should_remove; this.replacement = _replacement; if (skipped) return node; if (removed) return null; } for (const key in node) { const value = node[key]; if (typeof value !== "object") { continue; } else if (Array.isArray(value)) { for (let i = 0; i < value.length; i += 1) { if (value[i] !== null && typeof value[i].type === 'string') { if (!this.visit(value[i], node, key, i)) { // removed i--; } } } } else if (value !== null && typeof value.type === "string") { this.visit(value, node, key, null); } } if (this.leave) { const _replacement = this.replacement; const _should_remove = this.should_remove; this.replacement = null; this.should_remove = false; this.leave.call(this.context, node, parent, prop, index); if (this.replacement) { node = this.replacement; this.replace(parent, prop, index, node); } if (this.should_remove) { this.remove(parent, prop, index); } const removed = this.should_remove; this.replacement = _replacement; this.should_remove = _should_remove; if (removed) return null; } } return node; } } // @ts-check /* @typedef { import('estree').BaseNode} BaseNode / /* @typedef { import('./sync.js').SyncHandler} SyncHandler / /* @typedef { import('./async.js').AsyncHandler} AsyncHandler / /* * * @param {BaseNode} ast * @param {{ * enter?: SyncHandler * leave?: SyncHandler * }} walker * @returns {BaseNode} / function walk$1(ast, { enter, leave }) { const instance = new SyncWalker(enter, leave); return instance.visit(ast, null); } // https://github.com/vuejs/core/blob/main/packages/compiler-core/src/babelUtils.ts function walkIdentifiers(root, onIdentifier, onNode) { const parentStack = []; const knownIds = Object.create(null); const rootExp = root.type === 'Program' && root.body[0].type === 'ExpressionStatement' && root.body[0].expression; walk$1(root, { enter(node, parent) { parent && parentStack.push(parent); if (parent && parent.type.startsWith('TS') && parent.type !== 'TSAsExpression' && parent.type !== 'TSNonNullExpression' && parent.type !== 'TSTypeAssertion') { return this.skip(); } if (onNode) onNode(node); if (node.type === 'Identifier') { const isLocal = !!knownIds[node.name]; const isRefed = isReferencedIdentifier(node, parent, parentStack); if ((isRefed && !isLocal)) { onIdentifier(node, parent, parentStack, isRefed, isLocal); } } else if (node.type === 'ObjectProperty' && parent.type === 'ObjectPattern') { node.inPattern = true; } else if (isFunctionType(node)) { // walk function expressions and add its arguments to known identifiers // so that we don't prefix them walkFunctionParams(node, id => markScopeIdentifier(node, id, knownIds)); } else if (node.type === 'BlockStatement') { // #3445 record block-level local variables walkBlockDeclarations(node, id => markScopeIdentifier(node, id, knownIds)); } }, leave(node, parent) { parent && parentStack.pop(); if (node !== rootExp && node.scopeIds) { for (const id of node.scopeIds) { knownIds[id]--; if (knownIds[id] === 0) { delete knownIds[id]; } } } } }); } function isReferencedIdentifier(id, parent, parentStack) { if (!parent) { return true; } // is a special keyword but parsed as identifier if (id.name === 'arguments') { return false; } if (isReferenced(id, parent)) { return true; } // babel's isReferenced check returns false for ids being assigned to, so we // need to cover those cases here switch (parent.type) { case 'AssignmentExpression': case 'AssignmentPattern': return true; case 'ObjectPattern': case 'ArrayPattern': return isInDestructureAssignment(parent, parentStack); } return false; } function isInDestructureAssignment(parent, parentStack) { if (parent && (parent.type === 'ObjectProperty' \|\| parent.type === 'ArrayPattern')) { let i = parentStack.length; while (i--) { const p = parentStack[i]; if (p.type === 'AssignmentExpression') { return true; } else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) { break; } } } return false; } function walkFunctionParams(node, onIdent) { for (const p of node.params) { for (const id of extractIdentifiers(p)) { onIdent(id); } } } function walkBlockDeclarations(block, onIdent) { for (const stmt of block.body) { if (stmt.type === 'VariableDeclaration') { if (stmt.declare) continue; for (const decl of stmt.declarations) { for (const id of extractIdentifiers(decl.id)) { onIdent(id); } } } else if (stmt.type === 'FunctionDeclaration' \|\| stmt.type === 'ClassDeclaration') { if (stmt.declare \|\| !stmt.id) continue; onIdent(stmt.id); } } } function extractIdentifiers(param, nodes = []) { switch (param.type) { case 'Identifier': nodes.push(param); break; case 'MemberExpression': let object = param; while (object.type === 'MemberExpression') { object = object.object; } nodes.push(object); break; case 'ObjectPattern': for (const prop of param.properties) { if (prop.type === 'RestElement') { extractIdentifiers(prop.argument, nodes); } else { extractIdentifiers(prop.value, nodes); } } break; case 'ArrayPattern': param.elements.forEach(element => { if (element) extractIdentifiers(element, nodes); }); break; case 'RestElement': extractIdentifiers(param.argument, nodes); break; case 'AssignmentPattern': extractIdentifiers(param.left, nodes); break; } return nodes; } function markScopeIdentifier(node, child, knownIds) { const { name } = child; if (node.scopeIds && node.scopeIds.has(name)) { return; } if (name in knownIds) { knownIds[name]++; } else { knownIds[name] = 1; } (node.scopeIds \|\| (node.scopeIds = new Set())).add(name); } const isFunctionType = (node) => { return /Function(?:Expression\|Declaration)$\|Method$/.test(node.type); }; const isStaticProperty = (node) => node && (node.type === 'ObjectProperty' \|\| node.type === 'ObjectMethod') && !node.computed; /* * Copied from https://github.com/babel/babel/blob/main/packages/babel-types/src/validators/isReferenced.ts * To avoid runtime dependency on @babel/types (which includes process references) * This file should not change very often in babel but we may need to keep it * up-to-date from time to time. * * https://github.com/babel/babel/blob/main/LICENSE * / function isReferenced(node, parent, grandparent) { switch (parent.type) { // yes: PARENT[NODE] // yes: NODE.child // no: parent.NODE case 'MemberExpression': case 'OptionalMemberExpression': if (parent.property === node) { return !!parent.computed; } return parent.object === node; case 'JSXMemberExpression': return parent.object === node; // no: let NODE = init; // yes: let id = NODE; case 'VariableDeclarator': return parent.init === node; // yes: () => NODE // no: (NODE) => {} case 'ArrowFunctionExpression': return parent.body === node; // no: class { #NODE; } // no: class { get #NODE() {} } // no: class { #NODE() {} } // no: class { fn() { return this.#NODE; } } case 'PrivateName': return false; // no: class { NODE() {} } // yes: class { [NODE]() {} } // no: class { foo(NODE) {} } case 'ClassMethod': case 'ClassPrivateMethod': case 'ObjectMethod': if (parent.key === node) { return !!parent.computed; } return false; // yes: { [NODE]: "" } // no: { NODE: "" } // depends: { NODE } // depends: { key: NODE } case 'ObjectProperty': if (parent.key === node) { return !!parent.computed; } // parent.value === node return !grandparent \|\| grandparent.type !== 'ObjectPattern'; // no: class { NODE = value; } // yes: class { [NODE] = value; } // yes: class { key = NODE; } case 'ClassProperty': if (parent.key === node) { return !!parent.computed; } return true; case 'ClassPrivateProperty': return parent.key !== node; // no: class NODE {} // yes: class Foo extends NODE {} case 'ClassDeclaration': case 'ClassExpression': return parent.superClass === node; // yes: left = NODE; // no: NODE = right; case 'AssignmentExpression': return parent.right === node; // no: [NODE = foo] = []; // yes: [foo = NODE] = []; case 'AssignmentPattern': return parent.right === node; // no: NODE: for (;;) {} case 'LabeledStatement': return false; // no: try {} catch (NODE) {} case 'CatchClause': return false; // no: function foo(...NODE) {} case 'RestElement': return false; case 'BreakStatement': case 'ContinueStatement': return false; // no: function NODE() {} // no: function foo(NODE) {} case 'FunctionDeclaration': case 'FunctionExpression': return false; // no: export NODE from "foo"; // no: export as NODE from "foo"; case 'ExportNamespaceSpecifier': case 'ExportDefaultSpecifier': return false; // no: export { foo as NODE }; // yes: export { NODE as foo }; // no: export { NODE as foo } from "foo"; case 'ExportSpecifier': // @ts-expect-error if (grandparent === null \|\| grandparent === void 0 ? void 0 : grandparent.source) { return false; } return parent.local === node; // no: import NODE from "foo"; // no: import * as NODE from "foo"; // no: import { NODE as foo } from "foo"; // no: import { foo as NODE } from "foo"; // no: import NODE from "bar"; case 'ImportDefaultSpecifier': case 'ImportNamespaceSpecifier': case 'ImportSpecifier': return false; // no: import "foo" assert { NODE: "json" } case 'ImportAttribute': return false; // no: <div NODE="foo" /> case 'JSXAttribute': return false; // no: [NODE] = []; // no: ({ NODE }) = []; case 'ObjectPattern': case 'ArrayPattern': return false; // no: new.NODE // no: NODE.target case 'MetaProperty': return false; // yes: type X = { someProperty: NODE } // no: type X = { NODE: OtherType } case 'ObjectTypeProperty': return parent.key !== node; // yes: enum X { Foo = NODE } // no: enum X { NODE } case 'TSEnumMember': return parent.id !== node; // yes: { [NODE]: value } // no: { NODE: value } case 'TSPropertySignature': if (parent.key === node) { return !!parent.computed; } return true; } return true; } const range = 2; function generateCodeFrame(source, start = 0, end = source.length) { const lines = source.split(/\r?\n/); let count = 0; const res = []; for (let i = 0; i < lines.length; i++) { count += lines[i].length + 1; if (count >= start) { for (let j = i - range; j <= i + range \|\| end > count; j++) { if (j < 0 \|\| j >= lines.length) continue; res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}\| ${lines[j]}`); const lineLength = lines[j].length; if (j === i) { // push underline const pad = start - (count - lineLength) + 1; const length = end > count ? lineLength - pad : end - start; res.push(` \| ` + repeat(` `, pad) + repeat(`^`, length)); } else if (j > i) { if (end > count) { const length = Math.min(end - count, lineLength); res.push(` \| ` + repeat(`^`, length)); } count += lineLength + 1; } } break; } } return res.join('\n'); } function repeat(str, n) { let result = ''; if (n > 0) { // eslint-disable-next-line no-constant-condition while (true) { // eslint-disable-line if (n & 1) result += str; n >>>= 1; if (n <= 0) break; str += str; } } return result; } // can we use __proto__? const hasProto = '__proto__' in {}; // Browser environment sniffing const inBrowser = typeof window !== 'undefined'; const UA = inBrowser && window.navigator.userAgent.toLowerCase(); const isIE = UA && /msie\|trident/.test(UA); UA && UA.indexOf('msie 9.0') > 0; const isEdge = UA && UA.indexOf('edge/') > 0; UA && UA.indexOf('android') > 0; UA && /iphone\|ipad\|ipod\|ios/.test(UA); UA && /chrome\/\d+/.test(UA) && !isEdge; UA && /phantomjs/.test(UA); UA && UA.match(/firefox\/(\d+)/); // Firefox has a "watch" function on Object.prototype... // @ts-expect-error firebox support const nativeWatch = {}.watch; let supportsPassive = false; if (inBrowser) { try { const opts = {}; Object.defineProperty(opts, 'passive', { get() { /* istanbul ignore next / supportsPassive = true; } }); // https://github.com/facebook/flow/issues/285 window.addEventListener('test-passive', null, opts); } catch (e) { } } // this needs to be lazy-evaled because vue may be required before // vue-server-renderer can set VUE_ENV let _isServer; const isServerRendering = () => { if (_isServer === undefined) { / istanbul ignore if / if (!inBrowser && typeof global !== 'undefined') { // detect presence of vue-server-renderer and avoid // Webpack shimming the process _isServer = global['process'] && global['process'].env.VUE_ENV === 'server'; } else { _isServer = false; } } return _isServer; }; / istanbul ignore next / function isNative(Ctor) { return typeof Ctor === 'function' && /native code/.test(Ctor.toString()); } const hasSymbol = typeof Symbol !== 'undefined' && isNative(Symbol) && typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys); let _Set; // $flow-disable-line / istanbul ignore if / if (typeof Set !== 'undefined' && isNative(Set)) { // use native Set when available. _Set = Set; } else { // a non-standard Set polyfill that only works with primitive keys. _Set = class Set { constructor() { this.set = Object.create(null); } has(key) { return this.set[key] === true; } add(key) { this.set[key] = true; } clear() { this.set = Object.create(null); } }; } const ASSET_TYPES = ['component', 'directive', 'filter']; const LIFECYCLE_HOOKS = [ 'beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeUpdate', 'updated', 'beforeDestroy', 'destroyed', 'activated', 'deactivated', 'errorCaptured', 'serverPrefetch', 'renderTracked', 'renderTriggered' ]; var config = { /* * Option merge strategies (used in core/util/options) / // $flow-disable-line optionMergeStrategies: Object.create(null), /* * Whether to suppress warnings. / silent: false, /* * Show production mode tip message on boot? / productionTip: process.env.NODE_ENV !== 'production', /* * Whether to enable devtools / devtools: process.env.NODE_ENV !== 'production', /* * Whether to record perf / performance: false, /* * Error handler for watcher errors / errorHandler: null, /* * Warn handler for watcher warns / warnHandler: null, /* * Ignore certain custom elements / ignoredElements: [], /* * Custom user key aliases for v-on / // $flow-disable-line keyCodes: Object.create(null), /* * Check if a tag is reserved so that it cannot be registered as a * component. This is platform-dependent and may be overwritten. / isReservedTag: no, /* * Check if an attribute is reserved so that it cannot be used as a component * prop. This is platform-dependent and may be overwritten. / isReservedAttr: no, /* * Check if a tag is an unknown element. * Platform-dependent. / isUnknownElement: no, /* * Get the namespace of an element / getTagNamespace: noop, /* * Parse the real tag name for the specific platform. / parsePlatformTagName: identity, /* * Check if an attribute must be bound using property, e.g. value * Platform-dependent. / mustUseProp: no, /* * Perform updates asynchronously. Intended to be used by Vue Test Utils * This will significantly reduce performance if set to false. / async: true, /* * Exposed for legacy reasons / _lifecycleHooks: LIFECYCLE_HOOKS }; let currentInstance = null; /* * @internal / function setCurrentInstance(vm = null) { if (!vm) currentInstance && currentInstance._scope.off(); currentInstance = vm; vm && vm._scope.on(); } /* * @internal / class VNode { constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) { this.tag = tag; this.data = data; this.children = children; this.text = text; this.elm = elm; this.ns = undefined; this.context = context; this.fnContext = undefined; this.fnOptions = undefined; this.fnScopeId = undefined; this.key = data && data.key; this.componentOptions = componentOptions; this.componentInstance = undefined; this.parent = undefined; this.raw = false; this.isStatic = false; this.isRootInsert = true; this.isComment = false; this.isCloned = false; this.isOnce = false; this.asyncFactory = asyncFactory; this.asyncMeta = undefined; this.isAsyncPlaceholder = false; } // DEPRECATED: alias for componentInstance for backwards compat. / istanbul ignore next / get child() { return this.componentInstance; } } const createEmptyVNode = (text = '') => { const node = new VNode(); node.text = text; node.isComment = true; return node; }; function createTextVNode(val) { return new VNode(undefined, undefined, undefined, String(val)); } // optimized shallow clone // used for static nodes and slot nodes because they may be reused across // multiple renders, cloning them avoids errors when DOM manipulations rely // on their elm reference. function cloneVNode(vnode) { const cloned = new VNode(vnode.tag, vnode.data, // #7975 // clone children array to avoid mutating original in case of cloning // a child. vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory); cloned.ns = vnode.ns; cloned.isStatic = vnode.isStatic; cloned.key = vnode.key; cloned.isComment = vnode.isComment; cloned.fnContext = vnode.fnContext; cloned.fnOptions = vnode.fnOptions; cloned.fnScopeId = vnode.fnScopeId; cloned.asyncMeta = vnode.asyncMeta; cloned.isCloned = true; return cloned; } / not type checking this file because flow doesn't play well with Proxy / if (process.env.NODE_ENV !== 'production') { makeMap('Infinity,undefined,NaN,isFinite,isNaN,' + 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' + 'require' // for Webpack/Browserify ); const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy); if (hasProxy) { const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact'); config.keyCodes = new Proxy(config.keyCodes, { set(target, key, value) { if (isBuiltInModifier(key)) { warn$3(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`); return false; } else { target[key] = value; return true; } } }); } } let uid = 0; /* * A dep is an observable that can have multiple * directives subscribing to it. * @internal / class Dep { constructor() { // pending subs cleanup this._pending = false; this.id = uid++; this.subs = []; } addSub(sub) { this.subs.push(sub); } removeSub(sub) { // #12696 deps with massive amount of subscribers are extremely slow to // clean up in Chromium // to workaround this, we unset the sub for now, and clear them on // next scheduler flush. this.subs[this.subs.indexOf(sub)] = null; if (!this._pending) { this._pending = true; } } depend(info) { if (Dep.target) { Dep.target.addDep(this); if (process.env.NODE_ENV !== 'production' && info && Dep.target.onTrack) { Dep.target.onTrack(Object.assign({ effect: Dep.target }, info)); } } } notify(info) { // stabilize the subscriber list first const subs = this.subs.filter(s => s); if (process.env.NODE_ENV !== 'production' && !config.async) { // subs aren't sorted in scheduler if not running async // we need to sort them now to make sure they fire in correct // order subs.sort((a, b) => a.id - b.id); } for (let i = 0, l = subs.length; i < l; i++) { const sub = subs[i]; if (process.env.NODE_ENV !== 'production' && info) { sub.onTrigger && sub.onTrigger(Object.assign({ effect: subs[i] }, info)); } sub.update(); } } } // The current target watcher being evaluated. // This is globally unique because only one watcher // can be evaluated at a time. Dep.target = null; const targetStack = []; function pushTarget(target) { targetStack.push(target); Dep.target = target; } function popTarget() { targetStack.pop(); Dep.target = targetStack[targetStack.length - 1]; } / * not type checking this file because flow doesn't play well with * dynamically accessing methods on Array prototype / const arrayProto = Array.prototype; const arrayMethods = Object.create(arrayProto); const methodsToPatch = [ 'push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse' ]; /* * Intercept mutating methods and emit events / methodsToPatch.forEach(function (method) { // cache original method const original = arrayProto[method]; def(arrayMethods, method, function mutator(...args) { const result = original.apply(this, args); const ob = this.__ob__; let inserted; switch (method) { case 'push': case 'unshift': inserted = args; break; case 'splice': inserted = args.slice(2); break; } if (inserted) ob.observeArray(inserted); // notify change if (process.env.NODE_ENV !== 'production') { ob.dep.notify({ type: "array mutation" / TriggerOpTypes.ARRAY_MUTATION /, target: this, key: method }); } else { ob.dep.notify(); } return result; }); }); const arrayKeys = Object.getOwnPropertyNames(arrayMethods); const NO_INIITIAL_VALUE = {}; /* * In some cases we may want to disable observation inside a component's * update computation. / let shouldObserve = true; function toggleObserving(value) { shouldObserve = value; } // ssr mock dep const mockDep = { notify: noop, depend: noop, addSub: noop, removeSub: noop }; /* * Observer class that is attached to each observed * object. Once attached, the observer converts the target * object's property keys into getter/setters that * collect dependencies and dispatch updates. / class Observer { constructor(value, shallow = false, mock = false) { this.value = value; this.shallow = shallow; this.mock = mock; // this.value = value this.dep = mock ? mockDep : new Dep(); this.vmCount = 0; def(value, '__ob__', this); if (isArray(value)) { if (!mock) { if (hasProto) { value.__proto__ = arrayMethods; / eslint-enable no-proto / } else { for (let i = 0, l = arrayKeys.length; i < l; i++) { const key = arrayKeys[i]; def(value, key, arrayMethods[key]); } } } if (!shallow) { this.observeArray(value); } } else { /* * Walk through all properties and convert them into * getter/setters. This method should only be called when * value type is Object. / const keys = Object.keys(value); for (let i = 0; i < keys.length; i++) { const key = keys[i]; defineReactive(value, key, NO_INIITIAL_VALUE, undefined, shallow, mock); } } } /* * Observe a list of Array items. / observeArray(value) { for (let i = 0, l = value.length; i < l; i++) { observe(value[i], false, this.mock); } } } // helpers /* * Attempt to create an observer instance for a value, * returns the new observer if successfully observed, * or the existing observer if the value already has one. / function observe(value, shallow, ssrMockReactivity) { if (value && hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { return value.__ob__; } if (shouldObserve && (ssrMockReactivity \|\| !isServerRendering()) && (isArray(value) \|\| isPlainObject(value)) && Object.isExtensible(value) && !value.__v_skip / ReactiveFlags.SKIP / && !isRef(value) && !(value instanceof VNode)) { return new Observer(value, shallow, ssrMockReactivity); } } /* * Define a reactive property on an Object. / function defineReactive(obj, key, val, customSetter, shallow, mock) { const dep = new Dep(); const property = Object.getOwnPropertyDescriptor(obj, key); if (property && property.configurable === false) { return; } // cater for pre-defined getter/setters const getter = property && property.get; const setter = property && property.set; if ((!getter \|\| setter) && (val === NO_INIITIAL_VALUE \|\| arguments.length === 2)) { val = obj[key]; } let childOb = !shallow && observe(val, false, mock); Object.defineProperty(obj, key, { enumerable: true, configurable: true, get: function reactiveGetter() { const value = getter ? getter.call(obj) : val; if (Dep.target) { if (process.env.NODE_ENV !== 'production') { dep.depend({ target: obj, type: "get" / TrackOpTypes.GET /, key }); } else { dep.depend(); } if (childOb) { childOb.dep.depend(); if (isArray(value)) { dependArray(value); } } } return isRef(value) && !shallow ? value.value : value; }, set: function reactiveSetter(newVal) { const value = getter ? getter.call(obj) : val; if (!hasChanged(value, newVal)) { return; } if (process.env.NODE_ENV !== 'production' && customSetter) { customSetter(); } if (setter) { setter.call(obj, newVal); } else if (getter) { // #7981: for accessor properties without setter return; } else if (!shallow && isRef(value) && !isRef(newVal)) { value.value = newVal; return; } else { val = newVal; } childOb = !shallow && observe(newVal, false, mock); if (process.env.NODE_ENV !== 'production') { dep.notify({ type: "set" / TriggerOpTypes.SET /, target: obj, key, newValue: newVal, oldValue: value }); } else { dep.notify(); } } }); return dep; } function set(target, key, val) { if (process.env.NODE_ENV !== 'production' && (isUndef(target) \|\| isPrimitive(target))) { warn$3(`Cannot set reactive property on undefined, null, or primitive value: ${target}`); } if (isReadonly(target)) { process.env.NODE_ENV !== 'production' && warn$3(`Set operation on key "${key}" failed: target is readonly.`); return; } const ob = target.__ob__; if (isArray(target) && isValidArrayIndex(key)) { target.length = Math.max(target.length, key); target.splice(key, 1, val); // when mocking for SSR, array methods are not hijacked if (ob && !ob.shallow && ob.mock) { observe(val, false, true); } return val; } if (key in target && !(key in Object.prototype)) { target[key] = val; return val; } if (target._isVue \|\| (ob && ob.vmCount)) { process.env.NODE_ENV !== 'production' && warn$3('Avoid adding reactive properties to a Vue instance or its root $data ' + 'at runtime - declare it upfront in the data option.'); return val; } if (!ob) { target[key] = val; return val; } defineReactive(ob.value, key, val, undefined, ob.shallow, ob.mock); if (process.env.NODE_ENV !== 'production') { ob.dep.notify({ type: "add" / TriggerOpTypes.ADD /, target: target, key, newValue: val, oldValue: undefined }); } else { ob.dep.notify(); } return val; } /* * Collect dependencies on array elements when the array is touched, since * we cannot intercept array element access like property getters. / function dependArray(value) { for (let e, i = 0, l = value.length; i < l; i++) { e = value[i]; if (e && e.__ob__) { e.__ob__.dep.depend(); } if (isArray(e)) { dependArray(e); } } } function isReadonly(value) { return !!(value && value.__v_isReadonly); } function isRef(r) { return !!(r && r.__v_isRef === true); } if (process.env.NODE_ENV !== 'production') ; const normalizeEvent = cached((name) => { const passive = name.charAt(0) === '&'; name = passive ? name.slice(1) : name; const once = name.charAt(0) === '~'; // Prefixed last, checked first name = once ? name.slice(1) : name; const capture = name.charAt(0) === '!'; name = capture ? name.slice(1) : name; return { name, once, capture, passive }; }); function createFnInvoker(fns, vm) { function invoker() { const fns = invoker.fns; if (isArray(fns)) { const cloned = fns.slice(); for (let i = 0; i < cloned.length; i++) { invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`); } } else { // return handler return value for single handlers return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`); } } invoker.fns = fns; return invoker; } function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) { let name, cur, old, event; for (name in on) { cur = on[name]; old = oldOn[name]; event = normalizeEvent(name); if (isUndef(cur)) { process.env.NODE_ENV !== 'production' && warn$3(`Invalid handler for event "${event.name}": got ` + String(cur), vm); } else if (isUndef(old)) { if (isUndef(cur.fns)) { cur = on[name] = createFnInvoker(cur, vm); } if (isTrue(event.once)) { cur = on[name] = createOnceHandler(event.name, cur, event.capture); } add(event.name, cur, event.capture, event.passive, event.params); } else if (cur !== old) { old.fns = cur; on[name] = old; } } for (name in oldOn) { if (isUndef(on[name])) { event = normalizeEvent(name); remove(event.name, oldOn[name], event.capture); } } } function extractPropsFromVNodeData(data, Ctor, tag) { // we are only extracting raw values here. // validation and default values are handled in the child // component itself. const propOptions = Ctor.options.props; if (isUndef(propOptions)) { return; } const res = {}; const { attrs, props } = data; if (isDef(attrs) \|\| isDef(props)) { for (const key in propOptions) { const altKey = hyphenate(key); if (process.env.NODE_ENV !== 'production') { const keyInLowerCase = key.toLowerCase(); if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) { tip(`Prop "${keyInLowerCase}" is passed to component ` + `${formatComponentName( // @ts-expect-error tag is string tag \|\| Ctor)}, but the declared prop name is` + ` "${key}". ` + `Note that HTML attributes are case-insensitive and camelCased ` + `props need to use their kebab-case equivalents when using in-DOM ` + `templates. You should probably use "${altKey}" instead of "${key}".`); } } checkProp(res, props, key, altKey, true) \|\| checkProp(res, attrs, key, altKey, false); } } return res; } function checkProp(res, hash, key, altKey, preserve) { if (isDef(hash)) { if (hasOwn(hash, key)) { res[key] = hash[key]; if (!preserve) { delete hash[key]; } return true; } else if (hasOwn(hash, altKey)) { res[key] = hash[altKey]; if (!preserve) { delete hash[altKey]; } return true; } } return false; } // The template compiler attempts to minimize the need for normalization by // statically analyzing the template at compile time. // // For plain HTML markup, normalization can be completely skipped because the // generated render function is guaranteed to return Array<VNode>. There are // two cases where extra normalization is needed: // 1. When the children contains components - because a functional component // may return an Array instead of a single root. In this case, just a simple // normalization is needed - if any child is an Array, we flatten the whole // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep // because functional components already normalize their own children. function simpleNormalizeChildren(children) { for (let i = 0; i < children.length; i++) { if (isArray(children[i])) { return Array.prototype.concat.apply([], children); } } return children; } // 2. When the children contains constructs that always generated nested Arrays, // e.g. <template>, <slot>, v-for, or when the children is provided by user // with hand-written render functions / JSX. In such cases a full normalization // is needed to cater to all possible types of children values. function normalizeChildren(children) { return isPrimitive(children) ? [createTextVNode(children)] : isArray(children) ? normalizeArrayChildren(children) : undefined; } function isTextNode(node) { return isDef(node) && isDef(node.text) && isFalse(node.isComment); } function normalizeArrayChildren(children, nestedIndex) { const res = []; let i, c, lastIndex, last; for (i = 0; i < children.length; i++) { c = children[i]; if (isUndef(c) \|\| typeof c === 'boolean') continue; lastIndex = res.length - 1; last = res[lastIndex]; // nested if (isArray(c)) { if (c.length > 0) { c = normalizeArrayChildren(c, `${nestedIndex \|\| ''}_${i}`); // merge adjacent text nodes if (isTextNode(c[0]) && isTextNode(last)) { res[lastIndex] = createTextVNode(last.text + c[0].text); c.shift(); } res.push.apply(res, c); } } else if (isPrimitive(c)) { if (isTextNode(last)) { // merge adjacent text nodes // this is necessary for SSR hydration because text nodes are // essentially merged when rendered to HTML strings res[lastIndex] = createTextVNode(last.text + c); } else if (c !== '') { // convert primitive to vnode res.push(createTextVNode(c)); } } else { if (isTextNode(c) && isTextNode(last)) { // merge adjacent text nodes res[lastIndex] = createTextVNode(last.text + c.text); } else { // default key for nested array children (likely generated by v-for) if (isTrue(children._isVList) && isDef(c.tag) && isUndef(c.key) && isDef(nestedIndex)) { c.key = `__vlist${nestedIndex}_${i}__`; } res.push(c); } } } return res; } const SIMPLE_NORMALIZE = 1; const ALWAYS_NORMALIZE = 2; // wrapper function for providing a more flexible interface // without getting yelled at by flow function createElement(context, tag, data, children, normalizationType, alwaysNormalize) { if (isArray(data) \|\| isPrimitive(data)) { normalizationType = children; children = data; data = undefined; } if (isTrue(alwaysNormalize)) { normalizationType = ALWAYS_NORMALIZE; } return _createElement(context, tag, data, children, normalizationType); } function _createElement(context, tag, data, children, normalizationType) { if (isDef(data) && isDef(data.__ob__)) { process.env.NODE_ENV !== 'production' && warn$3(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context); return createEmptyVNode(); } // object syntax in v-bind if (isDef(data) && isDef(data.is)) { tag = data.is; } if (!tag) { // in case of component :is set to falsy value return createEmptyVNode(); } // warn against non-primitive key if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.key) && !isPrimitive(data.key)) { warn$3('Avoid using non-primitive value as key, ' + 'use string/number value instead.', context); } // support single function children as default scoped slot if (isArray(children) && isFunction(children[0])) { data = data \|\| {}; data.scopedSlots = { default: children[0] }; children.length = 0; } if (normalizationType === ALWAYS_NORMALIZE) { children = normalizeChildren(children); } else if (normalizationType === SIMPLE_NORMALIZE) { children = simpleNormalizeChildren(children); } let vnode, ns; if (typeof tag === 'string') { let Ctor; ns = (context.$vnode && context.$vnode.ns) \|\| config.getTagNamespace(tag); if ((!data \|\| !data.pre) && isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) { // component vnode = createComponent(Ctor, data, context, children, tag); } else { // unknown or unlisted namespaced elements // check at runtime because it may get assigned a namespace when its // parent normalizes children vnode = new VNode(tag, data, children, undefined, undefined, context); } } else { // direct component options / constructor vnode = createComponent(tag, data, context, children); } if (isArray(vnode)) { return vnode; } else if (isDef(vnode)) { if (isDef(ns)) applyNS(vnode, ns); if (isDef(data)) registerDeepBindings(data); return vnode; } else { return createEmptyVNode(); } } function applyNS(vnode, ns, force) { vnode.ns = ns; if (vnode.tag === 'foreignObject') { // use default namespace inside foreignObject ns = undefined; force = true; } if (isDef(vnode.children)) { for (let i = 0, l = vnode.children.length; i < l; i++) { const child = vnode.children[i]; if (isDef(child.tag) && (isUndef(child.ns) \|\| (isTrue(force) && child.tag !== 'svg'))) { applyNS(child, ns, force); } } } } // ref #5318 // necessary to ensure parent re-render when deep bindings like :style and // :class are used on slot nodes function registerDeepBindings(data) { if (isObject$1(data.style)) { traverse(data.style); } if (isObject$1(data.class)) { traverse(data.class); } } /* * Runtime helper for rendering v-for lists. / function renderList(val, render) { let ret = null, i, l, keys, key; if (isArray(val) \|\| typeof val === 'string') { ret = new Array(val.length); for (i = 0, l = val.length; i < l; i++) { ret[i] = render(val[i], i); } } else if (typeof val === 'number') { ret = new Array(val); for (i = 0; i < val; i++) { ret[i] = render(i + 1, i); } } else if (isObject$1(val)) { if (hasSymbol && val[Symbol.iterator]) { ret = []; const iterator = val[Symbol.iterator](); let result = iterator.next(); while (!result.done) { ret.push(render(result.value, ret.length)); result = iterator.next(); } } else { keys = Object.keys(val); ret = new Array(keys.length); for (i = 0, l = keys.length; i < l; i++) { key = keys[i]; ret[i] = render(val[key], key, i); } } } if (!isDef(ret)) { ret = []; } ret._isVList = true; return ret; } /* * Runtime helper for rendering <slot> / function renderSlot(name, fallbackRender, props, bindObject) { const scopedSlotFn = this.$scopedSlots[name]; let nodes; if (scopedSlotFn) { // scoped slot props = props \|\| {}; if (bindObject) { if (process.env.NODE_ENV !== 'production' && !isObject$1(bindObject)) { warn$3('slot v-bind without argument expects an Object', this); } props = extend(extend({}, bindObject), props); } nodes = scopedSlotFn(props) \|\| (isFunction(fallbackRender) ? fallbackRender() : fallbackRender); } else { nodes = this.$slots[name] \|\| (isFunction(fallbackRender) ? fallbackRender() : fallbackRender); } const target = props && props.slot; if (target) { return this.$createElement('template', { slot: target }, nodes); } else { return nodes; } } /* * Runtime helper for resolving filters / function resolveFilter(id) { return resolveAsset(this.$options, 'filters', id, true) \|\| identity; } function isKeyNotMatch(expect, actual) { if (isArray(expect)) { return expect.indexOf(actual) === -1; } else { return expect !== actual; } } /* * Runtime helper for checking keyCodes from config. * exposed as Vue.prototype._k * passing in eventKeyName as last argument separately for backwards compat / function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) { const mappedKeyCode = config.keyCodes[key] \|\| builtInKeyCode; if (builtInKeyName && eventKeyName && !config.keyCodes[key]) { return isKeyNotMatch(builtInKeyName, eventKeyName); } else if (mappedKeyCode) { return isKeyNotMatch(mappedKeyCode, eventKeyCode); } else if (eventKeyName) { return hyphenate(eventKeyName) !== key; } return eventKeyCode === undefined; } /* * Runtime helper for merging v-bind="object" into a VNode's data. / function bindObjectProps(data, tag, value, asProp, isSync) { if (value) { if (!isObject$1(value)) { process.env.NODE_ENV !== 'production' && warn$3('v-bind without argument expects an Object or Array value', this); } else { if (isArray(value)) { value = toObject(value); } let hash; for (const key in value) { if (key === 'class' \|\| key === 'style' \|\| isReservedAttribute(key)) { hash = data; } else { const type = data.attrs && data.attrs.type; hash = asProp \|\| config.mustUseProp(tag, type, key) ? data.domProps \|\| (data.domProps = {}) : data.attrs \|\| (data.attrs = {}); } const camelizedKey = camelize(key); const hyphenatedKey = hyphenate(key); if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) { hash[key] = value[key]; if (isSync) { const on = data.on \|\| (data.on = {}); on[`update:${key}`] = function ($event) { value[key] = $event; }; } } } } } return data; } /* * Runtime helper for rendering static trees. / function renderStatic(index, isInFor) { const cached = this._staticTrees \|\| (this._staticTrees = []); let tree = cached[index]; // if has already-rendered static tree and not inside v-for, // we can reuse the same tree. if (tree && !isInFor) { return tree; } // otherwise, render a fresh tree. tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, this._c, this // for render fns generated for functional component templates ); markStatic$1(tree, `__static__${index}`, false); return tree; } /* * Runtime helper for v-once. * Effectively it means marking the node as static with a unique key. / function markOnce(tree, index, key) { markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true); return tree; } function markStatic$1(tree, key, isOnce) { if (isArray(tree)) { for (let i = 0; i < tree.length; i++) { if (tree[i] && typeof tree[i] !== 'string') { markStaticNode(tree[i], `${key}_${i}`, isOnce); } } } else { markStaticNode(tree, key, isOnce); } } function markStaticNode(node, key, isOnce) { node.isStatic = true; node.key = key; node.isOnce = isOnce; } function bindObjectListeners(data, value) { if (value) { if (!isPlainObject(value)) { process.env.NODE_ENV !== 'production' && warn$3('v-on without argument expects an Object value', this); } else { const on = (data.on = data.on ? extend({}, data.on) : {}); for (const key in value) { const existing = on[key]; const ours = value[key]; on[key] = existing ? [].concat(existing, ours) : ours; } } } return data; } function resolveScopedSlots(fns, res, // the following are added in 2.6 hasDynamicKeys, contentHashKey) { res = res \|\| { $stable: !hasDynamicKeys }; for (let i = 0; i < fns.length; i++) { const slot = fns[i]; if (isArray(slot)) { resolveScopedSlots(slot, res, hasDynamicKeys); } else if (slot) { // marker for reverse proxying v-slot without scope on this.$slots // @ts-expect-error if (slot.proxy) { // @ts-expect-error slot.fn.proxy = true; } res[slot.key] = slot.fn; } } if (contentHashKey) { res.$key = contentHashKey; } return res; } // helper to process dynamic keys for dynamic arguments in v-bind and v-on. function bindDynamicKeys(baseObj, values) { for (let i = 0; i < values.length; i += 2) { const key = values[i]; if (typeof key === 'string' && key) { baseObj[values[i]] = values[i + 1]; } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) { // null is a special value for explicitly removing a binding warn$3(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this); } } return baseObj; } // helper to dynamically append modifier runtime markers to event names. // ensure only append when value is already string, otherwise it will be cast // to string and cause the type check to miss. function prependModifier(value, symbol) { return typeof value === 'string' ? symbol + value : value; } function installRenderHelpers(target) { target._o = markOnce; target._n = toNumber; target._s = toString$2; target._l = renderList; target._t = renderSlot; target._q = looseEqual; target._i = looseIndexOf; target._m = renderStatic; target._f = resolveFilter; target._k = checkKeyCodes; target._b = bindObjectProps; target._v = createTextVNode; target._e = createEmptyVNode; target._u = resolveScopedSlots; target._g = bindObjectListeners; target._d = bindDynamicKeys; target._p = prependModifier; } /* * Runtime helper for resolving raw children VNodes into a slot object. / function resolveSlots(children, context) { if (!children \|\| !children.length) { return {}; } const slots = {}; for (let i = 0, l = children.length; i < l; i++) { const child = children[i]; const data = child.data; // remove slot attribute if the node is resolved as a Vue slot node if (data && data.attrs && data.attrs.slot) { delete data.attrs.slot; } // named slots should only be respected if the vnode was rendered in the // same context. if ((child.context === context \|\| child.fnContext === context) && data && data.slot != null) { const name = data.slot; const slot = slots[name] \|\| (slots[name] = []); if (child.tag === 'template') { slot.push.apply(slot, child.children \|\| []); } else { slot.push(child); } } else { (slots.default \|\| (slots.default = [])).push(child); } } // ignore slots that contains only whitespace for (const name in slots) { if (slots[name].every(isWhitespace)) { delete slots[name]; } } return slots; } function isWhitespace(node) { return (node.isComment && !node.asyncFactory) \|\| node.text === ' '; } function isAsyncPlaceholder(node) { // @ts-expect-error not really boolean type return node.isComment && node.asyncFactory; } function normalizeScopedSlots(ownerVm, scopedSlots, normalSlots, prevScopedSlots) { let res; const hasNormalSlots = Object.keys(normalSlots).length > 0; const isStable = scopedSlots ? !!scopedSlots.$stable : !hasNormalSlots; const key = scopedSlots && scopedSlots.$key; if (!scopedSlots) { res = {}; } else if (scopedSlots._normalized) { // fast path 1: child component re-render only, parent did not change return scopedSlots._normalized; } else if (isStable && prevScopedSlots && prevScopedSlots !== emptyObject && key === prevScopedSlots.$key && !hasNormalSlots && !prevScopedSlots.$hasNormal) { // fast path 2: stable scoped slots w/ no normal slots to proxy, // only need to normalize once return prevScopedSlots; } else { res = {}; for (const key in scopedSlots) { if (scopedSlots[key] && key[0] !== '$') { res[key] = normalizeScopedSlot(ownerVm, normalSlots, key, scopedSlots[key]); } } } // expose normal slots on scopedSlots for (const key in normalSlots) { if (!(key in res)) { res[key] = proxyNormalSlot(normalSlots, key); } } // avoriaz seems to mock a non-extensible $scopedSlots object // and when that is passed down this would cause an error if (scopedSlots && Object.isExtensible(scopedSlots)) { scopedSlots._normalized = res; } def(res, '$stable', isStable); def(res, '$key', key); def(res, '$hasNormal', hasNormalSlots); return res; } function normalizeScopedSlot(vm, normalSlots, key, fn) { const normalized = function () { const cur = currentInstance; setCurrentInstance(vm); let res = arguments.length ? fn.apply(null, arguments) : fn({}); res = res && typeof res === 'object' && !isArray(res) ? [res] // single vnode : normalizeChildren(res); const vnode = res && res[0]; setCurrentInstance(cur); return res && (!vnode \|\| (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391 ? undefined : res; }; // this is a slot using the new v-slot syntax without scope. although it is // compiled as a scoped slot, render fn users would expect it to be present // on this.$slots because the usage is semantically a normal slot. if (fn.proxy) { Object.defineProperty(normalSlots, key, { get: normalized, enumerable: true, configurable: true }); } return normalized; } function proxyNormalSlot(slots, key) { return () => slots[key]; } function syncSetupProxy(to, from, prev, instance, type) { let changed = false; for (const key in from) { if (!(key in to)) { changed = true; defineProxyAttr(to, key, instance, type); } else if (from[key] !== prev[key]) { changed = true; } } for (const key in to) { if (!(key in from)) { changed = true; delete to[key]; } } return changed; } function defineProxyAttr(proxy, key, instance, type) { Object.defineProperty(proxy, key, { enumerable: true, configurable: true, get() { return instance[type][key]; } }); } function createAsyncPlaceholder(factory, data, context, children, tag) { const node = createEmptyVNode(); node.asyncFactory = factory; node.asyncMeta = { data, context, children, tag }; return node; } function resolveAsyncComponent(factory, baseCtor) { if (isTrue(factory.error) && isDef(factory.errorComp)) { return factory.errorComp; } if (isDef(factory.resolved)) { return factory.resolved; } if (isTrue(factory.loading) && isDef(factory.loadingComp)) { return factory.loadingComp; } } let target; function add(event, fn) { target.$on(event, fn); } function remove(event, fn) { target.$off(event, fn); } function createOnceHandler(event, fn) { const _target = target; return function onceHandler() { const res = fn.apply(null, arguments); if (res !== null) { _target.$off(event, onceHandler); } }; } function updateComponentListeners(vm, listeners, oldListeners) { target = vm; updateListeners(listeners, oldListeners \|\| {}, add, remove, createOnceHandler, vm); target = undefined; } let activeInstance = null; function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) { if (process.env.NODE_ENV !== 'production') ; // determine whether component has slot children // we need to do this before overwriting $options._renderChildren. // check if there are dynamic scopedSlots (hand-written or compiled but with // dynamic slot names). Static scoped slots compiled from template has the // "$stable" marker. const newScopedSlots = parentVnode.data.scopedSlots; const oldScopedSlots = vm.$scopedSlots; const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) \|\| (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) \|\| (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) \|\| (!newScopedSlots && vm.$scopedSlots.$key)); // Any static slot children from the parent may have changed during parent's // update. Dynamic scoped slots may also have changed. In such cases, a forced // update is necessary to ensure correctness. let needsForceUpdate = !!(renderChildren \|\| // has new static slots vm.$options._renderChildren \|\| // has old static slots hasDynamicScopedSlot); const prevVNode = vm.$vnode; vm.$options._parentVnode = parentVnode; vm.$vnode = parentVnode; // update vm's placeholder node without re-render if (vm._vnode) { // update child tree's parent vm._vnode.parent = parentVnode; } vm.$options._renderChildren = renderChildren; // update $attrs and $listeners hash // these are also reactive so they may trigger child update if the child // used them during render const attrs = parentVnode.data.attrs \|\| emptyObject; if (vm._attrsProxy) { // force update if attrs are accessed and has changed since it may be // passed to a child component. if (syncSetupProxy(vm._attrsProxy, attrs, (prevVNode.data && prevVNode.data.attrs) \|\| emptyObject, vm, '$attrs')) { needsForceUpdate = true; } } vm.$attrs = attrs; // update listeners listeners = listeners \|\| emptyObject; const prevListeners = vm.$options._parentListeners; if (vm._listenersProxy) { syncSetupProxy(vm._listenersProxy, listeners, prevListeners \|\| emptyObject, vm, '$listeners'); } vm.$listeners = vm.$options._parentListeners = listeners; updateComponentListeners(vm, listeners, prevListeners); // update props if (propsData && vm.$options.props) { toggleObserving(false); const props = vm._props; const propKeys = vm.$options._propKeys \|\| []; for (let i = 0; i < propKeys.length; i++) { const key = propKeys[i]; const propOptions = vm.$options.props; // wtf flow? props[key] = validateProp(key, propOptions, propsData, vm); } toggleObserving(true); // keep a copy of raw propsData vm.$options.propsData = propsData; } // resolve slots + force update if has children if (needsForceUpdate) { vm.$slots = resolveSlots(renderChildren, parentVnode.context); vm.$forceUpdate(); } if (process.env.NODE_ENV !== 'production') ; } function isInInactiveTree(vm) { while (vm && (vm = vm.$parent)) { if (vm._inactive) return true; } return false; } function activateChildComponent(vm, direct) { if (direct) { vm._directInactive = false; if (isInInactiveTree(vm)) { return; } } else if (vm._directInactive) { return; } if (vm._inactive \|\| vm._inactive === null) { vm._inactive = false; for (let i = 0; i < vm.$children.length; i++) { activateChildComponent(vm.$children[i]); } callHook(vm, 'activated'); } } function deactivateChildComponent(vm, direct) { if (direct) { vm._directInactive = true; if (isInInactiveTree(vm)) { return; } } if (!vm._inactive) { vm._inactive = true; for (let i = 0; i < vm.$children.length; i++) { deactivateChildComponent(vm.$children[i]); } callHook(vm, 'deactivated'); } } function callHook(vm, hook, args, setContext = true) { // #7573 disable dep collection when invoking lifecycle hooks pushTarget(); const prev = currentInstance; setContext && setCurrentInstance(vm); const handlers = vm.$options[hook]; const info = `${hook} hook`; if (handlers) { for (let i = 0, j = handlers.length; i < j; i++) { invokeWithErrorHandling(handlers[i], vm, args \|\| null, vm, info); } } if (vm._hasHookEvent) { vm.$emit('hook:' + hook); } setContext && setCurrentInstance(prev); popTarget(); } // Async edge case fix requires storing an event listener's attach timestamp. let getNow = Date.now; // Determine what event timestamp the browser is using. Annoyingly, the // timestamp can either be hi-res (relative to page load) or low-res // (relative to UNIX epoch), so in order to compare time we have to use the // same timestamp type when saving the flush timestamp. // All IE versions use low-res event timestamps, and have problematic clock // implementations (#9632) if (inBrowser && !isIE) { const performance = window.performance; if (performance && typeof performance.now === 'function' && getNow() > document.createEvent('Event').timeStamp) { // if the event timestamp, although evaluated AFTER the Date.now(), is // smaller than it, it means the event is using a hi-res timestamp, // and we need to use the hi-res version for event listener timestamps as // well. getNow = () => performance.now(); } } /* * Queue a kept-alive component that was activated during patch. * The queue will be processed after the entire tree has been patched. / function queueActivatedComponent(vm) { // setting _inactive to false here so that a render function can // rely on checking whether it's in an inactive tree (e.g. router-view) vm._inactive = false; } function handleError(err, vm, info) { // Deactivate deps tracking while processing error handler to avoid possible infinite rendering. // See: https://github.com/vuejs/vuex/issues/1505 pushTarget(); try { if (vm) { let cur = vm; while ((cur = cur.$parent)) { const hooks = cur.$options.errorCaptured; if (hooks) { for (let i = 0; i < hooks.length; i++) { try { const capture = hooks[i].call(cur, err, vm, info) === false; if (capture) return; } catch (e) { globalHandleError(e, cur, 'errorCaptured hook'); } } } } } globalHandleError(err, vm, info); } finally { popTarget(); } } function invokeWithErrorHandling(handler, context, args, vm, info) { let res; try { res = args ? handler.apply(context, args) : handler.call(context); if (res && !res._isVue && isPromise(res) && !res._handled) { res.catch(e => handleError(e, vm, info + ` (Promise/async)`)); res._handled = true; } } catch (e) { handleError(e, vm, info); } return res; } function globalHandleError(err, vm, info) { logError(err, vm, info); } function logError(err, vm, info) { if (process.env.NODE_ENV !== 'production') { warn$3(`Error in ${info}: "${err.toString()}"`, vm); } / istanbul ignore else / if (inBrowser && typeof console !== 'undefined') { console.error(err); } else { throw err; } } / globals MutationObserver / const callbacks = []; function flushCallbacks() { const copies = callbacks.slice(0); callbacks.length = 0; for (let i = 0; i < copies.length; i++) { copies[i](); } } // The nextTick behavior leverages the microtask queue, which can be accessed // via either native Promise.then or MutationObserver. // MutationObserver has wider support, however it is seriously bugged in // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It // completely stops working after triggering a few times... so, if native // Promise is available, we will use it: / istanbul ignore next, $flow-disable-line / if (typeof Promise !== 'undefined' && isNative(Promise)) { Promise.resolve(); } else if (!isIE && typeof MutationObserver !== 'undefined' && (isNative(MutationObserver) \|\| // PhantomJS and iOS 7.x MutationObserver.toString() === '[object MutationObserverConstructor]')) { // Use MutationObserver where native Promise is not available, // e.g. PhantomJS, iOS7, Android 4.4 // (#6466 MutationObserver is unreliable in IE11) let counter = 1; const observer = new MutationObserver(flushCallbacks); const textNode = document.createTextNode(String(counter)); observer.observe(textNode, { characterData: true }); } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ; else ; const seenObjects = new _Set(); /* * Recursively traverse an object to evoke all converted * getters, so that every nested property inside the object * is collected as a "deep" dependency. / function traverse(val) { _traverse(val, seenObjects); seenObjects.clear(); return val; } function _traverse(val, seen) { let i, keys; const isA = isArray(val); if ((!isA && !isObject$1(val)) \|\| val.__v_skip / ReactiveFlags.SKIP / \|\| Object.isFrozen(val) \|\| val instanceof VNode) { return; } if (val.__ob__) { const depId = val.__ob__.dep.id; if (seen.has(depId)) { return; } seen.add(depId); } if (isA) { i = val.length; while (i--) _traverse(val[i], seen); } else if (isRef(val)) { _traverse(val.value, seen); } else { keys = Object.keys(val); i = keys.length; while (i--) _traverse(val[keys[i]], seen); } } function resolveInject(inject, vm) { if (inject) { // inject is :any because flow is not smart enough to figure out cached const result = Object.create(null); const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject); for (let i = 0; i < keys.length; i++) { const key = keys[i]; // #6574 in case the inject object is observed... if (key === '__ob__') continue; const provideKey = inject[key].from; if (provideKey in vm._provided) { result[key] = vm._provided[provideKey]; } else if ('default' in inject[key]) { const provideDefault = inject[key].default; result[key] = isFunction(provideDefault) ? provideDefault.call(vm) : provideDefault; } else if (process.env.NODE_ENV !== 'production') { warn$3(`Injection "${key}" not found`, vm); } } return result; } } function resolveConstructorOptions(Ctor) { let options = Ctor.options; if (Ctor.super) { const superOptions = resolveConstructorOptions(Ctor.super); const cachedSuperOptions = Ctor.superOptions; if (superOptions !== cachedSuperOptions) { // super option changed, // need to resolve new options. Ctor.superOptions = superOptions; // check if there are any late-modified/attached options (#4976) const modifiedOptions = resolveModifiedOptions(Ctor); // update base extend options if (modifiedOptions) { extend(Ctor.extendOptions, modifiedOptions); } options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions); if (options.name) { options.components[options.name] = Ctor; } } } return options; } function resolveModifiedOptions(Ctor) { let modified; const latest = Ctor.options; const sealed = Ctor.sealedOptions; for (const key in latest) { if (latest[key] !== sealed[key]) { if (!modified) modified = {}; modified[key] = latest[key]; } } return modified; } function FunctionalRenderContext(data, props, children, parent, Ctor) { const options = Ctor.options; // ensure the createElement function in functional components // gets a unique context - this is necessary for correct named slot check let contextVm; if (hasOwn(parent, '_uid')) { contextVm = Object.create(parent); contextVm._original = parent; } else { // the context vm passed in is a functional context as well. // in this case we want to make sure we are able to get a hold to the // real context instance. contextVm = parent; // @ts-ignore parent = parent._original; } const isCompiled = isTrue(options._compiled); const needNormalization = !isCompiled; this.data = data; this.props = props; this.children = children; this.parent = parent; this.listeners = data.on \|\| emptyObject; this.injections = resolveInject(options.inject, parent); this.slots = () => { if (!this.$slots) { normalizeScopedSlots(parent, data.scopedSlots, (this.$slots = resolveSlots(children, parent))); } return this.$slots; }; Object.defineProperty(this, 'scopedSlots', { enumerable: true, get() { return normalizeScopedSlots(parent, data.scopedSlots, this.slots()); } }); // support for compiled functional template if (isCompiled) { // exposing $options for renderStatic() this.$options = options; // pre-resolve slots for renderSlot() this.$slots = this.slots(); this.$scopedSlots = normalizeScopedSlots(parent, data.scopedSlots, this.$slots); } if (options._scopeId) { this._c = (a, b, c, d) => { const vnode = createElement(contextVm, a, b, c, d, needNormalization); if (vnode && !isArray(vnode)) { vnode.fnScopeId = options._scopeId; vnode.fnContext = parent; } return vnode; }; } else { this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization); } } installRenderHelpers(FunctionalRenderContext.prototype); function createFunctionalComponent(Ctor, propsData, data, contextVm, children) { const options = Ctor.options; const props = {}; const propOptions = options.props; if (isDef(propOptions)) { for (const key in propOptions) { props[key] = validateProp(key, propOptions, propsData \|\| emptyObject); } } else { if (isDef(data.attrs)) mergeProps(props, data.attrs); if (isDef(data.props)) mergeProps(props, data.props); } const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor); const vnode = options.render.call(null, renderContext._c, renderContext); if (vnode instanceof VNode) { return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext); } else if (isArray(vnode)) { const vnodes = normalizeChildren(vnode) \|\| []; const res = new Array(vnodes.length); for (let i = 0; i < vnodes.length; i++) { res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext); } return res; } } function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) { // #7817 clone node before setting fnContext, otherwise if the node is reused // (e.g. it was from a cached normal slot) the fnContext causes named slots // that should not be matched to match. const clone = cloneVNode(vnode); clone.fnContext = contextVm; clone.fnOptions = options; if (process.env.NODE_ENV !== 'production') { (clone.devtoolsMeta = clone.devtoolsMeta \|\| {}).renderContext = renderContext; } if (data.slot) { (clone.data \|\| (clone.data = {})).slot = data.slot; } return clone; } function mergeProps(to, from) { for (const key in from) { to[camelize(key)] = from[key]; } } function getComponentName(options) { return options.name \|\| options.__name \|\| options._componentTag; } // inline hooks to be invoked on component VNodes during patch const componentVNodeHooks = { init(vnode, hydrating) { if (vnode.componentInstance && !vnode.componentInstance._isDestroyed && vnode.data.keepAlive) { // kept-alive components, treat as a patch const mountedNode = vnode; // work around flow componentVNodeHooks.prepatch(mountedNode, mountedNode); } else { const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance)); child.$mount(hydrating ? vnode.elm : undefined, hydrating); } }, prepatch(oldVnode, vnode) { const options = vnode.componentOptions; const child = (vnode.componentInstance = oldVnode.componentInstance); updateChildComponent(child, options.propsData, // updated props options.listeners, // updated listeners vnode, // new parent vnode options.children // new children ); }, insert(vnode) { const { context, componentInstance } = vnode; if (!componentInstance._isMounted) { componentInstance._isMounted = true; callHook(componentInstance, 'mounted'); } if (vnode.data.keepAlive) { if (context._isMounted) { // vue-router#1212 // During updates, a kept-alive component's child components may // change, so directly walking the tree here may call activated hooks // on incorrect children. Instead we push them into a queue which will // be processed after the whole patch process ended. queueActivatedComponent(componentInstance); } else { activateChildComponent(componentInstance, true / direct /); } } }, destroy(vnode) { const { componentInstance } = vnode; if (!componentInstance._isDestroyed) { if (!vnode.data.keepAlive) { componentInstance.$destroy(); } else { deactivateChildComponent(componentInstance, true / direct /); } } } }; const hooksToMerge = Object.keys(componentVNodeHooks); function createComponent(Ctor, data, context, children, tag) { if (isUndef(Ctor)) { return; } const baseCtor = context.$options._base; // plain options object: turn it into a constructor if (isObject$1(Ctor)) { Ctor = baseCtor.extend(Ctor); } // if at this stage it's not a constructor or an async component factory, // reject. if (typeof Ctor !== 'function') { if (process.env.NODE_ENV !== 'production') { warn$3(`Invalid Component definition: ${String(Ctor)}`, context); } return; } // async component let asyncFactory; // @ts-expect-error if (isUndef(Ctor.cid)) { asyncFactory = Ctor; Ctor = resolveAsyncComponent(asyncFactory); if (Ctor === undefined) { // return a placeholder node for async component, which is rendered // as a comment node but preserves all the raw information for the node. // the information will be used for async server-rendering and hydration. return createAsyncPlaceholder(asyncFactory, data, context, children, tag); } } data = data \|\| {}; // resolve constructor options in case global mixins are applied after // component constructor creation resolveConstructorOptions(Ctor); // transform component v-model data into props & events if (isDef(data.model)) { // @ts-expect-error transformModel(Ctor.options, data); } // extract props // @ts-expect-error const propsData = extractPropsFromVNodeData(data, Ctor, tag); // functional component // @ts-expect-error if (isTrue(Ctor.options.functional)) { return createFunctionalComponent(Ctor, propsData, data, context, children); } // extract listeners, since these needs to be treated as // child component listeners instead of DOM listeners const listeners = data.on; // replace with listeners with .native modifier // so it gets processed during parent component patch. data.on = data.nativeOn; // @ts-expect-error if (isTrue(Ctor.options.abstract)) { // abstract components do not keep anything // other than props & listeners & slot // work around flow const slot = data.slot; data = {}; if (slot) { data.slot = slot; } } // install component management hooks onto the placeholder node installComponentHooks(data); // return a placeholder vnode // @ts-expect-error const name = getComponentName(Ctor.options) \|\| tag; const vnode = new VNode( // @ts-expect-error `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, // @ts-expect-error { Ctor, propsData, listeners, tag, children }, asyncFactory); return vnode; } function createComponentInstanceForVnode( // we know it's MountedComponentVNode but flow doesn't vnode, // activeInstance in lifecycle state parent) { const options = { _isComponent: true, _parentVnode: vnode, parent }; // check inline-template render functions const inlineTemplate = vnode.data.inlineTemplate; if (isDef(inlineTemplate)) { options.render = inlineTemplate.render; options.staticRenderFns = inlineTemplate.staticRenderFns; } return new vnode.componentOptions.Ctor(options); } function installComponentHooks(data) { const hooks = data.hook \|\| (data.hook = {}); for (let i = 0; i < hooksToMerge.length; i++) { const key = hooksToMerge[i]; const existing = hooks[key]; const toMerge = componentVNodeHooks[key]; // @ts-expect-error if (existing !== toMerge && !(existing && existing._merged)) { hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge; } } } function mergeHook(f1, f2) { const merged = (a, b) => { // flow complains about extra args which is why we use any f1(a, b); f2(a, b); }; merged._merged = true; return merged; } // transform component v-model info (value and callback) into // prop and event handler respectively. function transformModel(options, data) { const prop = (options.model && options.model.prop) \|\| 'value'; const event = (options.model && options.model.event) \|\| 'input'; (data.attrs \|\| (data.attrs = {}))[prop] = data.model.value; const on = data.on \|\| (data.on = {}); const existing = on[event]; const callback = data.model.callback; if (isDef(existing)) { if (isArray(existing) ? existing.indexOf(callback) === -1 : existing !== callback) { on[event] = [callback].concat(existing); } } else { on[event] = callback; } } let warn$3 = noop; let tip = noop; let generateComponentTrace; // work around flow check let formatComponentName; if (process.env.NODE_ENV !== 'production') { const hasConsole = typeof console !== 'undefined'; const classifyRE = /(?:^\|[-_])(\w)/g; const classify = str => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, ''); warn$3 = (msg, vm = currentInstance) => { const trace = vm ? generateComponentTrace(vm) : ''; if (hasConsole && !config.silent) { console.error(`[Vue warn]: ${msg}${trace}`); } }; tip = (msg, vm) => { if (hasConsole && !config.silent) { console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : '')); } }; formatComponentName = (vm, includeFile) => { if (vm.$root === vm) { return '<Root>'; } const options = isFunction(vm) && vm.cid != null ? vm.options : vm._isVue ? vm.$options \|\| vm.constructor.options : vm; let name = getComponentName(options); const file = options.__file; if (!name && file) { const match = file.match(/([^/\\]+)\.vue$/); name = match && match[1]; } return ((name ? `<${classify(name)}>` : `<Anonymous>`) + (file && includeFile !== false ? ` at ${file}` : '')); }; const repeat = (str, n) => { let res = ''; while (n) { if (n % 2 === 1) res += str; if (n > 1) str += str; n >>= 1; } return res; }; generateComponentTrace = (vm) => { if (vm._isVue && vm.$parent) { const tree = []; let currentRecursiveSequence = 0; while (vm) { if (tree.length > 0) { const last = tree[tree.length - 1]; if (last.constructor === vm.constructor) { currentRecursiveSequence++; vm = vm.$parent; continue; } else if (currentRecursiveSequence > 0) { tree[tree.length - 1] = [last, currentRecursiveSequence]; currentRecursiveSequence = 0; } } tree.push(vm); vm = vm.$parent; } return ('\n\nfound in\n\n' + tree .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i 2)}${isArray(vm) ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)` : formatComponentName(vm)}`) .join('\n')); } else { return `\n\n(found in ${formatComponentName(vm)})`; } }; } /** * Option overwriting strategies are functions that handle * how to merge a parent option value and a child option * value into the final value. / const strats = config.optionMergeStrategies; /* * Options with restrictions / if (process.env.NODE_ENV !== 'production') { strats.el = strats.propsData = function (parent, child, vm, key) { if (!vm) { warn$3(`option "${key}" can only be used during instance ` + 'creation with the `new` keyword.'); } return defaultStrat(parent, child); }; } /* * Helper that recursively merges two data objects together. / function mergeData(to, from, recursive = true) { if (!from) return to; let key, toVal, fromVal; const keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from); for (let i = 0; i < keys.length; i++) { key = keys[i]; // in case the object is already observed... if (key === '__ob__') continue; toVal = to[key]; fromVal = from[key]; if (!recursive \|\| !hasOwn(to, key)) { set(to, key, fromVal); } else if (toVal !== fromVal && isPlainObject(toVal) && isPlainObject(fromVal)) { mergeData(toVal, fromVal); } } return to; } /* * Data / function mergeDataOrFn(parentVal, childVal, vm) { if (!vm) { // in a Vue.extend merge, both should be functions if (!childVal) { return parentVal; } if (!parentVal) { return childVal; } // when parentVal & childVal are both present, // we need to return a function that returns the // merged result of both functions... no need to // check if parentVal is a function here because // it has to be a function to pass previous merges. return function mergedDataFn() { return mergeData(isFunction(childVal) ? childVal.call(this, this) : childVal, isFunction(parentVal) ? parentVal.call(this, this) : parentVal); }; } else { return function mergedInstanceDataFn() { // instance merge const instanceData = isFunction(childVal) ? childVal.call(vm, vm) : childVal; const defaultData = isFunction(parentVal) ? parentVal.call(vm, vm) : parentVal; if (instanceData) { return mergeData(instanceData, defaultData); } else { return defaultData; } }; } } strats.data = function (parentVal, childVal, vm) { if (!vm) { if (childVal && typeof childVal !== 'function') { process.env.NODE_ENV !== 'production' && warn$3('The "data" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm); return parentVal; } return mergeDataOrFn(parentVal, childVal); } return mergeDataOrFn(parentVal, childVal, vm); }; /* * Hooks and props are merged as arrays. / function mergeLifecycleHook(parentVal, childVal) { const res = childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; return res ? dedupeHooks(res) : res; } function dedupeHooks(hooks) { const res = []; for (let i = 0; i < hooks.length; i++) { if (res.indexOf(hooks[i]) === -1) { res.push(hooks[i]); } } return res; } LIFECYCLE_HOOKS.forEach(hook => { strats[hook] = mergeLifecycleHook; }); /* * Assets * * When a vm is present (instance creation), we need to do * a three-way merge between constructor options, instance * options and parent options. / function mergeAssets(parentVal, childVal, vm, key) { const res = Object.create(parentVal \|\| null); if (childVal) { process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm); return extend(res, childVal); } else { return res; } } ASSET_TYPES.forEach(function (type) { strats[type + 's'] = mergeAssets; }); /* * Watchers. * * Watchers hashes should not overwrite one * another, so we merge them as arrays. / strats.watch = function (parentVal, childVal, vm, key) { // work around Firefox's Object.prototype.watch... //@ts-expect-error work around if (parentVal === nativeWatch) parentVal = undefined; //@ts-expect-error work around if (childVal === nativeWatch) childVal = undefined; / istanbul ignore if / if (!childVal) return Object.create(parentVal \|\| null); if (process.env.NODE_ENV !== 'production') { assertObjectType(key, childVal, vm); } if (!parentVal) return childVal; const ret = {}; extend(ret, parentVal); for (const key in childVal) { let parent = ret[key]; const child = childVal[key]; if (parent && !isArray(parent)) { parent = [parent]; } ret[key] = parent ? parent.concat(child) : isArray(child) ? child : [child]; } return ret; }; /* * Other object hashes. / strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) { if (childVal && process.env.NODE_ENV !== 'production') { assertObjectType(key, childVal, vm); } if (!parentVal) return childVal; const ret = Object.create(null); extend(ret, parentVal); if (childVal) extend(ret, childVal); return ret; }; strats.provide = function (parentVal, childVal) { if (!parentVal) return childVal; return function () { const ret = Object.create(null); mergeData(ret, isFunction(parentVal) ? parentVal.call(this) : parentVal); if (childVal) { mergeData(ret, isFunction(childVal) ? childVal.call(this) : childVal, false // non-recursive ); } return ret; }; }; /* * Default strategy. / const defaultStrat = function (parentVal, childVal) { return childVal === undefined ? parentVal : childVal; }; /* * Validate component names / function checkComponents(options) { for (const key in options.components) { validateComponentName(key); } } function validateComponentName(name) { if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]$`).test(name)) { warn$3('Invalid component name: "' + name + '". Component names ' + 'should conform to valid custom element name in html5 specification.'); } if (isBuiltInTag(name) \|\| config.isReservedTag(name)) { warn$3('Do not use built-in or reserved HTML elements as component ' + 'id: ' + name); } } /** * Ensure all props option syntax are normalized into the * Object-based format. / function normalizeProps(options, vm) { const props = options.props; if (!props) return; const res = {}; let i, val, name; if (isArray(props)) { i = props.length; while (i--) { val = props[i]; if (typeof val === 'string') { name = camelize(val); res[name] = { type: null }; } else if (process.env.NODE_ENV !== 'production') { warn$3('props must be strings when using array syntax.'); } } } else if (isPlainObject(props)) { for (const key in props) { val = props[key]; name = camelize(key); res[name] = isPlainObject(val) ? val : { type: val }; } } else if (process.env.NODE_ENV !== 'production') { warn$3(`Invalid value for option "props": expected an Array or an Object, ` + `but got ${toRawType(props)}.`, vm); } options.props = res; } /* * Normalize all injections into Object-based format / function normalizeInject(options, vm) { const inject = options.inject; if (!inject) return; const normalized = (options.inject = {}); if (isArray(inject)) { for (let i = 0; i < inject.length; i++) { normalized[inject[i]] = { from: inject[i] }; } } else if (isPlainObject(inject)) { for (const key in inject) { const val = inject[key]; normalized[key] = isPlainObject(val) ? extend({ from: key }, val) : { from: val }; } } else if (process.env.NODE_ENV !== 'production') { warn$3(`Invalid value for option "inject": expected an Array or an Object, ` + `but got ${toRawType(inject)}.`, vm); } } /* * Normalize raw function directives into object format. / function normalizeDirectives(options) { const dirs = options.directives; if (dirs) { for (const key in dirs) { const def = dirs[key]; if (isFunction(def)) { dirs[key] = { bind: def, update: def }; } } } } function assertObjectType(name, value, vm) { if (!isPlainObject(value)) { warn$3(`Invalid value for option "${name}": expected an Object, ` + `but got ${toRawType(value)}.`, vm); } } /* * Merge two option objects into a new one. * Core utility used in both instantiation and inheritance. / function mergeOptions(parent, child, vm) { if (process.env.NODE_ENV !== 'production') { checkComponents(child); } if (isFunction(child)) { // @ts-expect-error child = child.options; } normalizeProps(child, vm); normalizeInject(child, vm); normalizeDirectives(child); // Apply extends and mixins on the child options, // but only if it is a raw options object that isn't // the result of another mergeOptions call. // Only merged options has the _base property. if (!child._base) { if (child.extends) { parent = mergeOptions(parent, child.extends, vm); } if (child.mixins) { for (let i = 0, l = child.mixins.length; i < l; i++) { parent = mergeOptions(parent, child.mixins[i], vm); } } } const options = {}; let key; for (key in parent) { mergeField(key); } for (key in child) { if (!hasOwn(parent, key)) { mergeField(key); } } function mergeField(key) { const strat = strats[key] \|\| defaultStrat; options[key] = strat(parent[key], child[key], vm, key); } return options; } /* * Resolve an asset. * This function is used because child instances need access * to assets defined in its ancestor chain. / function resolveAsset(options, type, id, warnMissing) { / istanbul ignore if / if (typeof id !== 'string') { return; } const assets = options[type]; // check local registration variations first if (hasOwn(assets, id)) return assets[id]; const camelizedId = camelize(id); if (hasOwn(assets, camelizedId)) return assets[camelizedId]; const PascalCaseId = capitalize(camelizedId); if (hasOwn(assets, PascalCaseId)) return assets[PascalCaseId]; // fallback to prototype chain const res = assets[id] \|\| assets[camelizedId] \|\| assets[PascalCaseId]; if (process.env.NODE_ENV !== 'production' && warnMissing && !res) { warn$3('Failed to resolve ' + type.slice(0, -1) + ': ' + id); } return res; } function validateProp(key, propOptions, propsData, vm) { const prop = propOptions[key]; const absent = !hasOwn(propsData, key); let value = propsData[key]; // boolean casting const booleanIndex = getTypeIndex(Boolean, prop.type); if (booleanIndex > -1) { if (absent && !hasOwn(prop, 'default')) { value = false; } else if (value === '' \|\| value === hyphenate(key)) { // only cast empty string / same name to boolean if // boolean has higher priority const stringIndex = getTypeIndex(String, prop.type); if (stringIndex < 0 \|\| booleanIndex < stringIndex) { value = true; } } } // check default value if (value === undefined) { value = getPropDefaultValue(vm, prop, key); // since the default value is a fresh copy, // make sure to observe it. const prevShouldObserve = shouldObserve; toggleObserving(true); observe(value); toggleObserving(prevShouldObserve); } if (process.env.NODE_ENV !== 'production') { assertProp(prop, key, value, vm, absent); } return value; } /* * Get the default value of a prop. / function getPropDefaultValue(vm, prop, key) { // no default, return undefined if (!hasOwn(prop, 'default')) { return undefined; } const def = prop.default; // warn against non-factory defaults for Object & Array if (process.env.NODE_ENV !== 'production' && isObject$1(def)) { warn$3('Invalid default value for prop "' + key + '": ' + 'Props with type Object/Array must use a factory function ' + 'to return the default value.', vm); } // the raw prop value was also undefined from previous render, // return previous default value to avoid unnecessary watcher trigger if (vm && vm.$options.propsData && vm.$options.propsData[key] === undefined && vm._props[key] !== undefined) { return vm._props[key]; } // call factory function for non-Function types // a value is Function if its prototype is function even across different execution context return isFunction(def) && getType(prop.type) !== 'Function' ? def.call(vm) : def; } /* * Assert whether a prop is valid. / function assertProp(prop, name, value, vm, absent) { if (prop.required && absent) { warn$3('Missing required prop: "' + name + '"', vm); return; } if (value == null && !prop.required) { return; } let type = prop.type; let valid = !type \|\| type === true; const expectedTypes = []; if (type) { if (!isArray(type)) { type = [type]; } for (let i = 0; i < type.length && !valid; i++) { const assertedType = assertType(value, type[i], vm); expectedTypes.push(assertedType.expectedType \|\| ''); valid = assertedType.valid; } } const haveExpectedTypes = expectedTypes.some(t => t); if (!valid && haveExpectedTypes) { warn$3(getInvalidTypeMessage(name, value, expectedTypes), vm); return; } const validator = prop.validator; if (validator) { if (!validator(value)) { warn$3('Invalid prop: custom validator check failed for prop "' + name + '".', vm); } } } const simpleCheckRE = /^(String\|Number\|Boolean\|Function\|Symbol\|BigInt)$/; function assertType(value, type, vm) { let valid; const expectedType = getType(type); if (simpleCheckRE.test(expectedType)) { const t = typeof value; valid = t === expectedType.toLowerCase(); // for primitive wrapper objects if (!valid && t === 'object') { valid = value instanceof type; } } else if (expectedType === 'Object') { valid = isPlainObject(value); } else if (expectedType === 'Array') { valid = isArray(value); } else { try { valid = value instanceof type; } catch (e) { warn$3('Invalid prop type: "' + String(type) + '" is not a constructor', vm); valid = false; } } return { valid, expectedType }; } const functionTypeCheckRE = /^\sfunction (\w+)/; /** * Use function string name to check built-in types, * because a simple equality check will fail when running * across different vms / iframes. / function getType(fn) { const match = fn && fn.toString().match(functionTypeCheckRE); return match ? match[1] : ''; } function isSameType(a, b) { return getType(a) === getType(b); } function getTypeIndex(type, expectedTypes) { if (!isArray(expectedTypes)) { return isSameType(expectedTypes, type) ? 0 : -1; } for (let i = 0, len = expectedTypes.length; i < len; i++) { if (isSameType(expectedTypes[i], type)) { return i; } } return -1; } function getInvalidTypeMessage(name, value, expectedTypes) { let message = `Invalid prop: type check failed for prop "${name}".` + ` Expected ${expectedTypes.map(capitalize).join(', ')}`; const expectedType = expectedTypes[0]; const receivedType = toRawType(value); // check if we need to specify expected value if (expectedTypes.length === 1 && isExplicable(expectedType) && isExplicable(typeof value) && !isBoolean(expectedType, receivedType)) { message += ` with value ${styleValue(value, expectedType)}`; } message += `, got ${receivedType} `; // check if we need to specify received value if (isExplicable(receivedType)) { message += `with value ${styleValue(value, receivedType)}.`; } return message; } function styleValue(value, type) { if (type === 'String') { return `"${value}"`; } else if (type === 'Number') { return `${Number(value)}`; } else { return `${value}`; } } const EXPLICABLE_TYPES = ['string', 'number', 'boolean']; function isExplicable(value) { return EXPLICABLE_TYPES.some(elem => value.toLowerCase() === elem); } function isBoolean(...args) { return args.some(elem => elem.toLowerCase() === 'boolean'); } // these are reserved for web because they are directly compiled away // during template compilation makeMap('style,class'); // attributes that should be using props for binding const acceptValue = makeMap('input,textarea,option,select,progress'); const mustUseProp = (tag, type, attr) => { return ((attr === 'value' && acceptValue(tag) && type !== 'button') \|\| (attr === 'selected' && tag === 'option') \|\| (attr === 'checked' && tag === 'input') \|\| (attr === 'muted' && tag === 'video')); }; const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck'); makeMap('events,caret,typing,plaintext-only'); const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' + 'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' + 'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' + 'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' + 'required,reversed,scoped,seamless,selected,sortable,' + 'truespeed,typemustmatch,visible'); const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' + 'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' + 'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' + 'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' + 's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' + 'embed,object,param,source,canvas,script,noscript,del,ins,' + 'caption,col,colgroup,table,thead,tbody,td,th,tr,' + 'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' + 'output,progress,select,textarea,' + 'details,dialog,menu,menuitem,summary,' + 'content,element,shadow,template,blockquote,iframe,tfoot'); // this map is intentionally selective, only covering SVG elements that may // contain child elements. const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' + 'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' + 'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true); const isPreTag = (tag) => tag === 'pre'; const isReservedTag = (tag) => { return isHTMLTag(tag) \|\| isSVG(tag); }; function getTagNamespace(tag) { if (isSVG(tag)) { return 'svg'; } // basic support for MathML // note it doesn't support other MathML elements being component roots if (tag === 'math') { return 'math'; } } makeMap('text,number,password,search,email,tel,url'); const validDivisionCharRE = /[\w).+\-_$\]]/; function parseFilters(exp) { let inSingle = false; let inDouble = false; let inTemplateString = false; let inRegex = false; let curly = 0; let square = 0; let paren = 0; let lastFilterIndex = 0; let c, prev, i, expression, filters; for (i = 0; i < exp.length; i++) { prev = c; c = exp.charCodeAt(i); if (inSingle) { if (c === 0x27 && prev !== 0x5c) inSingle = false; } else if (inDouble) { if (c === 0x22 && prev !== 0x5c) inDouble = false; } else if (inTemplateString) { if (c === 0x60 && prev !== 0x5c) inTemplateString = false; } else if (inRegex) { if (c === 0x2f && prev !== 0x5c) inRegex = false; } else if (c === 0x7c && // pipe exp.charCodeAt(i + 1) !== 0x7c && exp.charCodeAt(i - 1) !== 0x7c && !curly && !square && !paren) { if (expression === undefined) { // first filter, end of expression lastFilterIndex = i + 1; expression = exp.slice(0, i).trim(); } else { pushFilter(); } } else { switch (c) { case 0x22: inDouble = true; break; // " case 0x27: inSingle = true; break; // ' case 0x60: inTemplateString = true; break; // ` case 0x28: paren++; break; // ( case 0x29: paren--; break; // ) case 0x5b: square++; break; // [ case 0x5d: square--; break; // ] case 0x7b: curly++; break; // { case 0x7d: curly--; break; // } } if (c === 0x2f) { // / let j = i - 1; let p; // find first non-whitespace prev char for (; j >= 0; j--) { p = exp.charAt(j); if (p !== ' ') break; } if (!p \|\| !validDivisionCharRE.test(p)) { inRegex = true; } } } } if (expression === undefined) { expression = exp.slice(0, i).trim(); } else if (lastFilterIndex !== 0) { pushFilter(); } function pushFilter() { (filters \|\| (filters = [])).push(exp.slice(lastFilterIndex, i).trim()); lastFilterIndex = i + 1; } if (filters) { for (i = 0; i < filters.length; i++) { expression = wrapFilter(expression, filters[i]); } } return expression; } function wrapFilter(exp, filter) { const i = filter.indexOf('('); if (i < 0) { // _f: resolveFilter return `_f("${filter}")(${exp})`; } else { const name = filter.slice(0, i); const args = filter.slice(i + 1); return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`; } } const defaultTagRE = /\{\{((?:.\|\r?\n)+?)\}\}/g; const regexEscapeRE = /[-.+?^${}()\|[\]\/\\]/g; const buildRegex = cached(delimiters => { const open = delimiters[0].replace(regexEscapeRE, '\\$&'); const close = delimiters[1].replace(regexEscapeRE, '\\$&'); return new RegExp(open + '((?:.\|\\n)+?)' + close, 'g'); }); function parseText(text, delimiters) { //@ts-expect-error const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE; if (!tagRE.test(text)) { return; } const tokens = []; const rawTokens = []; let lastIndex = (tagRE.lastIndex = 0); let match, index, tokenValue; while ((match = tagRE.exec(text))) { index = match.index; // push text token if (index > lastIndex) { rawTokens.push((tokenValue = text.slice(lastIndex, index))); tokens.push(JSON.stringify(tokenValue)); } // tag token const exp = parseFilters(match[1].trim()); tokens.push(`_s(${exp})`); rawTokens.push({ '@binding': exp }); lastIndex = index + match[0].length; } if (lastIndex < text.length) { rawTokens.push((tokenValue = text.slice(lastIndex))); tokens.push(JSON.stringify(tokenValue)); } return { expression: tokens.join('+'), tokens: rawTokens }; } /* eslint-disable no-unused-vars / function baseWarn(msg, range) { console.error(`[Vue compiler]: ${msg}`); } / eslint-enable no-unused-vars / function pluckModuleFunction(modules, key) { return modules ? modules.map(m => m[key]).filter(_ => _) : []; } function addProp(el, name, value, range, dynamic) { (el.props \|\| (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range)); el.plain = false; } function addAttr(el, name, value, range, dynamic) { const attrs = dynamic ? el.dynamicAttrs \|\| (el.dynamicAttrs = []) : el.attrs \|\| (el.attrs = []); attrs.push(rangeSetItem({ name, value, dynamic }, range)); el.plain = false; } // add a raw attr (use this in preTransforms) function addRawAttr(el, name, value, range) { el.attrsMap[name] = value; el.attrsList.push(rangeSetItem({ name, value }, range)); } function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) { (el.directives \|\| (el.directives = [])).push(rangeSetItem({ name, rawName, value, arg, isDynamicArg, modifiers }, range)); el.plain = false; } function prependModifierMarker(symbol, name, dynamic) { return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured } function addHandler(el, name, value, modifiers, important, warn, range, dynamic) { modifiers = modifiers \|\| emptyObject; // warn prevent and passive modifier / istanbul ignore if / if (process.env.NODE_ENV !== 'production' && warn && modifiers.prevent && modifiers.passive) { warn("passive and prevent can't be used together. " + "Passive handler can't prevent default event.", range); } // normalize click.right and click.middle since they don't actually fire // this is technically browser-specific, but at least for now browsers are // the only target envs that have right/middle clicks. if (modifiers.right) { if (dynamic) { name = `(${name})==='click'?'contextmenu':(${name})`; } else if (name === 'click') { name = 'contextmenu'; delete modifiers.right; } } else if (modifiers.middle) { if (dynamic) { name = `(${name})==='click'?'mouseup':(${name})`; } else if (name === 'click') { name = 'mouseup'; } } // check capture modifier if (modifiers.capture) { delete modifiers.capture; name = prependModifierMarker('!', name, dynamic); } if (modifiers.once) { delete modifiers.once; name = prependModifierMarker('~', name, dynamic); } / istanbul ignore if / if (modifiers.passive) { delete modifiers.passive; name = prependModifierMarker('&', name, dynamic); } let events; if (modifiers.native) { delete modifiers.native; events = el.nativeEvents \|\| (el.nativeEvents = {}); } else { events = el.events \|\| (el.events = {}); } const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range); if (modifiers !== emptyObject) { newHandler.modifiers = modifiers; } const handlers = events[name]; / istanbul ignore if / if (Array.isArray(handlers)) { important ? handlers.unshift(newHandler) : handlers.push(newHandler); } else if (handlers) { events[name] = important ? [newHandler, handlers] : [handlers, newHandler]; } else { events[name] = newHandler; } el.plain = false; } function getRawBindingAttr(el, name) { return (el.rawAttrsMap[':' + name] \|\| el.rawAttrsMap['v-bind:' + name] \|\| el.rawAttrsMap[name]); } function getBindingAttr(el, name, getStatic) { const dynamicValue = getAndRemoveAttr(el, ':' + name) \|\| getAndRemoveAttr(el, 'v-bind:' + name); if (dynamicValue != null) { return parseFilters(dynamicValue); } else if (getStatic !== false) { const staticValue = getAndRemoveAttr(el, name); if (staticValue != null) { return JSON.stringify(staticValue); } } } // note: this only removes the attr from the Array (attrsList) so that it // doesn't get processed by processAttrs. // By default it does NOT remove it from the map (attrsMap) because the map is // needed during codegen. function getAndRemoveAttr(el, name, removeFromMap) { let val; if ((val = el.attrsMap[name]) != null) { const list = el.attrsList; for (let i = 0, l = list.length; i < l; i++) { if (list[i].name === name) { list.splice(i, 1); break; } } } if (removeFromMap) { delete el.attrsMap[name]; } return val; } function getAndRemoveAttrByRegex(el, name) { const list = el.attrsList; for (let i = 0, l = list.length; i < l; i++) { const attr = list[i]; if (name.test(attr.name)) { list.splice(i, 1); return attr; } } } function rangeSetItem(item, range) { if (range) { if (range.start != null) { item.start = range.start; } if (range.end != null) { item.end = range.end; } } return item; } function transformNode$1(el, options) { const warn = options.warn \|\| baseWarn; const staticClass = getAndRemoveAttr(el, 'class'); if (process.env.NODE_ENV !== 'production' && staticClass) { const res = parseText(staticClass, options.delimiters); if (res) { warn(`class="${staticClass}": ` + 'Interpolation inside attributes has been removed. ' + 'Use v-bind or the colon shorthand instead. For example, ' + 'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']); } } if (staticClass) { el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim()); } const classBinding = getBindingAttr(el, 'class', false / getStatic /); if (classBinding) { el.classBinding = classBinding; } } function genData$2(el) { let data = ''; if (el.staticClass) { data += `staticClass:${el.staticClass},`; } if (el.classBinding) { data += `class:${el.classBinding},`; } return data; } var klass = { staticKeys: ['staticClass'], transformNode: transformNode$1, genData: genData$2 }; const parseStyleText = cached(function (cssText) { const res = {}; const listDelimiter = /;(?![^(]\))/g; const propertyDelimiter = /:(.+)/; cssText.split(listDelimiter).forEach(function (item) { if (item) { const tmp = item.split(propertyDelimiter); tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()); } }); return res; }); function transformNode(el, options) { const warn = options.warn \|\| baseWarn; const staticStyle = getAndRemoveAttr(el, 'style'); if (staticStyle) { /* istanbul ignore if / if (process.env.NODE_ENV !== 'production') { const res = parseText(staticStyle, options.delimiters); if (res) { warn(`style="${staticStyle}": ` + 'Interpolation inside attributes has been removed. ' + 'Use v-bind or the colon shorthand instead. For example, ' + 'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']); } } el.staticStyle = JSON.stringify(parseStyleText(staticStyle)); } const styleBinding = getBindingAttr(el, 'style', false / getStatic /); if (styleBinding) { el.styleBinding = styleBinding; } } function genData$1(el) { let data = ''; if (el.staticStyle) { data += `staticStyle:${el.staticStyle},`; } if (el.styleBinding) { data += `style:(${el.styleBinding}),`; } return data; } var style = { staticKeys: ['staticStyle'], transformNode, genData: genData$1 }; var he$1 = {exports: {}}; /! https://mths.be/he v1.2.0 by @mathias \| MIT license / (function (module, exports) { (function(root) { // Detect free variables `exports`. var freeExports = exports; // Detect free variable `module`. var freeModule = module && module.exports == freeExports && module; // Detect free variable `global`, from Node.js or Browserified code, // and use it as `root`. var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal; if (freeGlobal.global === freeGlobal \|\| freeGlobal.window === freeGlobal) { root = freeGlobal; } /--------------------------------------------------------------------------/ // All astral symbols. var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; // All ASCII symbols (not just printable ASCII) except those listed in the // first column of the overrides table. // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides var regexAsciiWhitelist = /[\x01-\x7F]/g; // All BMP symbols that are not ASCII newlines, printable ASCII symbols, or // code points listed in the first column of the overrides table on // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides. var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g; var regexEncodeNonAscii = /<\u20D2\|=\u20E5\|>\u20D2\|\u205F\u200A\|\u219D\u0338\|\u2202\u0338\|\u2220\u20D2\|\u2229\uFE00\|\u222A\uFE00\|\u223C\u20D2\|\u223D\u0331\|\u223E\u0333\|\u2242\u0338\|\u224B\u0338\|\u224D\u20D2\|\u224E\u0338\|\u224F\u0338\|\u2250\u0338\|\u2261\u20E5\|\u2264\u20D2\|\u2265\u20D2\|\u2266\u0338\|\u2267\u0338\|\u2268\uFE00\|\u2269\uFE00\|\u226A\u0338\|\u226A\u20D2\|\u226B\u0338\|\u226B\u20D2\|\u227F\u0338\|\u2282\u20D2\|\u2283\u20D2\|\u228A\uFE00\|\u228B\uFE00\|\u228F\u0338\|\u2290\u0338\|\u2293\uFE00\|\u2294\uFE00\|\u22B4\u20D2\|\u22B5\u20D2\|\u22D8\u0338\|\u22D9\u0338\|\u22DA\uFE00\|\u22DB\uFE00\|\u22F5\u0338\|\u22F9\u0338\|\u2933\u0338\|\u29CF\u0338\|\u29D0\u0338\|\u2A6D\u0338\|\u2A70\u0338\|\u2A7D\u0338\|\u2A7E\u0338\|\u2AA1\u0338\|\u2AA2\u0338\|\u2AAC\uFE00\|\u2AAD\uFE00\|\u2AAF\u0338\|\u2AB0\u0338\|\u2AC5\u0338\|\u2AC6\u0338\|\u2ACB\uFE00\|\u2ACC\uFE00\|\u2AFD\u20E5\|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]\|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g; var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','\|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'}; var regexEscape = /["&'<>`]/g; var escapeMap = { '"': '"', '&': '&', '\'': ''', '<': '<', // See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the // following is not strictly necessary unless it’s part of a tag or an // unquoted attribute value. We’re only escaping it to support those // situations, and for XML support. '>': '>', // In Internet Explorer ≤ 8, the backtick character can be used // to break out of (un)quoted attribute values or HTML comments. // See http://html5sec.org/#102, http://html5sec.org/#108, and // http://html5sec.org/#133. '`': '`' }; var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]\|[^0-9xX])/; var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]\|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]\|[\uD800-\uDBFF](?![\uDC00-\uDFFF])\|(?:[^\uD800-\uDBFF]\|^)[\uDC00-\uDFFF]/; var regexDecode = /&(CounterClockwiseContourIntegral\|DoubleLongLeftRightArrow\|ClockwiseContourIntegral\|NotNestedGreaterGreater\|NotSquareSupersetEqual\|DiacriticalDoubleAcute\|NotRightTriangleEqual\|NotSucceedsSlantEqual\|NotPrecedesSlantEqual\|CloseCurlyDoubleQuote\|NegativeVeryThinSpace\|DoubleContourIntegral\|FilledVerySmallSquare\|CapitalDifferentialD\|OpenCurlyDoubleQuote\|EmptyVerySmallSquare\|NestedGreaterGreater\|DoubleLongRightArrow\|NotLeftTriangleEqual\|NotGreaterSlantEqual\|ReverseUpEquilibrium\|DoubleLeftRightArrow\|NotSquareSubsetEqual\|NotDoubleVerticalBar\|RightArrowLeftArrow\|NotGreaterFullEqual\|NotRightTriangleBar\|SquareSupersetEqual\|DownLeftRightVector\|DoubleLongLeftArrow\|leftrightsquigarrow\|LeftArrowRightArrow\|NegativeMediumSpace\|blacktriangleright\|RightDownVectorBar\|PrecedesSlantEqual\|RightDoubleBracket\|SucceedsSlantEqual\|NotLeftTriangleBar\|RightTriangleEqual\|SquareIntersection\|RightDownTeeVector\|ReverseEquilibrium\|NegativeThickSpace\|longleftrightarrow\|Longleftrightarrow\|LongLeftRightArrow\|DownRightTeeVector\|DownRightVectorBar\|GreaterSlantEqual\|SquareSubsetEqual\|LeftDownVectorBar\|LeftDoubleBracket\|VerticalSeparator\|rightleftharpoons\|NotGreaterGreater\|NotSquareSuperset\|blacktriangleleft\|blacktriangledown\|NegativeThinSpace\|LeftDownTeeVector\|NotLessSlantEqual\|leftrightharpoons\|DoubleUpDownArrow\|DoubleVerticalBar\|LeftTriangleEqual\|FilledSmallSquare\|twoheadrightarrow\|NotNestedLessLess\|DownLeftTeeVector\|DownLeftVectorBar\|RightAngleBracket\|NotTildeFullEqual\|NotReverseElement\|RightUpDownVector\|DiacriticalTilde\|NotSucceedsTilde\|circlearrowright\|NotPrecedesEqual\|rightharpoondown\|DoubleRightArrow\|NotSucceedsEqual\|NonBreakingSpace\|NotRightTriangle\|LessEqualGreater\|RightUpTeeVector\|LeftAngleBracket\|GreaterFullEqual\|DownArrowUpArrow\|RightUpVectorBar\|twoheadleftarrow\|GreaterEqualLess\|downharpoonright\|RightTriangleBar\|ntrianglerighteq\|NotSupersetEqual\|LeftUpDownVector\|DiacriticalAcute\|rightrightarrows\|vartriangleright\|UpArrowDownArrow\|DiacriticalGrave\|UnderParenthesis\|EmptySmallSquare\|LeftUpVectorBar\|leftrightarrows\|DownRightVector\|downharpoonleft\|trianglerighteq\|ShortRightArrow\|OverParenthesis\|DoubleLeftArrow\|DoubleDownArrow\|NotSquareSubset\|bigtriangledown\|ntrianglelefteq\|UpperRightArrow\|curvearrowright\|vartriangleleft\|NotLeftTriangle\|nleftrightarrow\|LowerRightArrow\|NotHumpDownHump\|NotGreaterTilde\|rightthreetimes\|LeftUpTeeVector\|NotGreaterEqual\|straightepsilon\|LeftTriangleBar\|rightsquigarrow\|ContourIntegral\|rightleftarrows\|CloseCurlyQuote\|RightDownVector\|LeftRightVector\|nLeftrightarrow\|leftharpoondown\|circlearrowleft\|SquareSuperset\|OpenCurlyQuote\|hookrightarrow\|HorizontalLine\|DiacriticalDot\|NotLessGreater\|ntriangleright\|DoubleRightTee\|InvisibleComma\|InvisibleTimes\|LowerLeftArrow\|DownLeftVector\|NotSubsetEqual\|curvearrowleft\|trianglelefteq\|NotVerticalBar\|TildeFullEqual\|downdownarrows\|NotGreaterLess\|RightTeeVector\|ZeroWidthSpace\|looparrowright\|LongRightArrow\|doublebarwedge\|ShortLeftArrow\|ShortDownArrow\|RightVectorBar\|GreaterGreater\|ReverseElement\|rightharpoonup\|LessSlantEqual\|leftthreetimes\|upharpoonright\|rightarrowtail\|LeftDownVector\|Longrightarrow\|NestedLessLess\|UpperLeftArrow\|nshortparallel\|leftleftarrows\|leftrightarrow\|Leftrightarrow\|LeftRightArrow\|longrightarrow\|upharpoonleft\|RightArrowBar\|ApplyFunction\|LeftTeeVector\|leftarrowtail\|NotEqualTilde\|varsubsetneqq\|varsupsetneqq\|RightTeeArrow\|SucceedsEqual\|SucceedsTilde\|LeftVectorBar\|SupersetEqual\|hookleftarrow\|DifferentialD\|VerticalTilde\|VeryThinSpace\|blacktriangle\|bigtriangleup\|LessFullEqual\|divideontimes\|leftharpoonup\|UpEquilibrium\|ntriangleleft\|RightTriangle\|measuredangle\|shortparallel\|longleftarrow\|Longleftarrow\|LongLeftArrow\|DoubleLeftTee\|Poincareplane\|PrecedesEqual\|triangleright\|DoubleUpArrow\|RightUpVector\|fallingdotseq\|looparrowleft\|PrecedesTilde\|NotTildeEqual\|NotTildeTilde\|smallsetminus\|Proportional\|triangleleft\|triangledown\|UnderBracket\|NotHumpEqual\|exponentiale\|ExponentialE\|NotLessTilde\|HilbertSpace\|RightCeiling\|blacklozenge\|varsupsetneq\|HumpDownHump\|GreaterEqual\|VerticalLine\|LeftTeeArrow\|NotLessEqual\|DownTeeArrow\|LeftTriangle\|varsubsetneq\|Intersection\|NotCongruent\|DownArrowBar\|LeftUpVector\|LeftArrowBar\|risingdotseq\|GreaterTilde\|RoundImplies\|SquareSubset\|ShortUpArrow\|NotSuperset\|quaternions\|precnapprox\|backepsilon\|preccurlyeq\|OverBracket\|blacksquare\|MediumSpace\|VerticalBar\|circledcirc\|circleddash\|CircleMinus\|CircleTimes\|LessGreater\|curlyeqprec\|curlyeqsucc\|diamondsuit\|UpDownArrow\|Updownarrow\|RuleDelayed\|Rrightarrow\|updownarrow\|RightVector\|nRightarrow\|nrightarrow\|eqslantless\|LeftCeiling\|Equilibrium\|SmallCircle\|expectation\|NotSucceeds\|thickapprox\|GreaterLess\|SquareUnion\|NotPrecedes\|NotLessLess\|straightphi\|succnapprox\|succcurlyeq\|SubsetEqual\|sqsupseteq\|Proportion\|Laplacetrf\|ImaginaryI\|supsetneqq\|NotGreater\|gtreqqless\|NotElement\|ThickSpace\|TildeEqual\|TildeTilde\|Fouriertrf\|rmoustache\|EqualTilde\|eqslantgtr\|UnderBrace\|LeftVector\|UpArrowBar\|nLeftarrow\|nsubseteqq\|subsetneqq\|nsupseteqq\|nleftarrow\|succapprox\|lessapprox\|UpTeeArrow\|upuparrows\|curlywedge\|lesseqqgtr\|varepsilon\|varnothing\|RightFloor\|complement\|CirclePlus\|sqsubseteq\|Lleftarrow\|circledast\|RightArrow\|Rightarrow\|rightarrow\|lmoustache\|Bernoullis\|precapprox\|mapstoleft\|mapstodown\|longmapsto\|dotsquare\|downarrow\|DoubleDot\|nsubseteq\|supsetneq\|leftarrow\|nsupseteq\|subsetneq\|ThinSpace\|ngeqslant\|subseteqq\|HumpEqual\|NotSubset\|triangleq\|NotCupCap\|lesseqgtr\|heartsuit\|TripleDot\|Leftarrow\|Coproduct\|Congruent\|varpropto\|complexes\|gvertneqq\|LeftArrow\|LessTilde\|supseteqq\|MinusPlus\|CircleDot\|nleqslant\|NotExists\|gtreqless\|nparallel\|UnionPlus\|LeftFloor\|checkmark\|CenterDot\|centerdot\|Mellintrf\|gtrapprox\|bigotimes\|OverBrace\|spadesuit\|therefore\|pitchfork\|rationals\|PlusMinus\|Backslash\|Therefore\|DownBreve\|backsimeq\|backprime\|DownArrow\|nshortmid\|Downarrow\|lvertneqq\|eqvparsl\|imagline\|imagpart\|infintie\|integers\|Integral\|intercal\|LessLess\|Uarrocir\|intlarhk\|sqsupset\|angmsdaf\|sqsubset\|llcorner\|vartheta\|cupbrcap\|lnapprox\|Superset\|SuchThat\|succnsim\|succneqq\|angmsdag\|biguplus\|curlyvee\|trpezium\|Succeeds\|NotTilde\|bigwedge\|angmsdah\|angrtvbd\|triminus\|cwconint\|fpartint\|lrcorner\|smeparsl\|subseteq\|urcorner\|lurdshar\|laemptyv\|DDotrahd\|approxeq\|ldrushar\|awconint\|mapstoup\|backcong\|shortmid\|triangle\|geqslant\|gesdotol\|timesbar\|circledR\|circledS\|setminus\|multimap\|naturals\|scpolint\|ncongdot\|RightTee\|boxminus\|gnapprox\|boxtimes\|andslope\|thicksim\|angmsdaa\|varsigma\|cirfnint\|rtriltri\|angmsdab\|rppolint\|angmsdac\|barwedge\|drbkarow\|clubsuit\|thetasym\|bsolhsub\|capbrcup\|dzigrarr\|doteqdot\|DotEqual\|dotminus\|UnderBar\|NotEqual\|realpart\|otimesas\|ulcorner\|hksearow\|hkswarow\|parallel\|PartialD\|elinters\|emptyset\|plusacir\|bbrktbrk\|angmsdad\|pointint\|bigoplus\|angmsdae\|Precedes\|bigsqcup\|varkappa\|notindot\|supseteq\|precneqq\|precnsim\|profalar\|profline\|profsurf\|leqslant\|lesdotor\|raemptyv\|subplus\|notnivb\|notnivc\|subrarr\|zigrarr\|vzigzag\|submult\|subedot\|Element\|between\|cirscir\|larrbfs\|larrsim\|lotimes\|lbrksld\|lbrkslu\|lozenge\|ldrdhar\|dbkarow\|bigcirc\|epsilon\|simrarr\|simplus\|ltquest\|Epsilon\|luruhar\|gtquest\|maltese\|npolint\|eqcolon\|npreceq\|bigodot\|ddagger\|gtrless\|bnequiv\|harrcir\|ddotseq\|equivDD\|backsim\|demptyv\|nsqsube\|nsqsupe\|Upsilon\|nsubset\|upsilon\|minusdu\|nsucceq\|swarrow\|nsupset\|coloneq\|searrow\|boxplus\|napprox\|natural\|asympeq\|alefsym\|congdot\|nearrow\|bigstar\|diamond\|supplus\|tritime\|LeftTee\|nvinfin\|triplus\|NewLine\|nvltrie\|nvrtrie\|nwarrow\|nexists\|Diamond\|ruluhar\|Implies\|supmult\|angzarr\|suplarr\|suphsub\|questeq\|because\|digamma\|Because\|olcross\|bemptyv\|omicron\|Omicron\|rotimes\|NoBreak\|intprod\|angrtvb\|orderof\|uwangle\|suphsol\|lesdoto\|orslope\|DownTee\|realine\|cudarrl\|rdldhar\|OverBar\|supedot\|lessdot\|supdsub\|topfork\|succsim\|rbrkslu\|rbrksld\|pertenk\|cudarrr\|isindot\|planckh\|lessgtr\|pluscir\|gesdoto\|plussim\|plustwo\|lesssim\|cularrp\|rarrsim\|Cayleys\|notinva\|notinvb\|notinvc\|UpArrow\|Uparrow\|uparrow\|NotLess\|dwangle\|precsim\|Product\|curarrm\|Cconint\|dotplus\|rarrbfs\|ccupssm\|Cedilla\|cemptyv\|notniva\|quatint\|frac35\|frac38\|frac45\|frac56\|frac58\|frac78\|tridot\|xoplus\|gacute\|gammad\|Gammad\|lfisht\|lfloor\|bigcup\|sqsupe\|gbreve\|Gbreve\|lharul\|sqsube\|sqcups\|Gcedil\|apacir\|llhard\|lmidot\|Lmidot\|lmoust\|andand\|sqcaps\|approx\|Abreve\|spades\|circeq\|tprime\|divide\|topcir\|Assign\|topbot\|gesdot\|divonx\|xuplus\|timesd\|gesles\|atilde\|solbar\|SOFTcy\|loplus\|timesb\|lowast\|lowbar\|dlcorn\|dlcrop\|softcy\|dollar\|lparlt\|thksim\|lrhard\|Atilde\|lsaquo\|smashp\|bigvee\|thinsp\|wreath\|bkarow\|lsquor\|lstrok\|Lstrok\|lthree\|ltimes\|ltlarr\|DotDot\|simdot\|ltrPar\|weierp\|xsqcup\|angmsd\|sigmav\|sigmaf\|zeetrf\|Zcaron\|zcaron\|mapsto\|vsupne\|thetav\|cirmid\|marker\|mcomma\|Zacute\|vsubnE\|there4\|gtlPar\|vsubne\|bottom\|gtrarr\|SHCHcy\|shchcy\|midast\|midcir\|middot\|minusb\|minusd\|gtrdot\|bowtie\|sfrown\|mnplus\|models\|colone\|seswar\|Colone\|mstpos\|searhk\|gtrsim\|nacute\|Nacute\|boxbox\|telrec\|hairsp\|Tcedil\|nbumpe\|scnsim\|ncaron\|Ncaron\|ncedil\|Ncedil\|hamilt\|Scedil\|nearhk\|hardcy\|HARDcy\|tcedil\|Tcaron\|commat\|nequiv\|nesear\|tcaron\|target\|hearts\|nexist\|varrho\|scedil\|Scaron\|scaron\|hellip\|Sacute\|sacute\|hercon\|swnwar\|compfn\|rtimes\|rthree\|rsquor\|rsaquo\|zacute\|wedgeq\|homtht\|barvee\|barwed\|Barwed\|rpargt\|horbar\|conint\|swarhk\|roplus\|nltrie\|hslash\|hstrok\|Hstrok\|rmoust\|Conint\|bprime\|hybull\|hyphen\|iacute\|Iacute\|supsup\|supsub\|supsim\|varphi\|coprod\|brvbar\|agrave\|Supset\|supset\|igrave\|Igrave\|notinE\|Agrave\|iiiint\|iinfin\|copysr\|wedbar\|Verbar\|vangrt\|becaus\|incare\|verbar\|inodot\|bullet\|drcorn\|intcal\|drcrop\|cularr\|vellip\|Utilde\|bumpeq\|cupcap\|dstrok\|Dstrok\|CupCap\|cupcup\|cupdot\|eacute\|Eacute\|supdot\|iquest\|easter\|ecaron\|Ecaron\|ecolon\|isinsv\|utilde\|itilde\|Itilde\|curarr\|succeq\|Bumpeq\|cacute\|ulcrop\|nparsl\|Cacute\|nprcue\|egrave\|Egrave\|nrarrc\|nrarrw\|subsup\|subsub\|nrtrie\|jsercy\|nsccue\|Jsercy\|kappav\|kcedil\|Kcedil\|subsim\|ulcorn\|nsimeq\|egsdot\|veebar\|kgreen\|capand\|elsdot\|Subset\|subset\|curren\|aacute\|lacute\|Lacute\|emptyv\|ntilde\|Ntilde\|lagran\|lambda\|Lambda\|capcap\|Ugrave\|langle\|subdot\|emsp13\|numero\|emsp14\|nvdash\|nvDash\|nVdash\|nVDash\|ugrave\|ufisht\|nvHarr\|larrfs\|nvlArr\|larrhk\|larrlp\|larrpl\|nvrArr\|Udblac\|nwarhk\|larrtl\|nwnear\|oacute\|Oacute\|latail\|lAtail\|sstarf\|lbrace\|odblac\|Odblac\|lbrack\|udblac\|odsold\|eparsl\|lcaron\|Lcaron\|ograve\|Ograve\|lcedil\|Lcedil\|Aacute\|ssmile\|ssetmn\|squarf\|ldquor\|capcup\|ominus\|cylcty\|rharul\|eqcirc\|dagger\|rfloor\|rfisht\|Dagger\|daleth\|equals\|origof\|capdot\|equest\|dcaron\|Dcaron\|rdquor\|oslash\|Oslash\|otilde\|Otilde\|otimes\|Otimes\|urcrop\|Ubreve\|ubreve\|Yacute\|Uacute\|uacute\|Rcedil\|rcedil\|urcorn\|parsim\|Rcaron\|Vdashl\|rcaron\|Tstrok\|percnt\|period\|permil\|Exists\|yacute\|rbrack\|rbrace\|phmmat\|ccaron\|Ccaron\|planck\|ccedil\|plankv\|tstrok\|female\|plusdo\|plusdu\|ffilig\|plusmn\|ffllig\|Ccedil\|rAtail\|dfisht\|bernou\|ratail\|Rarrtl\|rarrtl\|angsph\|rarrpl\|rarrlp\|rarrhk\|xwedge\|xotime\|forall\|ForAll\|Vvdash\|vsupnE\|preceq\|bigcap\|frac12\|frac13\|frac14\|primes\|rarrfs\|prnsim\|frac15\|Square\|frac16\|square\|lesdot\|frac18\|frac23\|propto\|prurel\|rarrap\|rangle\|puncsp\|frac25\|Racute\|qprime\|racute\|lesges\|frac34\|abreve\|AElig\|eqsim\|utdot\|setmn\|urtri\|Equal\|Uring\|seArr\|uring\|searr\|dashv\|Dashv\|mumap\|nabla\|iogon\|Iogon\|sdote\|sdotb\|scsim\|napid\|napos\|equiv\|natur\|Acirc\|dblac\|erarr\|nbump\|iprod\|erDot\|ucirc\|awint\|esdot\|angrt\|ncong\|isinE\|scnap\|Scirc\|scirc\|ndash\|isins\|Ubrcy\|nearr\|neArr\|isinv\|nedot\|ubrcy\|acute\|Ycirc\|iukcy\|Iukcy\|xutri\|nesim\|caret\|jcirc\|Jcirc\|caron\|twixt\|ddarr\|sccue\|exist\|jmath\|sbquo\|ngeqq\|angst\|ccaps\|lceil\|ngsim\|UpTee\|delta\|Delta\|rtrif\|nharr\|nhArr\|nhpar\|rtrie\|jukcy\|Jukcy\|kappa\|rsquo\|Kappa\|nlarr\|nlArr\|TSHcy\|rrarr\|aogon\|Aogon\|fflig\|xrarr\|tshcy\|ccirc\|nleqq\|filig\|upsih\|nless\|dharl\|nlsim\|fjlig\|ropar\|nltri\|dharr\|robrk\|roarr\|fllig\|fltns\|roang\|rnmid\|subnE\|subne\|lAarr\|trisb\|Ccirc\|acirc\|ccups\|blank\|VDash\|forkv\|Vdash\|langd\|cedil\|blk12\|blk14\|laquo\|strns\|diams\|notin\|vDash\|larrb\|blk34\|block\|disin\|uplus\|vdash\|vBarv\|aelig\|starf\|Wedge\|check\|xrArr\|lates\|lbarr\|lBarr\|notni\|lbbrk\|bcong\|frasl\|lbrke\|frown\|vrtri\|vprop\|vnsup\|gamma\|Gamma\|wedge\|xodot\|bdquo\|srarr\|doteq\|ldquo\|boxdl\|boxdL\|gcirc\|Gcirc\|boxDl\|boxDL\|boxdr\|boxdR\|boxDr\|TRADE\|trade\|rlhar\|boxDR\|vnsub\|npart\|vltri\|rlarr\|boxhd\|boxhD\|nprec\|gescc\|nrarr\|nrArr\|boxHd\|boxHD\|boxhu\|boxhU\|nrtri\|boxHu\|clubs\|boxHU\|times\|colon\|Colon\|gimel\|xlArr\|Tilde\|nsime\|tilde\|nsmid\|nspar\|THORN\|thorn\|xlarr\|nsube\|nsubE\|thkap\|xhArr\|comma\|nsucc\|boxul\|boxuL\|nsupe\|nsupE\|gneqq\|gnsim\|boxUl\|boxUL\|grave\|boxur\|boxuR\|boxUr\|boxUR\|lescc\|angle\|bepsi\|boxvh\|varpi\|boxvH\|numsp\|Theta\|gsime\|gsiml\|theta\|boxVh\|boxVH\|boxvl\|gtcir\|gtdot\|boxvL\|boxVl\|boxVL\|crarr\|cross\|Cross\|nvsim\|boxvr\|nwarr\|nwArr\|sqsup\|dtdot\|Uogon\|lhard\|lharu\|dtrif\|ocirc\|Ocirc\|lhblk\|duarr\|odash\|sqsub\|Hacek\|sqcup\|llarr\|duhar\|oelig\|OElig\|ofcir\|boxvR\|uogon\|lltri\|boxVr\|csube\|uuarr\|ohbar\|csupe\|ctdot\|olarr\|olcir\|harrw\|oline\|sqcap\|omacr\|Omacr\|omega\|Omega\|boxVR\|aleph\|lneqq\|lnsim\|loang\|loarr\|rharu\|lobrk\|hcirc\|operp\|oplus\|rhard\|Hcirc\|orarr\|Union\|order\|ecirc\|Ecirc\|cuepr\|szlig\|cuesc\|breve\|reals\|eDDot\|Breve\|hoarr\|lopar\|utrif\|rdquo\|Umacr\|umacr\|efDot\|swArr\|ultri\|alpha\|rceil\|ovbar\|swarr\|Wcirc\|wcirc\|smtes\|smile\|bsemi\|lrarr\|aring\|parsl\|lrhar\|bsime\|uhblk\|lrtri\|cupor\|Aring\|uharr\|uharl\|slarr\|rbrke\|bsolb\|lsime\|rbbrk\|RBarr\|lsimg\|phone\|rBarr\|rbarr\|icirc\|lsquo\|Icirc\|emacr\|Emacr\|ratio\|simne\|plusb\|simlE\|simgE\|simeq\|pluse\|ltcir\|ltdot\|empty\|xharr\|xdtri\|iexcl\|Alpha\|ltrie\|rarrw\|pound\|ltrif\|xcirc\|bumpe\|prcue\|bumpE\|asymp\|amacr\|cuvee\|Sigma\|sigma\|iiint\|udhar\|iiota\|ijlig\|IJlig\|supnE\|imacr\|Imacr\|prime\|Prime\|image\|prnap\|eogon\|Eogon\|rarrc\|mdash\|mDDot\|cuwed\|imath\|supne\|imped\|Amacr\|udarr\|prsim\|micro\|rarrb\|cwint\|raquo\|infin\|eplus\|range\|rangd\|Ucirc\|radic\|minus\|amalg\|veeeq\|rAarr\|epsiv\|ycirc\|quest\|sharp\|quot\|zwnj\|Qscr\|race\|qscr\|Qopf\|qopf\|qint\|rang\|Rang\|Zscr\|zscr\|Zopf\|zopf\|rarr\|rArr\|Rarr\|Pscr\|pscr\|prop\|prod\|prnE\|prec\|ZHcy\|zhcy\|prap\|Zeta\|zeta\|Popf\|popf\|Zdot\|plus\|zdot\|Yuml\|yuml\|phiv\|YUcy\|yucy\|Yscr\|yscr\|perp\|Yopf\|yopf\|part\|para\|YIcy\|Ouml\|rcub\|yicy\|YAcy\|rdca\|ouml\|osol\|Oscr\|rdsh\|yacy\|real\|oscr\|xvee\|andd\|rect\|andv\|Xscr\|oror\|ordm\|ordf\|xscr\|ange\|aopf\|Aopf\|rHar\|Xopf\|opar\|Oopf\|xopf\|xnis\|rhov\|oopf\|omid\|xmap\|oint\|apid\|apos\|ogon\|ascr\|Ascr\|odot\|odiv\|xcup\|xcap\|ocir\|oast\|nvlt\|nvle\|nvgt\|nvge\|nvap\|Wscr\|wscr\|auml\|ntlg\|ntgl\|nsup\|nsub\|nsim\|Nscr\|nscr\|nsce\|Wopf\|ring\|npre\|wopf\|npar\|Auml\|Barv\|bbrk\|Nopf\|nopf\|nmid\|nLtv\|beta\|ropf\|Ropf\|Beta\|beth\|nles\|rpar\|nleq\|bnot\|bNot\|nldr\|NJcy\|rscr\|Rscr\|Vscr\|vscr\|rsqb\|njcy\|bopf\|nisd\|Bopf\|rtri\|Vopf\|nGtv\|ngtr\|vopf\|boxh\|boxH\|boxv\|nges\|ngeq\|boxV\|bscr\|scap\|Bscr\|bsim\|Vert\|vert\|bsol\|bull\|bump\|caps\|cdot\|ncup\|scnE\|ncap\|nbsp\|napE\|Cdot\|cent\|sdot\|Vbar\|nang\|vBar\|chcy\|Mscr\|mscr\|sect\|semi\|CHcy\|Mopf\|mopf\|sext\|circ\|cire\|mldr\|mlcp\|cirE\|comp\|shcy\|SHcy\|vArr\|varr\|cong\|copf\|Copf\|copy\|COPY\|malt\|male\|macr\|lvnE\|cscr\|ltri\|sime\|ltcc\|simg\|Cscr\|siml\|csub\|Uuml\|lsqb\|lsim\|uuml\|csup\|Lscr\|lscr\|utri\|smid\|lpar\|cups\|smte\|lozf\|darr\|Lopf\|Uscr\|solb\|lopf\|sopf\|Sopf\|lneq\|uscr\|spar\|dArr\|lnap\|Darr\|dash\|Sqrt\|LJcy\|ljcy\|lHar\|dHar\|Upsi\|upsi\|diam\|lesg\|djcy\|DJcy\|leqq\|dopf\|Dopf\|dscr\|Dscr\|dscy\|ldsh\|ldca\|squf\|DScy\|sscr\|Sscr\|dsol\|lcub\|late\|star\|Star\|Uopf\|Larr\|lArr\|larr\|uopf\|dtri\|dzcy\|sube\|subE\|Lang\|lang\|Kscr\|kscr\|Kopf\|kopf\|KJcy\|kjcy\|KHcy\|khcy\|DZcy\|ecir\|edot\|eDot\|Jscr\|jscr\|succ\|Jopf\|jopf\|Edot\|uHar\|emsp\|ensp\|Iuml\|iuml\|eopf\|isin\|Iscr\|iscr\|Eopf\|epar\|sung\|epsi\|escr\|sup1\|sup2\|sup3\|Iota\|iota\|supe\|supE\|Iopf\|iopf\|IOcy\|iocy\|Escr\|esim\|Esim\|imof\|Uarr\|QUOT\|uArr\|uarr\|euml\|IEcy\|iecy\|Idot\|Euml\|euro\|excl\|Hscr\|hscr\|Hopf\|hopf\|TScy\|tscy\|Tscr\|hbar\|tscr\|flat\|tbrk\|fnof\|hArr\|harr\|half\|fopf\|Fopf\|tdot\|gvnE\|fork\|trie\|gtcc\|fscr\|Fscr\|gdot\|gsim\|Gscr\|gscr\|Gopf\|gopf\|gneq\|Gdot\|tosa\|gnap\|Topf\|topf\|geqq\|toea\|GJcy\|gjcy\|tint\|gesl\|mid\|Sfr\|ggg\|top\|ges\|gla\|glE\|glj\|geq\|gne\|gEl\|gel\|gnE\|Gcy\|gcy\|gap\|Tfr\|tfr\|Tcy\|tcy\|Hat\|Tau\|Ffr\|tau\|Tab\|hfr\|Hfr\|ffr\|Fcy\|fcy\|icy\|Icy\|iff\|ETH\|eth\|ifr\|Ifr\|Eta\|eta\|int\|Int\|Sup\|sup\|ucy\|Ucy\|Sum\|sum\|jcy\|ENG\|ufr\|Ufr\|eng\|Jcy\|jfr\|els\|ell\|egs\|Efr\|efr\|Jfr\|uml\|kcy\|Kcy\|Ecy\|ecy\|kfr\|Kfr\|lap\|Sub\|sub\|lat\|lcy\|Lcy\|leg\|Dot\|dot\|lEg\|leq\|les\|squ\|div\|die\|lfr\|Lfr\|lgE\|Dfr\|dfr\|Del\|deg\|Dcy\|dcy\|lne\|lnE\|sol\|loz\|smt\|Cup\|lrm\|cup\|lsh\|Lsh\|sim\|shy\|map\|Map\|mcy\|Mcy\|mfr\|Mfr\|mho\|gfr\|Gfr\|sfr\|cir\|Chi\|chi\|nap\|Cfr\|vcy\|Vcy\|cfr\|Scy\|scy\|ncy\|Ncy\|vee\|Vee\|Cap\|cap\|nfr\|scE\|sce\|Nfr\|nge\|ngE\|nGg\|vfr\|Vfr\|ngt\|bot\|nGt\|nis\|niv\|Rsh\|rsh\|nle\|nlE\|bne\|Bfr\|bfr\|nLl\|nlt\|nLt\|Bcy\|bcy\|not\|Not\|rlm\|wfr\|Wfr\|npr\|nsc\|num\|ocy\|ast\|Ocy\|ofr\|xfr\|Xfr\|Ofr\|ogt\|ohm\|apE\|olt\|Rho\|ape\|rho\|Rfr\|rfr\|ord\|REG\|ang\|reg\|orv\|And\|and\|AMP\|Rcy\|amp\|Afr\|ycy\|Ycy\|yen\|yfr\|Yfr\|rcy\|par\|pcy\|Pcy\|pfr\|Pfr\|phi\|Phi\|afr\|Acy\|acy\|zcy\|Zcy\|piv\|acE\|acd\|zfr\|Zfr\|pre\|prE\|psi\|Psi\|qfr\|Qfr\|zwj\|Or\|ge\|Gg\|gt\|gg\|el\|oS\|lt\|Lt\|LT\|Re\|lg\|gl\|eg\|ne\|Im\|it\|le\|DD\|wp\|wr\|nu\|Nu\|dd\|lE\|Sc\|sc\|pi\|Pi\|ee\|af\|ll\|Ll\|rx\|gE\|xi\|pm\|Xi\|ic\|pr\|Pr\|in\|ni\|mp\|mu\|ac\|Mu\|or\|ap\|Gt\|GT\|ii);\|&(Aacute\|Agrave\|Atilde\|Ccedil\|Eacute\|Egrave\|Iacute\|Igrave\|Ntilde\|Oacute\|Ograve\|Oslash\|Otilde\|Uacute\|Ugrave\|Yacute\|aacute\|agrave\|atilde\|brvbar\|ccedil\|curren\|divide\|eacute\|egrave\|frac12\|frac14\|frac34\|iacute\|igrave\|iquest\|middot\|ntilde\|oacute\|ograve\|oslash\|otilde\|plusmn\|uacute\|ugrave\|yacute\|AElig\|Acirc\|Aring\|Ecirc\|Icirc\|Ocirc\|THORN\|Ucirc\|acirc\|acute\|aelig\|aring\|cedil\|ecirc\|icirc\|iexcl\|laquo\|micro\|ocirc\|pound\|raquo\|szlig\|thorn\|times\|ucirc\|Auml\|COPY\|Euml\|Iuml\|Ouml\|QUOT\|Uuml\|auml\|cent\|copy\|euml\|iuml\|macr\|nbsp\|ordf\|ordm\|ouml\|para\|quot\|sect\|sup1\|sup2\|sup3\|uuml\|yuml\|AMP\|ETH\|REG\|amp\|deg\|eth\|not\|reg\|shy\|uml\|yen\|GT\|LT\|gt\|lt)(?!;)([=a-zA-Z0-9]?)\|&#([0-9]+)(;?)\|&#[xX]([a-fA-F0-9]+)(;?)\|&([0-9a-zA-Z]+)/g; var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'\|','Verbar':'\u2016','vert':'\|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'\|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'}; var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'}; var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'}; var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111]; /--------------------------------------------------------------------------/ var stringFromCharCode = String.fromCharCode; var object = {}; var hasOwnProperty = object.hasOwnProperty; var has = function(object, propertyName) { return hasOwnProperty.call(object, propertyName); }; var contains = function(array, value) { var index = -1; var length = array.length; while (++index < length) { if (array[index] == value) { return true; } } return false; }; var merge = function(options, defaults) { if (!options) { return defaults; } var result = {}; var key; for (key in defaults) { // A `hasOwnProperty` check is not needed here, since only recognized // option names are used anyway. Any others are ignored. result[key] = has(options, key) ? options[key] : defaults[key]; } return result; }; // Modified version of `ucs2encode`; see https://mths.be/punycode. var codePointToSymbol = function(codePoint, strict) { var output = ''; if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) \|\| codePoint > 0x10FFFF) { // See issue #4: // “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is // greater than 0x10FFFF, then this is a parse error. Return a U+FFFD // REPLACEMENT CHARACTER.” if (strict) { parseError('character reference outside the permissible Unicode range'); } return '\uFFFD'; } if (has(decodeMapNumeric, codePoint)) { if (strict) { parseError('disallowed character reference'); } return decodeMapNumeric[codePoint]; } if (strict && contains(invalidReferenceCodePoints, codePoint)) { parseError('disallowed character reference'); } if (codePoint > 0xFFFF) { codePoint -= 0x10000; output += stringFromCharCode(codePoint >>> 10 & 0x3FF \| 0xD800); codePoint = 0xDC00 \| codePoint & 0x3FF; } output += stringFromCharCode(codePoint); return output; }; var hexEscape = function(codePoint) { return '&#x' + codePoint.toString(16).toUpperCase() + ';'; }; var decEscape = function(codePoint) { return '&#' + codePoint + ';'; }; var parseError = function(message) { throw Error('Parse error: ' + message); }; /--------------------------------------------------------------------------/ var encode = function(string, options) { options = merge(options, encode.options); var strict = options.strict; if (strict && regexInvalidRawCodePoint.test(string)) { parseError('forbidden code point'); } var encodeEverything = options.encodeEverything; var useNamedReferences = options.useNamedReferences; var allowUnsafeSymbols = options.allowUnsafeSymbols; var escapeCodePoint = options.decimal ? decEscape : hexEscape; var escapeBmpSymbol = function(symbol) { return escapeCodePoint(symbol.charCodeAt(0)); }; if (encodeEverything) { // Encode ASCII symbols. string = string.replace(regexAsciiWhitelist, function(symbol) { // Use named references if requested & possible. if (useNamedReferences && has(encodeMap, symbol)) { return '&' + encodeMap[symbol] + ';'; } return escapeBmpSymbol(symbol); }); // Shorten a few escapes that represent two symbols, of which at least one // is within the ASCII range. if (useNamedReferences) { string = string .replace(/>\u20D2/g, '&nvgt;') .replace(/<\u20D2/g, '&nvlt;') .replace(/fj/g, '&fjlig;'); } // Encode non-ASCII symbols. if (useNamedReferences) { // Encode non-ASCII symbols that can be replaced with a named reference. string = string.replace(regexEncodeNonAscii, function(string) { // Note: there is no need to check `has(encodeMap, string)` here. return '&' + encodeMap[string] + ';'; }); } // Note: any remaining non-ASCII symbols are handled outside of the `if`. } else if (useNamedReferences) { // Apply named character references. // Encode `<>"'&` using named character references. if (!allowUnsafeSymbols) { string = string.replace(regexEscape, function(string) { return '&' + encodeMap[string] + ';'; // no need to check `has()` here }); } // Shorten escapes that represent two symbols, of which at least one is // `<>"'&`. string = string .replace(/>\u20D2/g, '&nvgt;') .replace(/<\u20D2/g, '&nvlt;'); // Encode non-ASCII symbols that can be replaced with a named reference. string = string.replace(regexEncodeNonAscii, function(string) { // Note: there is no need to check `has(encodeMap, string)` here. return '&' + encodeMap[string] + ';'; }); } else if (!allowUnsafeSymbols) { // Encode `<>"'&` using hexadecimal escapes, now that they’re not handled // using named character references. string = string.replace(regexEscape, escapeBmpSymbol); } return string // Encode astral symbols. .replace(regexAstralSymbols, function($0) { // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae var high = $0.charCodeAt(0); var low = $0.charCodeAt(1); var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000; return escapeCodePoint(codePoint); }) // Encode any remaining BMP symbols that are not printable ASCII symbols // using a hexadecimal escape. .replace(regexBmpWhitelist, escapeBmpSymbol); }; // Expose default options (so they can be overridden globally). encode.options = { 'allowUnsafeSymbols': false, 'encodeEverything': false, 'strict': false, 'useNamedReferences': false, 'decimal' : false }; var decode = function(html, options) { options = merge(options, decode.options); var strict = options.strict; if (strict && regexInvalidEntity.test(html)) { parseError('malformed character reference'); } return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) { var codePoint; var semicolon; var decDigits; var hexDigits; var reference; var next; if ($1) { reference = $1; // Note: there is no need to check `has(decodeMap, reference)`. return decodeMap[reference]; } if ($2) { // Decode named character references without trailing `;`, e.g. `&amp`. // This is only a parse error if it gets converted to `&`, or if it is // followed by `=` in an attribute context. reference = $2; next = $3; if (next && options.isAttributeValue) { if (strict && next == '=') { parseError('`&` did not start a character reference'); } return $0; } else { if (strict) { parseError( 'named character reference was not terminated by a semicolon' ); } // Note: there is no need to check `has(decodeMapLegacy, reference)`. return decodeMapLegacy[reference] + (next \|\| ''); } } if ($4) { // Decode decimal escapes, e.g. `𝌆`. decDigits = $4; semicolon = $5; if (strict && !semicolon) { parseError('character reference was not terminated by a semicolon'); } codePoint = parseInt(decDigits, 10); return codePointToSymbol(codePoint, strict); } if ($6) { // Decode hexadecimal escapes, e.g. `𝌆`. hexDigits = $6; semicolon = $7; if (strict && !semicolon) { parseError('character reference was not terminated by a semicolon'); } codePoint = parseInt(hexDigits, 16); return codePointToSymbol(codePoint, strict); } // If we’re still here, `if ($7)` is implied; it’s an ambiguous // ampersand for sure. https://mths.be/notes/ambiguous-ampersands if (strict) { parseError( 'named character reference was not terminated by a semicolon' ); } return $0; }); }; // Expose default options (so they can be overridden globally). decode.options = { 'isAttributeValue': false, 'strict': false }; var escape = function(string) { return string.replace(regexEscape, function($0) { // Note: there is no need to check `has(escapeMap, $0)` here. return escapeMap[$0]; }); }; /--------------------------------------------------------------------------/ var he = { 'version': '1.2.0', 'encode': encode, 'decode': decode, 'escape': escape, 'unescape': decode }; // Some AMD build optimizers, like r.js, check for specific condition patterns // like the following: if (freeExports && !freeExports.nodeType) { if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+ freeModule.exports = he; } else { // in Narwhal or RingoJS v0.7.0- for (var key in he) { has(he, key) && (freeExports[key] = he[key]); } } } else { // in Rhino or a web browser root.he = he; } }(commonjsGlobal)); } (he$1, he$1.exports)); var he = he$1.exports; /** * Cross-platform code generation for component v-model / function genComponentModel(el, value, modifiers) { const { number, trim } = modifiers \|\| {}; const baseValueExpression = '$$v'; let valueExpression = baseValueExpression; if (trim) { valueExpression = `(typeof ${baseValueExpression} === 'string'` + `? ${baseValueExpression}.trim()` + `: ${baseValueExpression})`; } if (number) { valueExpression = `_n(${valueExpression})`; } const assignment = genAssignmentCode(value, valueExpression); el.model = { value: `(${value})`, expression: JSON.stringify(value), callback: `function (${baseValueExpression}) {${assignment}}` }; } /* * Cross-platform codegen helper for generating v-model value assignment code. / function genAssignmentCode(value, assignment) { const res = parseModel(value); if (res.key === null) { return `${value}=${assignment}`; } else { return `$set(${res.exp}, ${res.key}, ${assignment})`; } } /* * Parse a v-model expression into a base path and a final key segment. * Handles both dot-path and possible square brackets. * * Possible cases: * * - test * - test[key] * - test[test1[key]] * - test["a"][key] * - xxx.test[a[a].test1[key]] * - test.xxx.a["asa"][test1[key]] * / let len, str$1, chr, index, expressionPos, expressionEndPos; function parseModel(val) { // Fix https://github.com/vuejs/vue/pull/7730 // allow v-model="obj.val " (trailing whitespace) val = val.trim(); len = val.length; if (val.indexOf('[') < 0 \|\| val.lastIndexOf(']') < len - 1) { index = val.lastIndexOf('.'); if (index > -1) { return { exp: val.slice(0, index), key: '"' + val.slice(index + 1) + '"' }; } else { return { exp: val, key: null }; } } str$1 = val; index = expressionPos = expressionEndPos = 0; while (!eof()) { chr = next(); / istanbul ignore if / if (isStringStart(chr)) { parseString(chr); } else if (chr === 0x5b) { parseBracket(chr); } } return { exp: val.slice(0, expressionPos), key: val.slice(expressionPos + 1, expressionEndPos) }; } function next() { return str$1.charCodeAt(++index); } function eof() { return index >= len; } function isStringStart(chr) { return chr === 0x22 \|\| chr === 0x27; } function parseBracket(chr) { let inBracket = 1; expressionPos = index; while (!eof()) { chr = next(); if (isStringStart(chr)) { parseString(chr); continue; } if (chr === 0x5b) inBracket++; if (chr === 0x5d) inBracket--; if (inBracket === 0) { expressionEndPos = index; break; } } } function parseString(chr) { const stringQuote = chr; while (!eof()) { chr = next(); if (chr === stringQuote) { break; } } } const onRE = /^@\|^v-on:/; const dirRE = /^v-\|^@\|^:\|^#/; const forAliasRE$1 = /([\s\S]?)\s+(?:in\|of)\s+([\s\S])/; const forIteratorRE = /,([^,\}\]])(?:,([^,\}\]]))?$/; const stripParensRE = /^$\|$$/g; const dynamicArgRE = /^\[.\]$/; const argRE = /:(.)$/; const bindRE = /^:\|^\.\|^v-bind:/; const modifierRE = /\.[^.\]]+(?=[^\]]$)/g; const slotRE = /^v-slot(:\|$)\|^#/; const lineBreakRE = /[\r\n]/; const whitespaceRE = /[ \f\t\r\n]+/g; const invalidAttributeRE = /[\s"'<>\/=]/; const decodeHTMLCached = cached(he.decode); const emptySlotScopeToken = `_empty_`; // configurable state let warn$2; let delimiters; let transforms; let preTransforms; let postTransforms; let platformIsPreTag; let platformMustUseProp; let platformGetTagNamespace; let maybeComponent; function createASTElement(tag, attrs, parent) { return { type: 1, tag, attrsList: attrs, attrsMap: makeAttrsMap(attrs), rawAttrsMap: {}, parent, children: [] }; } /** * Convert HTML string to AST. / function parse$1(template, options) { warn$2 = options.warn \|\| baseWarn; platformIsPreTag = options.isPreTag \|\| no; platformMustUseProp = options.mustUseProp \|\| no; platformGetTagNamespace = options.getTagNamespace \|\| no; const isReservedTag = options.isReservedTag \|\| no; maybeComponent = (el) => !!(el.component \|\| el.attrsMap[':is'] \|\| el.attrsMap['v-bind:is'] \|\| !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); transforms = pluckModuleFunction(options.modules, 'transformNode'); preTransforms = pluckModuleFunction(options.modules, 'preTransformNode'); postTransforms = pluckModuleFunction(options.modules, 'postTransformNode'); delimiters = options.delimiters; const stack = []; const preserveWhitespace = options.preserveWhitespace !== false; const whitespaceOption = options.whitespace; let root; let currentParent; let inVPre = false; let inPre = false; let warned = false; function warnOnce(msg, range) { if (!warned) { warned = true; warn$2(msg, range); } } function closeElement(element) { trimEndingWhitespace(element); if (!inVPre && !element.processed) { element = processElement(element, options); } // tree management if (!stack.length && element !== root) { // allow root elements with v-if, v-else-if and v-else if (root.if && (element.elseif \|\| element.else)) { if (process.env.NODE_ENV !== 'production') { checkRootConstraints(element); } addIfCondition(root, { exp: element.elseif, block: element }); } else if (process.env.NODE_ENV !== 'production') { warnOnce(`Component template should contain exactly one root element. ` + `If you are using v-if on multiple elements, ` + `use v-else-if to chain them instead.`, { start: element.start }); } } if (currentParent && !element.forbidden) { if (element.elseif \|\| element.else) { processIfConditions(element, currentParent); } else { if (element.slotScope) { // scoped slot // keep it in the children list so that v-else(-if) conditions can // find it as the prev node. const name = element.slotTarget \|\| '"default"'; (currentParent.scopedSlots \|\| (currentParent.scopedSlots = {}))[name] = element; } currentParent.children.push(element); element.parent = currentParent; } } // final children cleanup // filter out scoped slots element.children = element.children.filter(c => !c.slotScope); // remove trailing whitespace node again trimEndingWhitespace(element); // check pre state if (element.pre) { inVPre = false; } if (platformIsPreTag(element.tag)) { inPre = false; } // apply post-transforms for (let i = 0; i < postTransforms.length; i++) { postTransforms[i](element, options); } } function trimEndingWhitespace(el) { // remove trailing whitespace node if (!inPre) { let lastNode; while ((lastNode = el.children[el.children.length - 1]) && lastNode.type === 3 && lastNode.text === ' ') { el.children.pop(); } } } function checkRootConstraints(el) { if (el.tag === 'slot' \|\| el.tag === 'template') { warnOnce(`Cannot use <${el.tag}> as component root element because it may ` + 'contain multiple nodes.', { start: el.start }); } if (el.attrsMap.hasOwnProperty('v-for')) { warnOnce('Cannot use v-for on stateful component root element because ' + 'it renders multiple elements.', el.rawAttrsMap['v-for']); } } parseHTML(template, { warn: warn$2, expectHTML: options.expectHTML, isUnaryTag: options.isUnaryTag, canBeLeftOpenTag: options.canBeLeftOpenTag, shouldDecodeNewlines: options.shouldDecodeNewlines, shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref, shouldKeepComment: options.comments, outputSourceRange: options.outputSourceRange, start(tag, attrs, unary, start, end) { // check namespace. // inherit parent ns if there is one const ns = (currentParent && currentParent.ns) \|\| platformGetTagNamespace(tag); // handle IE svg bug / istanbul ignore if / if (isIE && ns === 'svg') { attrs = guardIESVGBug(attrs); } let element = createASTElement(tag, attrs, currentParent); if (ns) { element.ns = ns; } if (process.env.NODE_ENV !== 'production') { if (options.outputSourceRange) { element.start = start; element.end = end; element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => { cumulated[attr.name] = attr; return cumulated; }, {}); } attrs.forEach(attr => { if (invalidAttributeRE.test(attr.name)) { warn$2(`Invalid dynamic argument expression: attribute names cannot contain ` + `spaces, quotes, <, >, / or =.`, options.outputSourceRange ? { start: attr.start + attr.name.indexOf(`[`), end: attr.start + attr.name.length } : undefined); } }); } if (isForbiddenTag(element) && !isServerRendering()) { element.forbidden = true; process.env.NODE_ENV !== 'production' && warn$2('Templates should only be responsible for mapping the state to the ' + 'UI. Avoid placing tags with side-effects in your templates, such as ' + `<${tag}>` + ', as they will not be parsed.', { start: element.start }); } // apply pre-transforms for (let i = 0; i < preTransforms.length; i++) { element = preTransforms[i](element, options) \|\| element; } if (!inVPre) { processPre(element); if (element.pre) { inVPre = true; } } if (platformIsPreTag(element.tag)) { inPre = true; } if (inVPre) { processRawAttrs(element); } else if (!element.processed) { // structural directives processFor(element); processIf(element); processOnce(element); } if (!root) { root = element; if (process.env.NODE_ENV !== 'production') { checkRootConstraints(root); } } if (!unary) { currentParent = element; stack.push(element); } else { closeElement(element); } }, end(tag, start, end) { const element = stack[stack.length - 1]; // pop stack stack.length -= 1; currentParent = stack[stack.length - 1]; if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) { element.end = end; } closeElement(element); }, chars(text, start, end) { if (!currentParent) { if (process.env.NODE_ENV !== 'production') { if (text === template) { warnOnce('Component template requires a root element, rather than just text.', { start }); } else if ((text = text.trim())) { warnOnce(`text "${text}" outside root element will be ignored.`, { start }); } } return; } // IE textarea placeholder bug / istanbul ignore if / if (isIE && currentParent.tag === 'textarea' && currentParent.attrsMap.placeholder === text) { return; } const children = currentParent.children; if (inPre \|\| text.trim()) { text = isTextTag(currentParent) ? text : decodeHTMLCached(text); } else if (!children.length) { // remove the whitespace-only node right after an opening tag text = ''; } else if (whitespaceOption) { if (whitespaceOption === 'condense') { // in condense mode, remove the whitespace node if it contains // line break, otherwise condense to a single space text = lineBreakRE.test(text) ? '' : ' '; } else { text = ' '; } } else { text = preserveWhitespace ? ' ' : ''; } if (text) { if (!inPre && whitespaceOption === 'condense') { // condense consecutive whitespaces into single space text = text.replace(whitespaceRE, ' '); } let res; let child; if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) { child = { type: 2, expression: res.expression, tokens: res.tokens, text }; } else if (text !== ' ' \|\| !children.length \|\| children[children.length - 1].text !== ' ') { child = { type: 3, text }; } if (child) { if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) { child.start = start; child.end = end; } children.push(child); } } }, comment(text, start, end) { // adding anything as a sibling to the root node is forbidden // comments should still be allowed, but ignored if (currentParent) { const child = { type: 3, text, isComment: true }; if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) { child.start = start; child.end = end; } currentParent.children.push(child); } } }); return root; } function processPre(el) { if (getAndRemoveAttr(el, 'v-pre') != null) { el.pre = true; } } function processRawAttrs(el) { const list = el.attrsList; const len = list.length; if (len) { const attrs = (el.attrs = new Array(len)); for (let i = 0; i < len; i++) { attrs[i] = { name: list[i].name, value: JSON.stringify(list[i].value) }; if (list[i].start != null) { attrs[i].start = list[i].start; attrs[i].end = list[i].end; } } } else if (!el.pre) { // non root node in pre blocks with no attributes el.plain = true; } } function processElement(element, options) { processKey(element); // determine whether this is a plain element after // removing structural attributes element.plain = !element.key && !element.scopedSlots && !element.attrsList.length; processRef(element); processSlotContent(element); processSlotOutlet(element); processComponent(element); for (let i = 0; i < transforms.length; i++) { element = transforms[i](element, options) \|\| element; } processAttrs(element); return element; } function processKey(el) { const exp = getBindingAttr(el, 'key'); if (exp) { if (process.env.NODE_ENV !== 'production') { if (el.tag === 'template') { warn$2(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key')); } if (el.for) { const iterator = el.iterator2 \|\| el.iterator1; const parent = el.parent; if (iterator && iterator === exp && parent && parent.tag === 'transition-group') { warn$2(`Do not use v-for index as key on <transition-group> children, ` + `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true / tip /); } } } el.key = exp; } } function processRef(el) { const ref = getBindingAttr(el, 'ref'); if (ref) { el.ref = ref; el.refInFor = checkInFor(el); } } function processFor(el) { let exp; if ((exp = getAndRemoveAttr(el, 'v-for'))) { const res = parseFor(exp); if (res) { extend(el, res); } else if (process.env.NODE_ENV !== 'production') { warn$2(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']); } } } function parseFor(exp) { const inMatch = exp.match(forAliasRE$1); if (!inMatch) return; const res = {}; res.for = inMatch[2].trim(); const alias = inMatch[1].trim().replace(stripParensRE, ''); const iteratorMatch = alias.match(forIteratorRE); if (iteratorMatch) { res.alias = alias.replace(forIteratorRE, '').trim(); res.iterator1 = iteratorMatch[1].trim(); if (iteratorMatch[2]) { res.iterator2 = iteratorMatch[2].trim(); } } else { res.alias = alias; } return res; } function processIf(el) { const exp = getAndRemoveAttr(el, 'v-if'); if (exp) { el.if = exp; addIfCondition(el, { exp: exp, block: el }); } else { if (getAndRemoveAttr(el, 'v-else') != null) { el.else = true; } const elseif = getAndRemoveAttr(el, 'v-else-if'); if (elseif) { el.elseif = elseif; } } } function processIfConditions(el, parent) { const prev = findPrevElement(parent.children); if (prev && prev.if) { addIfCondition(prev, { exp: el.elseif, block: el }); } else if (process.env.NODE_ENV !== 'production') { warn$2(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` + `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']); } } function findPrevElement(children) { let i = children.length; while (i--) { if (children[i].type === 1) { return children[i]; } else { if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') { warn$2(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` + `will be ignored.`, children[i]); } children.pop(); } } } function addIfCondition(el, condition) { if (!el.ifConditions) { el.ifConditions = []; } el.ifConditions.push(condition); } function processOnce(el) { const once = getAndRemoveAttr(el, 'v-once'); if (once != null) { el.once = true; } } // handle content being passed to a component as slot, // e.g. <template slot="xxx">, <div slot-scope="xxx"> function processSlotContent(el) { let slotScope; if (el.tag === 'template') { slotScope = getAndRemoveAttr(el, 'scope'); / istanbul ignore if / if (process.env.NODE_ENV !== 'production' && slotScope) { warn$2(`the "scope" attribute for scoped slots have been deprecated and ` + `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` + `can also be used on plain elements in addition to <template> to ` + `denote scoped slots.`, el.rawAttrsMap['scope'], true); } el.slotScope = slotScope \|\| getAndRemoveAttr(el, 'slot-scope'); } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) { / istanbul ignore if / if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) { warn$2(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` + `(v-for takes higher priority). Use a wrapper <template> for the ` + `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true); } el.slotScope = slotScope; } // slot="xxx" const slotTarget = getBindingAttr(el, 'slot'); if (slotTarget) { el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget; el.slotTargetDynamic = !!(el.attrsMap[':slot'] \|\| el.attrsMap['v-bind:slot']); // preserve slot as an attribute for native shadow DOM compat // only for non-scoped slots. if (el.tag !== 'template' && !el.slotScope) { addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot')); } } // 2.6 v-slot syntax { if (el.tag === 'template') { // v-slot on <template> const slotBinding = getAndRemoveAttrByRegex(el, slotRE); if (slotBinding) { if (process.env.NODE_ENV !== 'production') { if (el.slotTarget \|\| el.slotScope) { warn$2(`Unexpected mixed usage of different slot syntaxes.`, el); } if (el.parent && !maybeComponent(el.parent)) { warn$2(`<template v-slot> can only appear at the root level inside ` + `the receiving component`, el); } } const { name, dynamic } = getSlotName(slotBinding); el.slotTarget = name; el.slotTargetDynamic = dynamic; el.slotScope = slotBinding.value \|\| emptySlotScopeToken; // force it into a scoped slot for perf } } else { // v-slot on component, denotes default slot const slotBinding = getAndRemoveAttrByRegex(el, slotRE); if (slotBinding) { if (process.env.NODE_ENV !== 'production') { if (!maybeComponent(el)) { warn$2(`v-slot can only be used on components or <template>.`, slotBinding); } if (el.slotScope \|\| el.slotTarget) { warn$2(`Unexpected mixed usage of different slot syntaxes.`, el); } if (el.scopedSlots) { warn$2(`To avoid scope ambiguity, the default slot should also use ` + `<template> syntax when there are other named slots.`, slotBinding); } } // add the component's children to its default slot const slots = el.scopedSlots \|\| (el.scopedSlots = {}); const { name, dynamic } = getSlotName(slotBinding); const slotContainer = (slots[name] = createASTElement('template', [], el)); slotContainer.slotTarget = name; slotContainer.slotTargetDynamic = dynamic; slotContainer.children = el.children.filter((c) => { if (!c.slotScope) { c.parent = slotContainer; return true; } }); slotContainer.slotScope = slotBinding.value \|\| emptySlotScopeToken; // remove children as they are returned from scopedSlots now el.children = []; // mark el non-plain so data gets generated el.plain = false; } } } } function getSlotName(binding) { let name = binding.name.replace(slotRE, ''); if (!name) { if (binding.name[0] !== '#') { name = 'default'; } else if (process.env.NODE_ENV !== 'production') { warn$2(`v-slot shorthand syntax requires a slot name.`, binding); } } return dynamicArgRE.test(name) ? // dynamic [name] { name: name.slice(1, -1), dynamic: true } : // static name { name: `"${name}"`, dynamic: false }; } // handle <slot/> outlets function processSlotOutlet(el) { if (el.tag === 'slot') { el.slotName = getBindingAttr(el, 'name'); if (process.env.NODE_ENV !== 'production' && el.key) { warn$2(`\`key\` does not work on <slot> because slots are abstract outlets ` + `and can possibly expand into multiple elements. ` + `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key')); } } } function processComponent(el) { let binding; if ((binding = getBindingAttr(el, 'is'))) { el.component = binding; } if (getAndRemoveAttr(el, 'inline-template') != null) { el.inlineTemplate = true; } } function processAttrs(el) { const list = el.attrsList; let i, l, name, rawName, value, modifiers, syncGen, isDynamic; for (i = 0, l = list.length; i < l; i++) { name = rawName = list[i].name; value = list[i].value; if (dirRE.test(name)) { // mark element as dynamic el.hasBindings = true; // modifiers modifiers = parseModifiers(name.replace(dirRE, '')); // support .foo shorthand syntax for the .prop modifier if (modifiers) { name = name.replace(modifierRE, ''); } if (bindRE.test(name)) { // v-bind name = name.replace(bindRE, ''); value = parseFilters(value); isDynamic = dynamicArgRE.test(name); if (isDynamic) { name = name.slice(1, -1); } if (process.env.NODE_ENV !== 'production' && value.trim().length === 0) { warn$2(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`); } if (modifiers) { if (modifiers.prop && !isDynamic) { name = camelize(name); if (name === 'innerHtml') name = 'innerHTML'; } if (modifiers.camel && !isDynamic) { name = camelize(name); } if (modifiers.sync) { syncGen = genAssignmentCode(value, `$event`); if (!isDynamic) { addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$2, list[i]); if (hyphenate(name) !== camelize(name)) { addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$2, list[i]); } } else { // handler w/ dynamic event name addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$2, list[i], true // dynamic ); } } } if ((modifiers && modifiers.prop) \|\| (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) { addProp(el, name, value, list[i], isDynamic); } else { addAttr(el, name, value, list[i], isDynamic); } } else if (onRE.test(name)) { // v-on name = name.replace(onRE, ''); isDynamic = dynamicArgRE.test(name); if (isDynamic) { name = name.slice(1, -1); } addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic); } else { // normal directives name = name.replace(dirRE, ''); // parse arg const argMatch = name.match(argRE); let arg = argMatch && argMatch[1]; isDynamic = false; if (arg) { name = name.slice(0, -(arg.length + 1)); if (dynamicArgRE.test(arg)) { arg = arg.slice(1, -1); isDynamic = true; } } addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]); if (process.env.NODE_ENV !== 'production' && name === 'model') { checkForAliasModel(el, value); } } } else { // literal attribute if (process.env.NODE_ENV !== 'production') { const res = parseText(value, delimiters); if (res) { warn$2(`${name}="${value}": ` + 'Interpolation inside attributes has been removed. ' + 'Use v-bind or the colon shorthand instead. For example, ' + 'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]); } } addAttr(el, name, JSON.stringify(value), list[i]); // #6887 firefox doesn't update muted state if set via attribute // even immediately after element creation if (!el.component && name === 'muted' && platformMustUseProp(el.tag, el.attrsMap.type, name)) { addProp(el, name, 'true', list[i]); } } } } function checkInFor(el) { let parent = el; while (parent) { if (parent.for !== undefined) { return true; } parent = parent.parent; } return false; } function parseModifiers(name) { const match = name.match(modifierRE); if (match) { const ret = {}; match.forEach(m => { ret[m.slice(1)] = true; }); return ret; } } function makeAttrsMap(attrs) { const map = {}; for (let i = 0, l = attrs.length; i < l; i++) { if (process.env.NODE_ENV !== 'production' && map[attrs[i].name] && !isIE && !isEdge) { warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]); } map[attrs[i].name] = attrs[i].value; } return map; } // for script (e.g. type="x/template") or style, do not decode content function isTextTag(el) { return el.tag === 'script' \|\| el.tag === 'style'; } function isForbiddenTag(el) { return (el.tag === 'style' \|\| (el.tag === 'script' && (!el.attrsMap.type \|\| el.attrsMap.type === 'text/javascript'))); } const ieNSBug = /^xmlns:NS\d+/; const ieNSPrefix = /^NS\d+:/; / istanbul ignore next / function guardIESVGBug(attrs) { const res = []; for (let i = 0; i < attrs.length; i++) { const attr = attrs[i]; if (!ieNSBug.test(attr.name)) { attr.name = attr.name.replace(ieNSPrefix, ''); res.push(attr); } } return res; } function checkForAliasModel(el, value) { let _el = el; while (_el) { if (_el.for && _el.alias === value) { warn$2(`<${el.tag} v-model="${value}">: ` + `You are binding v-model directly to a v-for iteration alias. ` + `This will not be able to modify the v-for source array because ` + `writing to the alias is like modifying a function local variable. ` + `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']); } _el = _el.parent; } } /* * Expand input[v-model] with dynamic type bindings into v-if-else chains * Turn this: * <input v-model="data[type]" :type="type"> * into this: * <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]"> * <input v-else-if="type === 'radio'" type="radio" v-model="data[type]"> * <input v-else :type="type" v-model="data[type]"> / function preTransformNode(el, options) { if (el.tag === 'input') { const map = el.attrsMap; if (!map['v-model']) { return; } let typeBinding; if (map[':type'] \|\| map['v-bind:type']) { typeBinding = getBindingAttr(el, 'type'); } if (!map.type && !typeBinding && map['v-bind']) { typeBinding = `(${map['v-bind']}).type`; } if (typeBinding) { const ifCondition = getAndRemoveAttr(el, 'v-if', true); const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``; const hasElse = getAndRemoveAttr(el, 'v-else', true) != null; const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true); // 1. checkbox const branch0 = cloneASTElement(el); // process for on the main node processFor(branch0); addRawAttr(branch0, 'type', 'checkbox'); processElement(branch0, options); branch0.processed = true; // prevent it from double-processed branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra; addIfCondition(branch0, { exp: branch0.if, block: branch0 }); // 2. add radio else-if condition const branch1 = cloneASTElement(el); getAndRemoveAttr(branch1, 'v-for', true); addRawAttr(branch1, 'type', 'radio'); processElement(branch1, options); addIfCondition(branch0, { exp: `(${typeBinding})==='radio'` + ifConditionExtra, block: branch1 }); // 3. other const branch2 = cloneASTElement(el); getAndRemoveAttr(branch2, 'v-for', true); addRawAttr(branch2, ':type', typeBinding); processElement(branch2, options); addIfCondition(branch0, { exp: ifCondition, block: branch2 }); if (hasElse) { branch0.else = true; } else if (elseIfCondition) { branch0.elseif = elseIfCondition; } return branch0; } } } function cloneASTElement(el) { return createASTElement(el.tag, el.attrsList.slice(), el.parent); } var model$1 = { preTransformNode }; var modules = [klass, style, model$1]; let warn$1; // in some cases, the event used has to be determined at runtime // so we used some reserved tokens during compile. const RANGE_TOKEN = '__r'; function model(el, dir, _warn) { warn$1 = _warn; const value = dir.value; const modifiers = dir.modifiers; const tag = el.tag; const type = el.attrsMap.type; if (process.env.NODE_ENV !== 'production') { // inputs with type="file" are read only and setting the input's // value will throw an error. if (tag === 'input' && type === 'file') { warn$1(`<${el.tag} v-model="${value}" type="file">:\n` + `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']); } } if (el.component) { genComponentModel(el, value, modifiers); // component v-model doesn't need extra runtime return false; } else if (tag === 'select') { genSelect(el, value, modifiers); } else if (tag === 'input' && type === 'checkbox') { genCheckboxModel(el, value, modifiers); } else if (tag === 'input' && type === 'radio') { genRadioModel(el, value, modifiers); } else if (tag === 'input' \|\| tag === 'textarea') { genDefaultModel(el, value, modifiers); } else { genComponentModel(el, value, modifiers); // component v-model doesn't need extra runtime return false; } // ensure runtime directive metadata return true; } function genCheckboxModel(el, value, modifiers) { const number = modifiers && modifiers.number; const valueBinding = getBindingAttr(el, 'value') \|\| 'null'; const trueValueBinding = getBindingAttr(el, 'true-value') \|\| 'true'; const falseValueBinding = getBindingAttr(el, 'false-value') \|\| 'false'; addProp(el, 'checked', `Array.isArray(${value})` + `?_i(${value},${valueBinding})>-1` + (trueValueBinding === 'true' ? `:(${value})` : `:_q(${value},${trueValueBinding})`)); addHandler(el, 'change', `var $$a=${value},` + '$$el=$event.target,' + `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` + 'if(Array.isArray($$a)){' + `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` + '$$i=_i($$a,$$v);' + `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` + `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` + `}else{${genAssignmentCode(value, '$$c')}}`, null, true); } function genRadioModel(el, value, modifiers) { const number = modifiers && modifiers.number; let valueBinding = getBindingAttr(el, 'value') \|\| 'null'; valueBinding = number ? `_n(${valueBinding})` : valueBinding; addProp(el, 'checked', `_q(${value},${valueBinding})`); addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true); } function genSelect(el, value, modifiers) { const number = modifiers && modifiers.number; const selectedVal = `Array.prototype.filter` + `.call($event.target.options,function(o){return o.selected})` + `.map(function(o){var val = "_value" in o ? o._value : o.value;` + `return ${number ? '_n(val)' : 'val'}})`; const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'; let code = `var $$selectedVal = ${selectedVal};`; code = `${code} ${genAssignmentCode(value, assignment)}`; addHandler(el, 'change', code, null, true); } function genDefaultModel(el, value, modifiers) { const type = el.attrsMap.type; // warn if v-bind:value conflicts with v-model // except for inputs with v-bind:type if (process.env.NODE_ENV !== 'production') { const value = el.attrsMap['v-bind:value'] \|\| el.attrsMap[':value']; const typeBinding = el.attrsMap['v-bind:type'] \|\| el.attrsMap[':type']; if (value && !typeBinding) { const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'; warn$1(`${binding}="${value}" conflicts with v-model on the same element ` + 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]); } } const { lazy, number, trim } = modifiers \|\| {}; const needCompositionGuard = !lazy && type !== 'range'; const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'; let valueExpression = '$event.target.value'; if (trim) { valueExpression = `$event.target.value.trim()`; } if (number) { valueExpression = `_n(${valueExpression})`; } let code = genAssignmentCode(value, valueExpression); if (needCompositionGuard) { code = `if($event.target.composing)return;${code}`; } addProp(el, 'value', `(${value})`); addHandler(el, event, code, null, true); if (trim \|\| number) { addHandler(el, 'blur', '$forceUpdate()'); } } function text(el, dir) { if (dir.value) { addProp(el, 'textContent', `_s(${dir.value})`, dir); } } function html(el, dir) { if (dir.value) { addProp(el, 'innerHTML', `_s(${dir.value})`, dir); } } var directives = { model, text, html }; const baseOptions = { expectHTML: true, modules, directives, isPreTag, isUnaryTag, mustUseProp, canBeLeftOpenTag, isReservedTag, getTagNamespace, staticKeys: genStaticKeys$1(modules) }; const hasWarned = {}; function warnOnce(msg) { const isNodeProd = typeof process !== 'undefined' && process.env.NODE_ENV === 'production'; if (!isNodeProd && !hasWarned[msg]) { hasWarned[msg] = true; warn(msg); } } function warn(msg) { console.warn(`\x1b[1m\x1b[33m[@vue/compiler-sfc]\x1b[0m\x1b[33m ${msg}\x1b[0m\n`); } const doNotPrefix = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' + 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' + 'require,' + // for webpack 'arguments,' + // parsed as identifier but is a special keyword... '_c' // cached to save property access ); /* * The input is expected to be a valid expression. / function prefixIdentifiers(source, isFunctional = false, isTS = false, babelOptions = {}, bindings) { const s = new MagicString(source); const plugins = [ ...(isTS ? ['typescript'] : []), ...((babelOptions === null \|\| babelOptions === void 0 ? void 0 : babelOptions.plugins) \|\| []) ]; const ast = parser$1.parseExpression(source, Object.assign(Object.assign({}, babelOptions), { plugins })); const isScriptSetup = bindings && bindings.__isScriptSetup !== false; walkIdentifiers(ast, (ident, parent) => { const { name } = ident; if (doNotPrefix(name)) { return; } let prefix = `_vm.`; if (isScriptSetup) { const type = bindings[name]; if (type && type.startsWith('setup')) { prefix = `_setup.`; } } if (isStaticProperty(parent) && parent.shorthand) { // property shorthand like { foo }, we need to add the key since // we rewrite the value // { foo } -> { foo: _vm.foo } s.appendLeft(ident.end, `: ${prefix}${name}`); } else { s.prependRight(ident.start, prefix); } }, node => { if (node.type === 'WithStatement') { s.remove(node.start, node.body.start + 1); s.remove(node.end - 1, node.end); if (!isFunctional) { s.prependRight(node.start, `var _vm=this,_c=_vm._self._c${isScriptSetup ? `,_setup=_vm._self._setupProxy;` : `;`}`); } } }); return s.toString(); } const CSS_VARS_HELPER = `useCssVars`; function genCssVarsFromList(vars, id, isProd, isSSR = false) { return `{\n ${vars .map(key => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd)}": (${key})`) .join(',\n ')}\n}`; } function genVarName(id, raw, isProd) { if (isProd) { return hashSum(id + raw); } else { return `${id}-${raw.replace(/([^\w-])/g, '_')}`; } } function normalizeExpression(exp) { exp = exp.trim(); if ((exp[0] === `'` && exp[exp.length - 1] === `'`) \|\| (exp[0] === `"` && exp[exp.length - 1] === `"`)) { return exp.slice(1, -1); } return exp; } const vBindRE = /v-bind\s\(/g; function parseCssVars(sfc) { const vars = []; sfc.styles.forEach(style => { let match; // ignore v-bind() in comments /* ... / const content = style.content.replace(/\/\([\s\S]?)\\//g, ''); while ((match = vBindRE.exec(content))) { const start = match.index + match[0].length; const end = lexBinding(content, start); if (end !== null) { const variable = normalizeExpression(content.slice(start, end)); if (!vars.includes(variable)) { vars.push(variable); } } } }); return vars; } function lexBinding(content, start) { let state = 0 /* LexerState.inParens /; let parenDepth = 0; for (let i = start; i < content.length; i++) { const char = content.charAt(i); switch (state) { case 0 / LexerState.inParens /: if (char === `'`) { state = 1 / LexerState.inSingleQuoteString /; } else if (char === `"`) { state = 2 / LexerState.inDoubleQuoteString /; } else if (char === `(`) { parenDepth++; } else if (char === `)`) { if (parenDepth > 0) { parenDepth--; } else { return i; } } break; case 1 / LexerState.inSingleQuoteString /: if (char === `'`) { state = 0 / LexerState.inParens /; } break; case 2 / LexerState.inDoubleQuoteString /: if (char === `"`) { state = 0 / LexerState.inParens /; } break; } } return null; } const cssVarsPlugin = opts => { const { id, isProd } = opts; return { postcssPlugin: 'vue-sfc-vars', Declaration(decl) { // rewrite CSS variables const value = decl.value; if (vBindRE.test(value)) { vBindRE.lastIndex = 0; let transformed = ''; let lastIndex = 0; let match; while ((match = vBindRE.exec(value))) { const start = match.index + match[0].length; const end = lexBinding(value, start); if (end !== null) { const variable = normalizeExpression(value.slice(start, end)); transformed += value.slice(lastIndex, match.index) + `var(--${genVarName(id, variable, isProd)})`; lastIndex = end + 1; } } decl.value = transformed + value.slice(lastIndex); } } }; }; cssVarsPlugin.postcss = true; function genCssVarsCode(vars, bindings, id, isProd) { const varsExp = genCssVarsFromList(vars, id, isProd); return `_${CSS_VARS_HELPER}((_vm, _setup) => ${prefixIdentifiers(`(${varsExp})`, false, false, undefined, bindings)})`; } // <script setup> already gets the calls injected as part of the transform // this is only for single normal <script> function genNormalScriptCssVarsCode(cssVars, bindings, id, isProd) { return (`\nimport { ${CSS_VARS_HELPER} as _${CSS_VARS_HELPER} } from 'vue'\n` + `const __injectCSSVars__ = () => {\n${genCssVarsCode(cssVars, bindings, id, isProd)}}\n` + `const __setup__ = __default__.setup\n` + `__default__.setup = __setup__\n` + ` ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }\n` + ` : __injectCSSVars__\n`); } const defaultExportRE = /((?:^\|\n\|;)\s)export(\s)default/; const namedDefaultExportRE = /((?:^\|\n\|;)\s)export(.+)(?:as)?(\s)default/s; const exportDefaultClassRE = /((?:^\|\n\|;)\s)export\s+default\s+class\s+([\w$]+)/; /** * Utility for rewriting `export default` in a script block into a variable * declaration so that we can inject things into it / function rewriteDefault(input, as, parserPlugins) { if (!hasDefaultExport(input)) { return input + `\nconst ${as} = {}`; } let replaced; const classMatch = input.match(exportDefaultClassRE); if (classMatch) { replaced = input.replace(exportDefaultClassRE, '$1class $2') + `\nconst ${as} = ${classMatch[2]}`; } else { replaced = input.replace(defaultExportRE, `$1const ${as} =`); } if (!hasDefaultExport(replaced)) { return replaced; } // if the script somehow still contains `default export`, it probably has // multi-line comments or template strings. fallback to a full parse. const s = new MagicString(input); const ast = parser$1.parse(input, { sourceType: 'module', plugins: parserPlugins }).program.body; ast.forEach(node => { if (node.type === 'ExportDefaultDeclaration') { if (node.declaration.type === 'ClassDeclaration') { s.overwrite(node.start, node.declaration.id.start, `class `); s.append(`\nconst ${as} = ${node.declaration.id.name}`); } else { s.overwrite(node.start, node.declaration.start, `const ${as} = `); } } if (node.type === 'ExportNamedDeclaration') { for (const specifier of node.specifiers) { if (specifier.type === 'ExportSpecifier' && specifier.exported.type === 'Identifier' && specifier.exported.name === 'default') { if (node.source) { if (specifier.local.name === 'default') { const end = specifierEnd(input, specifier.local.end, node.end); s.prepend(`import { default as __VUE_DEFAULT__ } from '${node.source.value}'\n`); s.overwrite(specifier.start, end, ``); s.append(`\nconst ${as} = __VUE_DEFAULT__`); continue; } else { const end = specifierEnd(input, specifier.exported.end, node.end); s.prepend(`import { ${input.slice(specifier.local.start, specifier.local.end)} } from '${node.source.value}'\n`); s.overwrite(specifier.start, end, ``); s.append(`\nconst ${as} = ${specifier.local.name}`); continue; } } const end = specifierEnd(input, specifier.end, node.end); s.overwrite(specifier.start, end, ``); s.append(`\nconst ${as} = ${specifier.local.name}`); } } } }); return s.toString(); } function hasDefaultExport(input) { return defaultExportRE.test(input) \|\| namedDefaultExportRE.test(input); } function specifierEnd(input, end, nodeEnd) { // export { default , foo } ... let hasCommas = false; let oldEnd = end; while (end < nodeEnd) { if (/\s/.test(input.charAt(end))) { end++; } else if (input.charAt(end) === ',') { end++; hasCommas = true; break; } else if (input.charAt(end) === '}') { break; } } return hasCommas ? end : oldEnd; } // Special compiler macros const DEFINE_PROPS = 'defineProps'; const DEFINE_EMITS = 'defineEmits'; const DEFINE_EXPOSE = 'defineExpose'; const WITH_DEFAULTS = 'withDefaults'; // constants const DEFAULT_VAR = `__default__`; const isBuiltInDir$1 = makeMap(`once,memo,if,for,else,else-if,slot,text,html,on,bind,model,show,cloak,is`); /* * Compile `<script setup>` * It requires the whole SFC descriptor because we need to handle and merge * normal `<script>` + `<script setup>` if both are present. / function compileScript(sfc, options = { id: '' }) { let { filename, script, scriptSetup, source } = sfc; const isProd = !!options.isProd; const genSourceMap = options.sourceMap !== false; const cssVars = sfc.cssVars; const scopeId = options.id ? options.id.replace(/^data-v-/, '') : ''; const scriptLang = script && script.lang; const scriptSetupLang = scriptSetup && scriptSetup.lang; const isTS = scriptLang === 'ts' \|\| scriptLang === 'tsx' \|\| scriptSetupLang === 'ts' \|\| scriptSetupLang === 'tsx'; // resolve parser plugins const plugins = []; if (!isTS \|\| scriptLang === 'tsx' \|\| scriptSetupLang === 'tsx') { plugins.push('jsx'); } else { // If don't match the case of adding jsx, should remove the jsx from the babelParserPlugins if (options.babelParserPlugins) options.babelParserPlugins = options.babelParserPlugins.filter(n => n !== 'jsx'); } if (options.babelParserPlugins) plugins.push(...options.babelParserPlugins); if (isTS) { plugins.push('typescript'); if (!plugins.includes('decorators')) { plugins.push('decorators-legacy'); } } if (!scriptSetup) { if (!script) { throw new Error(`[@vue/compiler-sfc] SFC contains no <script> tags.`); } if (scriptLang && !isTS && scriptLang !== 'jsx') { // do not process non js/ts script blocks return script; } try { let content = script.content; let map = script.map; const scriptAst = parser$1.parse(content, { plugins, sourceType: 'module' }).program; const bindings = analyzeScriptBindings(scriptAst.body); if (cssVars.length) { content = rewriteDefault(content, DEFAULT_VAR, plugins); content += genNormalScriptCssVarsCode(cssVars, bindings, scopeId, isProd); content += `\nexport default ${DEFAULT_VAR}`; } return Object.assign(Object.assign({}, script), { content, map, bindings, scriptAst: scriptAst.body }); } catch (e) { // silently fallback if parse fails since user may be using custom // babel syntax return script; } } if (script && scriptLang !== scriptSetupLang) { throw new Error(`[@vue/compiler-sfc] <script> and <script setup> must have the same ` + `language type.`); } if (scriptSetupLang && !isTS && scriptSetupLang !== 'jsx') { // do not process non js/ts script blocks return scriptSetup; } // metadata that needs to be returned const bindingMetadata = {}; const helperImports = new Set(); const userImports = Object.create(null); const userImportAlias = Object.create(null); const scriptBindings = Object.create(null); const setupBindings = Object.create(null); let defaultExport; let hasDefinePropsCall = false; let hasDefineEmitCall = false; let hasDefineExposeCall = false; let hasDefaultExportName = false; let propsRuntimeDecl; let propsRuntimeDefaults; let propsDestructureDecl; let propsTypeDecl; let propsTypeDeclRaw; let propsIdentifier; let emitsRuntimeDecl; let emitsTypeDecl; let emitsTypeDeclRaw; let emitIdentifier; // props/emits declared via types const typeDeclaredProps = {}; const typeDeclaredEmits = new Set(); // record declared types for runtime props type generation const declaredTypes = {}; // props destructure data const propsDestructuredBindings = Object.create(null); // magic-string state const s = new MagicString(source); const startOffset = scriptSetup.start; const endOffset = scriptSetup.end; const scriptStartOffset = script && script.start; const scriptEndOffset = script && script.end; function helper(key) { helperImports.add(key); return `_${key}`; } function parse(input, options, offset) { try { return parser$1.parse(input, options).program; } catch (e) { e.message = `[@vue/compiler-sfc] ${e.message}\n\n${filename}\n${generateCodeFrame(source, e.pos + offset, e.pos + offset + 1)}`; throw e; } } function error(msg, node, end = node.end + startOffset) { throw new Error(`[@vue/compiler-sfc] ${msg}\n\n${filename}\n${generateCodeFrame(source, node.start + startOffset, end)}`); } function registerUserImport(source, local, imported, isType, isFromSetup) { if (source === 'vue' && imported) { userImportAlias[imported] = local; } let isUsedInTemplate = true; if (sfc.template && !sfc.template.src && !sfc.template.lang) { isUsedInTemplate = isImportUsed(local, sfc, isTS); } userImports[local] = { isType, imported: imported \|\| 'default', source, isFromSetup, isUsedInTemplate }; } function processDefineProps(node, declId) { if (!isCallOf(node, DEFINE_PROPS)) { return false; } if (hasDefinePropsCall) { error(`duplicate ${DEFINE_PROPS}() call`, node); } hasDefinePropsCall = true; propsRuntimeDecl = node.arguments[0]; // call has type parameters - infer runtime types from it if (node.typeParameters) { if (propsRuntimeDecl) { error(`${DEFINE_PROPS}() cannot accept both type and non-type arguments ` + `at the same time. Use one or the other.`, node); } propsTypeDeclRaw = node.typeParameters.params[0]; propsTypeDecl = resolveQualifiedType(propsTypeDeclRaw, node => node.type === 'TSTypeLiteral'); if (!propsTypeDecl) { error(`type argument passed to ${DEFINE_PROPS}() must be a literal type, ` + `or a reference to an interface or literal type.`, propsTypeDeclRaw); } } if (declId) { propsIdentifier = scriptSetup.content.slice(declId.start, declId.end); } return true; } function processWithDefaults(node, declId) { if (!isCallOf(node, WITH_DEFAULTS)) { return false; } if (processDefineProps(node.arguments[0], declId)) { if (propsRuntimeDecl) { error(`${WITH_DEFAULTS} can only be used with type-based ` + `${DEFINE_PROPS} declaration.`, node); } propsRuntimeDefaults = node.arguments[1]; if (!propsRuntimeDefaults \|\| propsRuntimeDefaults.type !== 'ObjectExpression') { error(`The 2nd argument of ${WITH_DEFAULTS} must be an object literal.`, propsRuntimeDefaults \|\| node); } } else { error(`${WITH_DEFAULTS}' first argument must be a ${DEFINE_PROPS} call.`, node.arguments[0] \|\| node); } return true; } function processDefineEmits(node, declId) { if (!isCallOf(node, DEFINE_EMITS)) { return false; } if (hasDefineEmitCall) { error(`duplicate ${DEFINE_EMITS}() call`, node); } hasDefineEmitCall = true; emitsRuntimeDecl = node.arguments[0]; if (node.typeParameters) { if (emitsRuntimeDecl) { error(`${DEFINE_EMITS}() cannot accept both type and non-type arguments ` + `at the same time. Use one or the other.`, node); } emitsTypeDeclRaw = node.typeParameters.params[0]; emitsTypeDecl = resolveQualifiedType(emitsTypeDeclRaw, node => node.type === 'TSFunctionType' \|\| node.type === 'TSTypeLiteral'); if (!emitsTypeDecl) { error(`type argument passed to ${DEFINE_EMITS}() must be a function type, ` + `a literal type with call signatures, or a reference to the above types.`, emitsTypeDeclRaw); } } if (declId) { emitIdentifier = scriptSetup.content.slice(declId.start, declId.end); } return true; } function resolveQualifiedType(node, qualifier) { if (qualifier(node)) { return node; } if (node.type === 'TSTypeReference' && node.typeName.type === 'Identifier') { const refName = node.typeName.name; const isQualifiedType = (node) => { if (node.type === 'TSInterfaceDeclaration' && node.id.name === refName) { return node.body; } else if (node.type === 'TSTypeAliasDeclaration' && node.id.name === refName && qualifier(node.typeAnnotation)) { return node.typeAnnotation; } else if (node.type === 'ExportNamedDeclaration' && node.declaration) { return isQualifiedType(node.declaration); } }; const body = scriptAst ? [...scriptSetupAst.body, ...scriptAst.body] : scriptSetupAst.body; for (const node of body) { const qualified = isQualifiedType(node); if (qualified) { return qualified; } } } } function processDefineExpose(node) { if (isCallOf(node, DEFINE_EXPOSE)) { if (hasDefineExposeCall) { error(`duplicate ${DEFINE_EXPOSE}() call`, node); } hasDefineExposeCall = true; return true; } return false; } function checkInvalidScopeReference(node, method) { if (!node) return; walkIdentifiers(node, id => { if (setupBindings[id.name]) { error(`\`${method}()\` in <script setup> cannot reference locally ` + `declared variables because it will be hoisted outside of the ` + `setup() function. If your component options require initialization ` + `in the module scope, use a separate normal <script> to export ` + `the options instead.`, id); } }); } /* * check defaults. If the default object is an object literal with only * static properties, we can directly generate more optimized default * declarations. Otherwise we will have to fallback to runtime merging. / function hasStaticWithDefaults() { return (propsRuntimeDefaults && propsRuntimeDefaults.type === 'ObjectExpression' && propsRuntimeDefaults.properties.every(node => (node.type === 'ObjectProperty' && !node.computed) \|\| node.type === 'ObjectMethod')); } function genRuntimeProps(props) { const keys = Object.keys(props); if (!keys.length) { return ``; } const hasStaticDefaults = hasStaticWithDefaults(); const scriptSetupSource = scriptSetup.content; let propsDecls = `{ ${keys .map(key => { let defaultString; const destructured = genDestructuredDefaultValue(key); if (destructured) { defaultString = `default: ${destructured}`; } else if (hasStaticDefaults) { const prop = propsRuntimeDefaults.properties.find((node) => node.key.name === key); if (prop) { if (prop.type === 'ObjectProperty') { // prop has corresponding static default value defaultString = `default: ${scriptSetupSource.slice(prop.value.start, prop.value.end)}`; } else { defaultString = `default() ${scriptSetupSource.slice(prop.body.start, prop.body.end)}`; } } } const { type, required } = props[key]; if (!isProd) { return `${key}: { type: ${toRuntimeTypeString(type)}, required: ${required}${defaultString ? `, ${defaultString}` : ``} }`; } else if (type.some(el => el === 'Boolean' \|\| (defaultString && el === 'Function'))) { // #4783 production: if boolean or defaultString and function exists, should keep the type. return `${key}: { type: ${toRuntimeTypeString(type)}${defaultString ? `, ${defaultString}` : ``} }`; } else { // production: checks are useless return `${key}: ${defaultString ? `{ ${defaultString} }` : 'null'}`; } }) .join(',\n ')}\n }`; if (propsRuntimeDefaults && !hasStaticDefaults) { propsDecls = `${helper('mergeDefaults')}(${propsDecls}, ${source.slice(propsRuntimeDefaults.start + startOffset, propsRuntimeDefaults.end + startOffset)})`; } return `\n props: ${propsDecls},`; } function genDestructuredDefaultValue(key) { const destructured = propsDestructuredBindings[key]; if (destructured && destructured.default) { const value = scriptSetup.content.slice(destructured.default.start, destructured.default.end); const isLiteral = destructured.default.type.endsWith('Literal'); return isLiteral ? value : `() => (${value})`; } } function genSetupPropsType(node) { const scriptSetupSource = scriptSetup.content; if (hasStaticWithDefaults()) { // if withDefaults() is used, we need to remove the optional flags // on props that have default values let res = `{ `; const members = node.type === 'TSTypeLiteral' ? node.members : node.body; for (const m of members) { if ((m.type === 'TSPropertySignature' \|\| m.type === 'TSMethodSignature') && m.typeAnnotation && m.key.type === 'Identifier') { if (propsRuntimeDefaults.properties.some((p) => p.key.name === m.key.name)) { res += m.key.name + (m.type === 'TSMethodSignature' ? '()' : '') + scriptSetupSource.slice(m.typeAnnotation.start, m.typeAnnotation.end) + ', '; } else { res += scriptSetupSource.slice(m.start, m.typeAnnotation.end) + `, `; } } } return (res.length ? res.slice(0, -2) : res) + ` }`; } else { return scriptSetupSource.slice(node.start, node.end); } } // 1. process normal <script> first if it exists let scriptAst; if (script) { scriptAst = parse(script.content, { plugins, sourceType: 'module' }, scriptStartOffset); for (const node of scriptAst.body) { if (node.type === 'ImportDeclaration') { // record imports for dedupe for (const specifier of node.specifiers) { const imported = specifier.type === 'ImportSpecifier' && specifier.imported.type === 'Identifier' && specifier.imported.name; registerUserImport(node.source.value, specifier.local.name, imported, node.importKind === 'type' \|\| (specifier.type === 'ImportSpecifier' && specifier.importKind === 'type'), false); } } else if (node.type === 'ExportDefaultDeclaration') { // export default defaultExport = node; // check if user has manually specified `name` or 'render` option in // export default // if has name, skip name inference // if has render and no template, generate return object instead of // empty render function (#4980) let optionProperties; if (defaultExport.declaration.type === 'ObjectExpression') { optionProperties = defaultExport.declaration.properties; } else if (defaultExport.declaration.type === 'CallExpression' && defaultExport.declaration.arguments[0].type === 'ObjectExpression') { optionProperties = defaultExport.declaration.arguments[0].properties; } if (optionProperties) { for (const s of optionProperties) { if (s.type === 'ObjectProperty' && s.key.type === 'Identifier' && s.key.name === 'name') { hasDefaultExportName = true; } } } // export default { ... } --> const __default__ = { ... } const start = node.start + scriptStartOffset; const end = node.declaration.start + scriptStartOffset; s.overwrite(start, end, `const ${DEFAULT_VAR} = `); } else if (node.type === 'ExportNamedDeclaration') { const defaultSpecifier = node.specifiers.find(s => s.exported.type === 'Identifier' && s.exported.name === 'default'); if (defaultSpecifier) { defaultExport = node; // 1. remove specifier if (node.specifiers.length > 1) { s.remove(defaultSpecifier.start + scriptStartOffset, defaultSpecifier.end + scriptStartOffset); } else { s.remove(node.start + scriptStartOffset, node.end + scriptStartOffset); } if (node.source) { // export { x as default } from './x' // rewrite to `import { x as __default__ } from './x'` and // add to top s.prepend(`import { ${defaultSpecifier.local.name} as ${DEFAULT_VAR} } from '${node.source.value}'\n`); } else { // export { x as default } // rewrite to `const __default__ = x` and move to end s.appendLeft(scriptEndOffset, `\nconst ${DEFAULT_VAR} = ${defaultSpecifier.local.name}\n`); } } if (node.declaration) { walkDeclaration(node.declaration, scriptBindings, userImportAlias); } } else if ((node.type === 'VariableDeclaration' \|\| node.type === 'FunctionDeclaration' \|\| node.type === 'ClassDeclaration' \|\| node.type === 'TSEnumDeclaration') && !node.declare) { walkDeclaration(node, scriptBindings, userImportAlias); } } // apply reactivity transform // if (enableReactivityTransform && shouldTransform(script.content)) { // const { rootRefs, importedHelpers } = transformAST( // scriptAst, // s, // scriptStartOffset! // ) // refBindings = rootRefs // for (const h of importedHelpers) { // helperImports.add(h) // } // } // <script> after <script setup> // we need to move the block up so that `const __default__` is // declared before being used in the actual component definition if (scriptStartOffset > startOffset) { // if content doesn't end with newline, add one if (!/\n$/.test(script.content.trim())) { s.appendLeft(scriptEndOffset, `\n`); } s.move(scriptStartOffset, scriptEndOffset, 0); } } // 2. parse <script setup> and walk over top level statements const scriptSetupAst = parse(scriptSetup.content, { plugins: [ ...plugins, // allow top level await but only inside <script setup> 'topLevelAwait' ], sourceType: 'module' }, startOffset); for (const node of scriptSetupAst.body) { const start = node.start + startOffset; let end = node.end + startOffset; // locate comment if (node.trailingComments && node.trailingComments.length > 0) { const lastCommentNode = node.trailingComments[node.trailingComments.length - 1]; end = lastCommentNode.end + startOffset; } // locate the end of whitespace between this statement and the next while (end <= source.length) { if (!/\s/.test(source.charAt(end))) { break; } end++; } // (Dropped) `ref: x` bindings if (node.type === 'LabeledStatement' && node.label.name === 'ref' && node.body.type === 'ExpressionStatement') { error(`ref sugar using the label syntax was an experimental proposal and ` + `has been dropped based on community feedback. Please check out ` + `the new proposal at https://github.com/vuejs/rfcs/discussions/369`, node); } if (node.type === 'ImportDeclaration') { // import declarations are moved to top s.move(start, end, 0); // dedupe imports let removed = 0; const removeSpecifier = (i) => { const removeLeft = i > removed; removed++; const current = node.specifiers[i]; const next = node.specifiers[i + 1]; s.remove(removeLeft ? node.specifiers[i - 1].end + startOffset : current.start + startOffset, next && !removeLeft ? next.start + startOffset : current.end + startOffset); }; for (let i = 0; i < node.specifiers.length; i++) { const specifier = node.specifiers[i]; const local = specifier.local.name; let imported = specifier.type === 'ImportSpecifier' && specifier.imported.type === 'Identifier' && specifier.imported.name; if (specifier.type === 'ImportNamespaceSpecifier') { imported = ''; } const source = node.source.value; const existing = userImports[local]; if (source === 'vue' && (imported === DEFINE_PROPS \|\| imported === DEFINE_EMITS \|\| imported === DEFINE_EXPOSE)) { warnOnce(`\`${imported}\` is a compiler macro and no longer needs to be imported.`); removeSpecifier(i); } else if (existing) { if (existing.source === source && existing.imported === imported) { // already imported in <script setup>, dedupe removeSpecifier(i); } else { error(`different imports aliased to same local name.`, specifier); } } else { registerUserImport(source, local, imported, node.importKind === 'type' \|\| (specifier.type === 'ImportSpecifier' && specifier.importKind === 'type'), true); } } if (node.specifiers.length && removed === node.specifiers.length) { s.remove(node.start + startOffset, node.end + startOffset); } } if (node.type === 'ExpressionStatement') { // process `defineProps` and `defineEmit(s)` calls if (processDefineProps(node.expression) \|\| processDefineEmits(node.expression) \|\| processWithDefaults(node.expression)) { s.remove(node.start + startOffset, node.end + startOffset); } else if (processDefineExpose(node.expression)) { // defineExpose({}) -> expose({}) const callee = node.expression.callee; s.overwrite(callee.start + startOffset, callee.end + startOffset, 'expose'); } } if (node.type === 'VariableDeclaration' && !node.declare) { const total = node.declarations.length; let left = total; for (let i = 0; i < total; i++) { const decl = node.declarations[i]; if (decl.init) { // defineProps / defineEmits const isDefineProps = processDefineProps(decl.init, decl.id) \|\| processWithDefaults(decl.init, decl.id); const isDefineEmits = processDefineEmits(decl.init, decl.id); if (isDefineProps \|\| isDefineEmits) { if (left === 1) { s.remove(node.start + startOffset, node.end + startOffset); } else { let start = decl.start + startOffset; let end = decl.end + startOffset; if (i < total - 1) { // not the last one, locate the start of the next end = node.declarations[i + 1].start + startOffset; } else { // last one, locate the end of the prev start = node.declarations[i - 1].end + startOffset; } s.remove(start, end); left--; } } } } } // walk declarations to record declared bindings if ((node.type === 'VariableDeclaration' \|\| node.type === 'FunctionDeclaration' \|\| node.type === 'ClassDeclaration') && !node.declare) { walkDeclaration(node, setupBindings, userImportAlias); } // walk statements & named exports / variable declarations for top level // await if ((node.type === 'VariableDeclaration' && !node.declare) \|\| node.type.endsWith('Statement')) { const scope = [scriptSetupAst.body]; walk$1(node, { enter(child, parent) { if (isFunctionType(child)) { this.skip(); } if (child.type === 'BlockStatement') { scope.push(child.body); } if (child.type === 'AwaitExpression') { error(`Vue 2 does not support top level await in <script setup>.`, child); } }, exit(node) { if (node.type === 'BlockStatement') scope.pop(); } }); } if ((node.type === 'ExportNamedDeclaration' && node.exportKind !== 'type') \|\| node.type === 'ExportAllDeclaration' \|\| node.type === 'ExportDefaultDeclaration') { error(`<script setup> cannot contain ES module exports. ` + `If you are using a previous version of <script setup>, please ` + `consult the updated RFC at https://github.com/vuejs/rfcs/pull/227.`, node); } if (isTS) { // runtime enum if (node.type === 'TSEnumDeclaration') { registerBinding(setupBindings, node.id, "setup-const" /* BindingTypes.SETUP_CONST /); } // move all Type declarations to outer scope if (node.type.startsWith('TS') \|\| (node.type === 'ExportNamedDeclaration' && node.exportKind === 'type') \|\| (node.type === 'VariableDeclaration' && node.declare)) { recordType(node, declaredTypes); s.move(start, end, 0); } } } // 3. Apply reactivity transform // if ( // (enableReactivityTransform && // // normal <script> had ref bindings that maybe used in <script setup> // (refBindings \|\| shouldTransform(scriptSetup.content))) \|\| // propsDestructureDecl // ) { // const { rootRefs, importedHelpers } = transformAST( // scriptSetupAst, // s, // startOffset, // refBindings, // propsDestructuredBindings // ) // refBindings = refBindings ? [...refBindings, ...rootRefs] : rootRefs // for (const h of importedHelpers) { // helperImports.add(h) // } // } // 4. extract runtime props/emits code from setup context type if (propsTypeDecl) { extractRuntimeProps(propsTypeDecl, typeDeclaredProps, declaredTypes); } if (emitsTypeDecl) { extractRuntimeEmits(emitsTypeDecl, typeDeclaredEmits); } // 5. check useOptions args to make sure it doesn't reference setup scope // variables checkInvalidScopeReference(propsRuntimeDecl, DEFINE_PROPS); checkInvalidScopeReference(propsRuntimeDefaults, DEFINE_PROPS); checkInvalidScopeReference(propsDestructureDecl, DEFINE_PROPS); checkInvalidScopeReference(emitsRuntimeDecl, DEFINE_EMITS); // 6. remove non-script content if (script) { if (startOffset < scriptStartOffset) { // <script setup> before <script> s.remove(0, startOffset); s.remove(endOffset, scriptStartOffset); s.remove(scriptEndOffset, source.length); } else { // <script> before <script setup> s.remove(0, scriptStartOffset); s.remove(scriptEndOffset, startOffset); s.remove(endOffset, source.length); } } else { // only <script setup> s.remove(0, startOffset); s.remove(endOffset, source.length); } // 7. analyze binding metadata if (scriptAst) { Object.assign(bindingMetadata, analyzeScriptBindings(scriptAst.body)); } if (propsRuntimeDecl) { for (const key of getObjectOrArrayExpressionKeys(propsRuntimeDecl)) { bindingMetadata[key] = "props" / BindingTypes.PROPS /; } } for (const key in typeDeclaredProps) { bindingMetadata[key] = "props" / BindingTypes.PROPS /; } // props aliases // if (propsDestructureDecl) { // if (propsDestructureRestId) { // bindingMetadata[propsDestructureRestId] = // BindingTypes.SETUP_REACTIVE_CONST // } // for (const key in propsDestructuredBindings) { // const { local } = propsDestructuredBindings[key] // if (local !== key) { // bindingMetadata[local] = BindingTypes.PROPS_ALIASED // ;(bindingMetadata.__propsAliases \|\| // (bindingMetadata.__propsAliases = {}))[local] = key // } // } // } for (const [key, { isType, imported, source }] of Object.entries(userImports)) { if (isType) continue; bindingMetadata[key] = imported === '' \|\| (imported === 'default' && source.endsWith('.vue')) \|\| source === 'vue' ? "setup-const" /* BindingTypes.SETUP_CONST / : "setup-maybe-ref" / BindingTypes.SETUP_MAYBE_REF /; } for (const key in scriptBindings) { bindingMetadata[key] = scriptBindings[key]; } for (const key in setupBindings) { bindingMetadata[key] = setupBindings[key]; } // 8. inject `useCssVars` calls if (cssVars.length) { helperImports.add(CSS_VARS_HELPER); s.prependRight(startOffset, `\n${genCssVarsCode(cssVars, bindingMetadata, scopeId, isProd)}\n`); } // 9. finalize setup() argument signature let args = `__props`; if (propsTypeDecl) { // mark as any and only cast on assignment // since the user defined complex types may be incompatible with the // inferred type from generated runtime declarations args += `: any`; } // inject user assignment of props // we use a default __props so that template expressions referencing props // can use it directly if (propsIdentifier) { s.prependLeft(startOffset, `\nconst ${propsIdentifier} = __props${propsTypeDecl ? ` as ${genSetupPropsType(propsTypeDecl)}` : ``}\n`); } const destructureElements = hasDefineExposeCall ? [`expose`] : []; if (emitIdentifier) { destructureElements.push(emitIdentifier === `emit` ? `emit` : `emit: ${emitIdentifier}`); } if (destructureElements.length) { args += `, { ${destructureElements.join(', ')} }`; if (emitsTypeDecl) { args += `: { emit: (${scriptSetup.content.slice(emitsTypeDecl.start, emitsTypeDecl.end)}), expose: any, slots: any, attrs: any }`; } } // 10. generate return statement const allBindings = Object.assign(Object.assign({}, scriptBindings), setupBindings); for (const key in userImports) { if (!userImports[key].isType && userImports[key].isUsedInTemplate) { allBindings[key] = true; } } // __sfc marker indicates these bindings are compiled from <script setup> // and should not be proxied on `this` const returned = `{ ${`__sfc: true,`}${Object.keys(allBindings).join(', ')} }`; s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`); // 11. finalize default export let runtimeOptions = ``; if (!hasDefaultExportName && filename && filename !== DEFAULT_FILENAME) { const match = filename.match(/([^/\\]+)\.\w+$/); if (match) { runtimeOptions += `\n __name: '${match[1]}',`; } } if (propsRuntimeDecl) { let declCode = scriptSetup.content .slice(propsRuntimeDecl.start, propsRuntimeDecl.end) .trim(); runtimeOptions += `\n props: ${declCode},`; } else if (propsTypeDecl) { runtimeOptions += genRuntimeProps(typeDeclaredProps); } if (emitsRuntimeDecl) { runtimeOptions += `\n emits: ${scriptSetup.content .slice(emitsRuntimeDecl.start, emitsRuntimeDecl.end) .trim()},`; } else if (emitsTypeDecl) { runtimeOptions += genRuntimeEmits(typeDeclaredEmits); } // wrap setup code with function. if (isTS) { // for TS, make sure the exported type is still valid type with // correct props information // we have to use object spread for types to be merged properly // user's TS setting should compile it down to proper targets // export default defineComponent({ ...__default__, ... }) const def = defaultExport ? `\n ...${DEFAULT_VAR},` : ``; s.prependLeft(startOffset, `\nexport default /#__PURE__/${helper(`defineComponent`)}({${def}${runtimeOptions}\n setup(${args}) {\n`); s.appendRight(endOffset, `})`); } else { if (defaultExport) { // without TS, can't rely on rest spread, so we use Object.assign // export default Object.assign(__default__, { ... }) s.prependLeft(startOffset, `\nexport default /#__PURE__/Object.assign(${DEFAULT_VAR}, {${runtimeOptions}\n ` + `setup(${args}) {\n`); s.appendRight(endOffset, `})`); } else { s.prependLeft(startOffset, `\nexport default {${runtimeOptions}\n setup(${args}) {\n`); s.appendRight(endOffset, `}`); } } // 12. finalize Vue helper imports if (helperImports.size > 0) { s.prepend(`import { ${[...helperImports] .map(h => `${h} as _${h}`) .join(', ')} } from 'vue'\n`); } s.trim(); return Object.assign(Object.assign({}, scriptSetup), { bindings: bindingMetadata, imports: userImports, content: s.toString(), map: genSourceMap ? s.generateMap({ source: filename, hires: true, includeContent: true }) : undefined, scriptAst: scriptAst === null \|\| scriptAst === void 0 ? void 0 : scriptAst.body, scriptSetupAst: scriptSetupAst === null \|\| scriptSetupAst === void 0 ? void 0 : scriptSetupAst.body }); } function registerBinding(bindings, node, type) { bindings[node.name] = type; } function walkDeclaration(node, bindings, userImportAlias) { if (node.type === 'VariableDeclaration') { const isConst = node.kind === 'const'; // export const foo = ... for (const { id, init } of node.declarations) { const isDefineCall = !!(isConst && isCallOf(init, c => c === DEFINE_PROPS \|\| c === DEFINE_EMITS \|\| c === WITH_DEFAULTS)); if (id.type === 'Identifier') { let bindingType; const userReactiveBinding = userImportAlias['reactive'] \|\| 'reactive'; if (isCallOf(init, userReactiveBinding)) { // treat reactive() calls as let since it's meant to be mutable bindingType = isConst ? "setup-reactive-const" / BindingTypes.SETUP_REACTIVE_CONST / : "setup-let" / BindingTypes.SETUP_LET /; } else if ( // if a declaration is a const literal, we can mark it so that // the generated render fn code doesn't need to unref() it isDefineCall \|\| (isConst && canNeverBeRef(init, userReactiveBinding))) { bindingType = isCallOf(init, DEFINE_PROPS) ? "setup-reactive-const" / BindingTypes.SETUP_REACTIVE_CONST / : "setup-const" / BindingTypes.SETUP_CONST /; } else if (isConst) { if (isCallOf(init, userImportAlias['ref'] \|\| 'ref')) { bindingType = "setup-ref" / BindingTypes.SETUP_REF /; } else { bindingType = "setup-maybe-ref" / BindingTypes.SETUP_MAYBE_REF /; } } else { bindingType = "setup-let" / BindingTypes.SETUP_LET /; } registerBinding(bindings, id, bindingType); } else { if (isCallOf(init, DEFINE_PROPS)) { // skip walking props destructure return; } if (id.type === 'ObjectPattern') { walkObjectPattern(id, bindings, isConst, isDefineCall); } else if (id.type === 'ArrayPattern') { walkArrayPattern(id, bindings, isConst, isDefineCall); } } } } else if (node.type === 'TSEnumDeclaration' \|\| node.type === 'FunctionDeclaration' \|\| node.type === 'ClassDeclaration') { // export function foo() {} / export class Foo {} // export declarations must be named. bindings[node.id.name] = "setup-const" / BindingTypes.SETUP_CONST /; } } function walkObjectPattern(node, bindings, isConst, isDefineCall = false) { for (const p of node.properties) { if (p.type === 'ObjectProperty') { if (p.key.type === 'Identifier' && p.key === p.value) { // shorthand: const { x } = ... const type = isDefineCall ? "setup-const" / BindingTypes.SETUP_CONST / : isConst ? "setup-maybe-ref" / BindingTypes.SETUP_MAYBE_REF / : "setup-let" / BindingTypes.SETUP_LET /; registerBinding(bindings, p.key, type); } else { walkPattern(p.value, bindings, isConst, isDefineCall); } } else { // ...rest // argument can only be identifier when destructuring const type = isConst ? "setup-const" / BindingTypes.SETUP_CONST / : "setup-let" / BindingTypes.SETUP_LET /; registerBinding(bindings, p.argument, type); } } } function walkArrayPattern(node, bindings, isConst, isDefineCall = false) { for (const e of node.elements) { e && walkPattern(e, bindings, isConst, isDefineCall); } } function walkPattern(node, bindings, isConst, isDefineCall = false) { if (node.type === 'Identifier') { const type = isDefineCall ? "setup-const" / BindingTypes.SETUP_CONST / : isConst ? "setup-maybe-ref" / BindingTypes.SETUP_MAYBE_REF / : "setup-let" / BindingTypes.SETUP_LET /; registerBinding(bindings, node, type); } else if (node.type === 'RestElement') { // argument can only be identifier when destructuring const type = isConst ? "setup-const" / BindingTypes.SETUP_CONST / : "setup-let" / BindingTypes.SETUP_LET /; registerBinding(bindings, node.argument, type); } else if (node.type === 'ObjectPattern') { walkObjectPattern(node, bindings, isConst); } else if (node.type === 'ArrayPattern') { walkArrayPattern(node, bindings, isConst); } else if (node.type === 'AssignmentPattern') { if (node.left.type === 'Identifier') { const type = isDefineCall ? "setup-const" / BindingTypes.SETUP_CONST / : isConst ? "setup-maybe-ref" / BindingTypes.SETUP_MAYBE_REF / : "setup-let" / BindingTypes.SETUP_LET /; registerBinding(bindings, node.left, type); } else { walkPattern(node.left, bindings, isConst); } } } function recordType(node, declaredTypes) { if (node.type === 'TSInterfaceDeclaration') { declaredTypes[node.id.name] = [`Object`]; } else if (node.type === 'TSTypeAliasDeclaration') { declaredTypes[node.id.name] = inferRuntimeType(node.typeAnnotation, declaredTypes); } else if (node.type === 'ExportNamedDeclaration' && node.declaration) { recordType(node.declaration, declaredTypes); } } function extractRuntimeProps(node, props, declaredTypes, isProd) { const members = node.type === 'TSTypeLiteral' ? node.members : node.body; for (const m of members) { if ((m.type === 'TSPropertySignature' \|\| m.type === 'TSMethodSignature') && m.key.type === 'Identifier') { let type; if (m.type === 'TSMethodSignature') { type = ['Function']; } else if (m.typeAnnotation) { type = inferRuntimeType(m.typeAnnotation.typeAnnotation, declaredTypes); } props[m.key.name] = { key: m.key.name, required: !m.optional, type: type \|\| [`null`] }; } } } function inferRuntimeType(node, declaredTypes) { switch (node.type) { case 'TSStringKeyword': return ['String']; case 'TSNumberKeyword': return ['Number']; case 'TSBooleanKeyword': return ['Boolean']; case 'TSObjectKeyword': return ['Object']; case 'TSTypeLiteral': // TODO (nice to have) generate runtime property validation return ['Object']; case 'TSFunctionType': return ['Function']; case 'TSArrayType': case 'TSTupleType': // TODO (nice to have) generate runtime element type/length checks return ['Array']; case 'TSLiteralType': switch (node.literal.type) { case 'StringLiteral': return ['String']; case 'BooleanLiteral': return ['Boolean']; case 'NumericLiteral': case 'BigIntLiteral': return ['Number']; default: return [`null`]; } case 'TSTypeReference': if (node.typeName.type === 'Identifier') { if (declaredTypes[node.typeName.name]) { return declaredTypes[node.typeName.name]; } switch (node.typeName.name) { case 'Array': case 'Function': case 'Object': case 'Set': case 'Map': case 'WeakSet': case 'WeakMap': case 'Date': case 'Promise': return [node.typeName.name]; case 'Record': case 'Partial': case 'Readonly': case 'Pick': case 'Omit': case 'Exclude': case 'Extract': case 'Required': case 'InstanceType': return ['Object']; } } return [`null`]; case 'TSParenthesizedType': return inferRuntimeType(node.typeAnnotation, declaredTypes); case 'TSUnionType': return [ ...new Set([].concat(...node.types.map(t => inferRuntimeType(t, declaredTypes)))) ]; case 'TSIntersectionType': return ['Object']; case 'TSSymbolKeyword': return ['Symbol']; default: return [`null`]; // no runtime check } } function toRuntimeTypeString(types) { return types.length > 1 ? `[${types.join(', ')}]` : types[0]; } function extractRuntimeEmits(node, emits) { if (node.type === 'TSTypeLiteral' \|\| node.type === 'TSInterfaceBody') { const members = node.type === 'TSTypeLiteral' ? node.members : node.body; for (let t of members) { if (t.type === 'TSCallSignatureDeclaration') { extractEventNames(t.parameters[0], emits); } } return; } else { extractEventNames(node.parameters[0], emits); } } function extractEventNames(eventName, emits) { if (eventName.type === 'Identifier' && eventName.typeAnnotation && eventName.typeAnnotation.type === 'TSTypeAnnotation') { const typeNode = eventName.typeAnnotation.typeAnnotation; if (typeNode.type === 'TSLiteralType') { if (typeNode.literal.type !== 'UnaryExpression' && typeNode.literal.type !== 'TemplateLiteral') { emits.add(String(typeNode.literal.value)); } } else if (typeNode.type === 'TSUnionType') { for (const t of typeNode.types) { if (t.type === 'TSLiteralType' && t.literal.type !== 'UnaryExpression' && t.literal.type !== 'TemplateLiteral') { emits.add(String(t.literal.value)); } } } } } function genRuntimeEmits(emits) { return emits.size ? `\n emits: [${Array.from(emits) .map(p => JSON.stringify(p)) .join(', ')}],` : ``; } function isCallOf(node, test) { return !!(node && node.type === 'CallExpression' && node.callee.type === 'Identifier' && (typeof test === 'string' ? node.callee.name === test : test(node.callee.name))); } function canNeverBeRef(node, userReactiveImport) { if (isCallOf(node, userReactiveImport)) { return true; } switch (node.type) { case 'UnaryExpression': case 'BinaryExpression': case 'ArrayExpression': case 'ObjectExpression': case 'FunctionExpression': case 'ArrowFunctionExpression': case 'UpdateExpression': case 'ClassExpression': case 'TaggedTemplateExpression': return true; case 'SequenceExpression': return canNeverBeRef(node.expressions[node.expressions.length - 1], userReactiveImport); default: if (node.type.endsWith('Literal')) { return true; } return false; } } /* * Analyze bindings in normal `<script>` * Note that `compileScriptSetup` already analyzes bindings as part of its * compilation process so this should only be used on single `<script>` SFCs. / function analyzeScriptBindings(ast) { for (const node of ast) { if (node.type === 'ExportDefaultDeclaration' && node.declaration.type === 'ObjectExpression') { return analyzeBindingsFromOptions(node.declaration); } } return {}; } function analyzeBindingsFromOptions(node) { const bindings = {}; // #3270, #3275 // mark non-script-setup so we don't resolve components/directives from these Object.defineProperty(bindings, '__isScriptSetup', { enumerable: false, value: false }); for (const property of node.properties) { if (property.type === 'ObjectProperty' && !property.computed && property.key.type === 'Identifier') { // props if (property.key.name === 'props') { // props: ['foo'] // props: { foo: ... } for (const key of getObjectOrArrayExpressionKeys(property.value)) { bindings[key] = "props" / BindingTypes.PROPS /; } } // inject else if (property.key.name === 'inject') { // inject: ['foo'] // inject: { foo: {} } for (const key of getObjectOrArrayExpressionKeys(property.value)) { bindings[key] = "options" / BindingTypes.OPTIONS /; } } // computed & methods else if (property.value.type === 'ObjectExpression' && (property.key.name === 'computed' \|\| property.key.name === 'methods')) { // methods: { foo() {} } // computed: { foo() {} } for (const key of getObjectExpressionKeys(property.value)) { bindings[key] = "options" / BindingTypes.OPTIONS /; } } } // setup & data else if (property.type === 'ObjectMethod' && property.key.type === 'Identifier' && (property.key.name === 'setup' \|\| property.key.name === 'data')) { for (const bodyItem of property.body.body) { // setup() { // return { // foo: null // } // } if (bodyItem.type === 'ReturnStatement' && bodyItem.argument && bodyItem.argument.type === 'ObjectExpression') { for (const key of getObjectExpressionKeys(bodyItem.argument)) { bindings[key] = property.key.name === 'setup' ? "setup-maybe-ref" / BindingTypes.SETUP_MAYBE_REF / : "data" / BindingTypes.DATA /; } } } } } return bindings; } function getObjectExpressionKeys(node) { const keys = []; for (const prop of node.properties) { if ((prop.type === 'ObjectProperty' \|\| prop.type === 'ObjectMethod') && !prop.computed) { if (prop.key.type === 'Identifier') { keys.push(prop.key.name); } else if (prop.key.type === 'StringLiteral') { keys.push(prop.key.value); } } } return keys; } function getArrayExpressionKeys(node) { const keys = []; for (const element of node.elements) { if (element && element.type === 'StringLiteral') { keys.push(element.value); } } return keys; } function getObjectOrArrayExpressionKeys(value) { if (value.type === 'ArrayExpression') { return getArrayExpressionKeys(value); } if (value.type === 'ObjectExpression') { return getObjectExpressionKeys(value); } return []; } const templateUsageCheckCache = new lruCache(512); function resolveTemplateUsageCheckString(sfc, isTS) { const { content } = sfc.template; const cached = templateUsageCheckCache.get(content); if (cached) { return cached; } let code = ''; parseHTML(content, Object.assign(Object.assign({}, baseOptions), { start(tag, attrs) { if (!isBuiltInTag(tag) && !isReservedTag(tag)) { code += `,${camelize(tag)},${capitalize(camelize(tag))}`; } for (let i = 0; i < attrs.length; i++) { const { name, value } = attrs[i]; if (dirRE.test(name)) { const baseName = onRE.test(name) ? 'on' : slotRE.test(name) ? 'slot' : bindRE.test(name) ? 'bind' : name.replace(dirRE, ''); if (!isBuiltInDir$1(baseName)) { code += `,v${capitalize(camelize(baseName))}`; } if (value) { code += `,${processExp(value, isTS, baseName)}`; } } } }, chars(text) { const res = parseText(text); if (res) { code += `,${processExp(res.expression, isTS)}`; } } })); code += ';'; templateUsageCheckCache.set(content, code); return code; } const forAliasRE = /([\s\S]?)\s+(?:in\|of)\s+([\s\S])/; function processExp(exp, isTS, dir) { if (isTS && / as\s+\w\|<.>\|:/.test(exp)) { if (dir === 'slot') { exp = `(${exp})=>{}`; } else if (dir === 'on') { exp = `()=>{${exp}}`; } else if (dir === 'for') { const inMatch = exp.match(forAliasRE); if (inMatch) { const [, LHS, RHS] = inMatch; return processExp(`(${LHS})=>{}`, true) + processExp(RHS, true); } } let ret = ''; // has potential type cast or generic arguments that uses types const ast = parser$1.parseExpression(exp, { plugins: ['typescript'] }); walkIdentifiers(ast, node => { ret += `,` + node.name; }); return ret; } return stripStrings(exp); } function stripStrings(exp) { return exp .replace(/'[^']'\|"[^"]"/g, '') .replace(/`[^`]+`/g, stripTemplateString); } function stripTemplateString(str) { const interpMatch = str.match(/\${[^}]+}/g); if (interpMatch) { return interpMatch.map(m => m.slice(2, -1)).join(','); } return ''; } function isImportUsed(local, sfc, isTS) { return new RegExp( // #4274 escape $ since it's a special char in regex // (and is the only regex special char that is valid in identifiers) `[^\\w$_]${local.replace(/\$/g, '\\$')}[^\\w$_]`).test(resolveTemplateUsageCheckString(sfc, isTS)); } /** * Note: this comparison assumes the prev/next script are already identical, * and only checks the special case where <script setup> unused import * pruning result changes due to template changes. / function hmrShouldReload(prevImports, next) { if (!next.scriptSetup) { return false; } const isTS = next.scriptSetup.lang === 'ts' \|\| next.scriptSetup.lang === 'tsx'; // for each previous import, check if its used status remain the same based on // the next descriptor's template for (const key in prevImports) { // if an import was previous unused, but now is used, we need to force // reload so that the script now includes that import. if (!prevImports[key].isUsedInTemplate && isImportUsed(key, next, isTS)) { return true; } } return false; } const cache = new lruCache(100); const splitRE = /\r?\n/g; const emptyRE = /^(?:\/\/)?\s$/; function parse(options) { const { source, filename = DEFAULT_FILENAME, compiler, compilerParseOptions = { pad: false }, sourceRoot = '', needMap = true, sourceMap = needMap } = options; const cacheKey = hashSum(filename + source + JSON.stringify(compilerParseOptions)); let output = cache.get(cacheKey); if (output) { return output; } if (compiler) { // user-provided compiler output = compiler.parseComponent(source, compilerParseOptions); } else { // use built-in compiler output = parseComponent(source, compilerParseOptions); } output.filename = filename; // parse CSS vars output.cssVars = parseCssVars(output); output.shouldForceReload = prevImports => hmrShouldReload(prevImports, output); if (sourceMap) { if (output.script && !output.script.src) { output.script.map = generateSourceMap(filename, source, output.script.content, sourceRoot, compilerParseOptions.pad); } if (output.styles) { output.styles.forEach(style => { if (!style.src) { style.map = generateSourceMap(filename, source, style.content, sourceRoot, compilerParseOptions.pad); } }); } } cache.set(cacheKey, output); return output; } function generateSourceMap(filename, source, generated, sourceRoot, pad) { const map = new require$$0.SourceMapGenerator({ file: filename.replace(/\\/g, '/'), sourceRoot: sourceRoot.replace(/\\/g, '/') }); let offset = 0; if (!pad) { offset = source.split(generated).shift().split(splitRE).length - 1; } map.setSourceContent(filename, source); generated.split(splitRE).forEach((line, index) => { if (!emptyRE.test(line)) { map.addMapping({ source: filename, original: { line: index + 1 + offset, column: 0 }, generated: { line: index + 1, column: 0 } }); } }); return JSON.parse(map.toString()); } function urlToRequire(url, transformAssetUrlsOption = {}) { const returnValue = `"${url}"`; // same logic as in transform-require.js const firstChar = url.charAt(0); if (firstChar === '~') { const secondChar = url.charAt(1); url = url.slice(secondChar === '/' ? 2 : 1); } if (isExternalUrl(url) \|\| isDataUrl(url) \|\| firstChar === '#') { return returnValue; } const uriParts = parseUriParts(url); if (transformAssetUrlsOption.base) { // explicit base - directly rewrite the url into absolute url // does not apply to absolute urls or urls that start with `@` // since they are aliases if (firstChar === '.' \|\| firstChar === '~') { // Allow for full hostnames provided in options.base const base = parseUriParts(transformAssetUrlsOption.base); const protocol = base.protocol \|\| ''; const host = base.host ? protocol + '//' + base.host : ''; const basePath = base.path \|\| '/'; // when packaged in the browser, path will be using the posix- // only version provided by rollup-plugin-node-builtins. return `"${host}${(path__default["default"].posix \|\| path__default["default"]).join(basePath, uriParts.path + (uriParts.hash \|\| ''))}"`; } } if (transformAssetUrlsOption.includeAbsolute \|\| firstChar === '.' \|\| firstChar === '~' \|\| firstChar === '@') { if (!uriParts.hash) { return `require("${url}")`; } else { // support uri fragment case by excluding it from // the require and instead appending it as string; // assuming that the path part is sufficient according to // the above caseing(t.i. no protocol-auth-host parts expected) return `require("${uriParts.path}") + "${uriParts.hash}"`; } } return returnValue; } /** * vuejs/component-compiler-utils#22 Support uri fragment in transformed require * @param urlString an url as a string / function parseUriParts(urlString) { // initialize return value const returnValue = url.parse(''); if (urlString) { // A TypeError is thrown if urlString is not a string // @see https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost if ('string' === typeof urlString) { // check is an uri return url.parse(urlString, false, true); // take apart the uri } } return returnValue; } const externalRE = /^(https?:)?\/\//; function isExternalUrl(url) { return externalRE.test(url); } const dataUrlRE = /^\sdata:/i; function isDataUrl(url) { return dataUrlRE.test(url); } // vue compiler module for transforming `<tag>:<attribute>` to `require` const defaultOptions = { audio: 'src', video: ['src', 'poster'], source: 'src', img: 'src', image: ['xlink:href', 'href'], use: ['xlink:href', 'href'] }; var assetUrlsModule = (userOptions, transformAssetUrlsOption) => { const options = userOptions ? Object.assign({}, defaultOptions, userOptions) : defaultOptions; return { postTransformNode: (node) => { transform$1(node, options, transformAssetUrlsOption); } }; }; function transform$1(node, options, transformAssetUrlsOption) { if (node.type !== 1 \|\| !node.attrs) return; for (const tag in options) { if (tag === '' \|\| node.tag === tag) { const attributes = options[tag]; if (typeof attributes === 'string') { node.attrs.some(attr => rewrite(attr, attributes, transformAssetUrlsOption)); } else if (Array.isArray(attributes)) { attributes.forEach(item => node.attrs.some(attr => rewrite(attr, item, transformAssetUrlsOption))); } } } } function rewrite(attr, name, transformAssetUrlsOption) { if (attr.name === name) { const value = attr.value; // only transform static URLs if (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') { attr.value = urlToRequire(value.slice(1, -1), transformAssetUrlsOption); return true; } } return false; } // vue compiler module for transforming `img:srcset` to a number of `require`s var srcsetModule = (transformAssetUrlsOptions) => ({ postTransformNode: (node) => { transform(node, transformAssetUrlsOptions); } }); // http://w3c.github.io/html/semantics-embedded-content.html#ref-for-image-candidate-string-5 const escapedSpaceCharacters = /( \|\\t\|\\n\|\\f\|\\r)+/g; function transform(node, transformAssetUrlsOptions) { if (node.type !== 1 \|\| !node.attrs) { return; } if (node.tag === 'img' \|\| node.tag === 'source') { node.attrs.forEach(attr => { if (attr.name === 'srcset') { // same logic as in transform-require.js const value = attr.value; const isStatic = value.charAt(0) === '"' && value.charAt(value.length - 1) === '"'; if (!isStatic) { return; } const imageCandidates = value .slice(1, -1) .split(',') .map(s => { // The attribute value arrives here with all whitespace, except // normal spaces, represented by escape sequences const [url, descriptor] = s .replace(escapedSpaceCharacters, ' ') .trim() .split(' ', 2); return { require: urlToRequire(url, transformAssetUrlsOptions), descriptor }; }); // "require(url1)" // "require(url1) 1x" // "require(url1), require(url2)" // "require(url1), require(url2) 2x" // "require(url1) 1x, require(url2)" // "require(url1) 1x, require(url2) 2x" const code = imageCandidates .map(({ require, descriptor }) => `${require} + "${descriptor ? ' ' + descriptor : ''}, " + `) .join('') .slice(0, -6) .concat('"') .replace(/ \+ ""$/, ''); attr.value = code; } }); } } var consolidate$2 = {exports: {}}; function commonjsRequire(path) { throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.'); } var consolidate$1 = {exports: {}}; (function (module, exports) { / * Engines which do not support caching of their file contents * should use the `read()` function defined in consolidate.js * On top of this, when an engine compiles to a `Function`, * these functions should either be cached within consolidate.js * or the engine itself via `options.cache`. This will allow * users and frameworks to pass `options.cache = true` for * `NODE_ENV=production`, however edit the file(s) without * re-loading the application in development. / /* * Module dependencies. / var fs = require$$0__default["default"]; var path = path__default["default"]; var util = require$$2__default["default"]; var join = path.join; var resolve = path.resolve; var extname = path.extname; var dirname = path.dirname; var isAbsolute = path.isAbsolute; var readCache = {}; /* * Require cache. / var cacheStore = {}; /* * Require cache. / var requires = {}; /* * Clear the cache. * * @api public / exports.clearCache = function() { readCache = {}; cacheStore = {}; }; /* * Conditionally cache `compiled` template based * on the `options` filename and `.cache` boolean. * * @param {Object} options * @param {Function} compiled * @return {Function} * @api private / function cache(options, compiled) { // cachable if (compiled && options.filename && options.cache) { delete readCache[options.filename]; cacheStore[options.filename] = compiled; return compiled; } // check cache if (options.filename && options.cache) { return cacheStore[options.filename]; } return compiled; } /* * Read `path` with `options` with * callback `(err, str)`. When `options.cache` * is true the template string will be cached. * * @param {String} options * @param {Function} cb * @api private / function read(path, options, cb) { var str = readCache[path]; var cached = options.cache && str && typeof str === 'string'; // cached (only if cached is a string and not a compiled template function) if (cached) return cb(null, str); // read fs.readFile(path, 'utf8', function(err, str) { if (err) return cb(err); // remove extraneous utf8 BOM marker str = str.replace(/^\uFEFF/, ''); if (options.cache) readCache[path] = str; cb(null, str); }); } /* * Read `path` with `options` with * callback `(err, str)`. When `options.cache` * is true the partial string will be cached. * * @param {String} options * @param {Function} fn * @api private / function readPartials(path, options, cb) { if (!options.partials) return cb(); var keys = Object.keys(options.partials); var partials = {}; function next(index) { if (index === keys.length) return cb(null, partials); var key = keys[index]; var partialPath = options.partials[key]; if (partialPath === undefined \|\| partialPath === null \|\| partialPath === false) { return next(++index); } var file; if (isAbsolute(partialPath)) { if (extname(partialPath) !== '') { file = partialPath; } else { file = join(partialPath + extname(path)); } } else { file = join(dirname(path), partialPath + extname(path)); } read(file, options, function(err, str) { if (err) return cb(err); partials[key] = str; next(++index); }); } next(0); } /* * promisify / function promisify(cb, fn) { return new Promise(function(resolve, reject) { cb = cb \|\| function(err, html) { if (err) { return reject(err); } resolve(html); }; fn(cb); }); } /* * fromStringRenderer / function fromStringRenderer(name) { return function(path, options, cb) { options.filename = path; return promisify(cb, function(cb) { readPartials(path, options, function(err, partials) { var extend = (requires.extend \|\| (requires.extend = require$$2__default["default"]._extend)); var opts = extend({}, options); opts.partials = partials; if (err) return cb(err); if (cache(opts)) { exports[name].render('', opts, cb); } else { read(path, opts, function(err, str) { if (err) return cb(err); exports[name].render(str, opts, cb); }); } }); }); }; } /* * velocity support. / exports.velocityjs = fromStringRenderer('velocityjs'); /* * velocity string support. / exports.velocityjs.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.velocityjs \|\| (requires.velocityjs = require('velocityjs')); try { options.locals = options; cb(null, engine.render(str, options).trimLeft()); } catch (err) { cb(err); } }); }; /* * Liquid support. / exports.liquid = fromStringRenderer('liquid'); /* * Liquid string support. / /* * Note that in order to get filters and custom tags we've had to push * all user-defined locals down into @locals. However, just to make things * backwards-compatible, any property of `options` that is left after * processing and removing `locals`, `meta`, `filters`, `customTags` and * `includeDir` will also become a local. / function _renderTinyliquid(engine, str, options, cb) { var context = engine.newContext(); var k; /* * Note that there's a bug in the library that doesn't allow us to pass * the locals to newContext(), hence looping through the keys: / if (options.locals) { for (k in options.locals) { context.setLocals(k, options.locals[k]); } delete options.locals; } if (options.meta) { context.setLocals('page', options.meta); delete options.meta; } /* * Add any defined filters: / if (options.filters) { for (k in options.filters) { context.setFilter(k, options.filters[k]); } delete options.filters; } /* * Set up a callback for the include directory: / var includeDir = options.includeDir \|\| process.cwd(); context.onInclude(function(name, callback) { var extname = path.extname(name) ? '' : '.liquid'; var filename = path.resolve(includeDir, name + extname); fs.readFile(filename, {encoding: 'utf8'}, function(err, data) { if (err) return callback(err); callback(null, engine.parse(data)); }); }); delete options.includeDir; /* * The custom tag functions need to have their results pushed back * through the parser, so set up a shim before calling the provided * callback: / var compileOptions = { customTags: {} }; if (options.customTags) { var tagFunctions = options.customTags; for (k in options.customTags) { /Tell jshint there's no problem with having this function in the loop / /jshint -W083 / compileOptions.customTags[k] = function(context, name, body) { var tpl = tagFunctions[name](body.trim()); context.astStack.push(engine.parse(tpl)); }; /jshint +W083 / } delete options.customTags; } /* * Now anything left in `options` becomes a local: / for (k in options) { context.setLocals(k, options[k]); } /* * Finally, execute the template: / var tmpl = cache(context) \|\| cache(context, engine.compile(str, compileOptions)); tmpl(context, cb); } exports.liquid.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.liquid; var Liquid; try { // set up tinyliquid engine engine = requires.liquid = require('tinyliquid'); // use tinyliquid engine _renderTinyliquid(engine, str, options, cb); return; } catch (err) { // set up liquid-node engine try { Liquid = requires.liquid = require('liquid-node'); engine = new Liquid.Engine(); } catch (err) { throw err; } } // use liquid-node engine try { var locals = options.locals \|\| {}; if (options.meta) { locals.pages = options.meta; delete options.meta; } /* * Add any defined filters: / if (options.filters) { engine.registerFilters(options.filters); delete options.filters; } /* * Set up a callback for the include directory: / var includeDir = options.includeDir \|\| process.cwd(); engine.fileSystem = new Liquid.LocalFileSystem(includeDir, 'liquid'); delete options.includeDir; /* * The custom tag functions need to have their results pushed back * through the parser, so set up a shim before calling the provided * callback: / if (options.customTags) { var tagFunctions = options.customTags; for (k in options.customTags) { engine.registerTag(k, tagFunctions[k]); } delete options.customTags; } /* * Now anything left in `options` becomes a local: / for (var k in options) { locals[k] = options[k]; } /* * Finally, execute the template: / return engine .parseAndRender(str, locals) .nodeify(function(err, result) { if (err) { throw new Error(err); } else { return cb(null, result); } }); } catch (err) { cb(err); } }); }; /* * Jade support. / exports.jade = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.jade; if (!engine) { try { engine = requires.jade = require('jade'); } catch (err) { try { engine = requires.jade = require('then-jade'); } catch (otherError) { throw err; } } } try { var tmpl = cache(options) \|\| cache(options, engine.compileFile(path, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Jade string support. / exports.jade.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.jade; if (!engine) { try { engine = requires.jade = require('jade'); } catch (err) { try { engine = requires.jade = require('then-jade'); } catch (otherError) { throw err; } } } try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Dust support. / exports.dust = fromStringRenderer('dust'); /* * Dust string support. / exports.dust.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.dust; if (!engine) { try { engine = requires.dust = require('dust'); } catch (err) { try { engine = requires.dust = require('dustjs-helpers'); } catch (err) { engine = requires.dust = require('dustjs-linkedin'); } } } var ext = 'dust'; var views = '.'; if (options) { if (options.ext) ext = options.ext; if (options.views) views = options.views; if (options.settings && options.settings.views) views = options.settings.views; } if (!options \|\| (options && !options.cache)) engine.cache = {}; engine.onLoad = function(path, callback) { if (extname(path) === '') path += '.' + ext; if (path[0] !== '/') path = views + '/' + path; read(path, options, callback); }; try { var templateName; if (options.filename) { templateName = options.filename.replace(new RegExp('^' + views + '/'), '').replace(new RegExp('\\.' + ext), ''); } var tmpl = cache(options) \|\| cache(options, engine.compileFn(str, templateName)); tmpl(options, cb); } catch (err) { cb(err); } }); }; /* * Swig support. / exports.swig = fromStringRenderer('swig'); /* * Swig string support. / exports.swig.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.swig; if (!engine) { try { engine = requires.swig = require('swig'); } catch (err) { try { engine = requires.swig = require('swig-templates'); } catch (otherError) { throw err; } } } try { if (options.cache === true) options.cache = 'memory'; engine.setDefaults({ cache: options.cache }); var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Razor support. / exports.razor = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.razor; if (!engine) { try { engine = requires.razor = require('razor-tmpl'); } catch (err) { throw err; } } try { var tmpl = cache(options) \|\| cache(options, (locals) => { console.log('Rendering razor file', path); return engine.renderFileSync(path, locals); }); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * razor string support. / exports.razor.render = function(str, options, cb) { return promisify(cb, function(cb) { try { var engine = requires.razor = require('razor-tmpl'); } catch (err) { throw err; } try { var tf = engine.compile(str); var tmpl = cache(options) \|\| cache(options, tf); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Atpl support. / exports.atpl = fromStringRenderer('atpl'); /* * Atpl string support. / exports.atpl.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.atpl \|\| (requires.atpl = require('atpl')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Liquor support, / exports.liquor = fromStringRenderer('liquor'); /* * Liquor string support. / exports.liquor.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.liquor \|\| (requires.liquor = require('liquor')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Twig support. / exports.twig = fromStringRenderer('twig'); /* * Twig string support. / exports.twig.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.twig \|\| (requires.twig = require('twig').twig); var templateData = { data: str, allowInlineIncludes: options.allowInlineIncludes, namespaces: options.namespaces, path: options.path }; try { var tmpl = cache(templateData) \|\| cache(templateData, engine(templateData)); cb(null, tmpl.render(options)); } catch (err) { cb(err); } }); }; /* * EJS support. / exports.ejs = fromStringRenderer('ejs'); /* * EJS string support. / exports.ejs.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.ejs \|\| (requires.ejs = require('ejs')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Eco support. / exports.eco = fromStringRenderer('eco'); /* * Eco string support. / exports.eco.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.eco \|\| (requires.eco = require('eco')); try { cb(null, engine.render(str, options)); } catch (err) { cb(err); } }); }; /* * Jazz support. / exports.jazz = fromStringRenderer('jazz'); /* * Jazz string support. / exports.jazz.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.jazz \|\| (requires.jazz = require('jazz')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); tmpl.eval(options, function(str) { cb(null, str); }); } catch (err) { cb(err); } }); }; /* * JQTPL support. / exports.jqtpl = fromStringRenderer('jqtpl'); /* * JQTPL string support. / exports.jqtpl.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.jqtpl \|\| (requires.jqtpl = require('jqtpl')); try { engine.template(str, str); cb(null, engine.tmpl(str, options)); } catch (err) { cb(err); } }); }; /* * Haml support. / exports.haml = fromStringRenderer('haml'); /* * Haml string support. / exports.haml.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.haml \|\| (requires.haml = require('hamljs')); try { options.locals = options; cb(null, engine.render(str, options).trimLeft()); } catch (err) { cb(err); } }); }; /* * Hamlet support. / exports.hamlet = fromStringRenderer('hamlet'); /* * Hamlet string support. / exports.hamlet.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.hamlet \|\| (requires.hamlet = require('hamlet')); try { options.locals = options; cb(null, engine.render(str, options).trimLeft()); } catch (err) { cb(err); } }); }; /* * Whiskers support. / exports.whiskers = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.whiskers \|\| (requires.whiskers = require('whiskers')); engine.__express(path, options, cb); }); }; /* * Whiskers string support. / exports.whiskers.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.whiskers \|\| (requires.whiskers = require('whiskers')); try { cb(null, engine.render(str, options)); } catch (err) { cb(err); } }); }; /* * Coffee-HAML support. / exports['haml-coffee'] = fromStringRenderer('haml-coffee'); /* * Coffee-HAML string support. / exports['haml-coffee'].render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires['haml-coffee'] \|\| (requires['haml-coffee'] = require('haml-coffee')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Hogan support. / exports.hogan = fromStringRenderer('hogan'); /* * Hogan string support. / exports.hogan.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.hogan \|\| (requires.hogan = require('hogan.js')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl.render(options, options.partials)); } catch (err) { cb(err); } }); }; /* * templayed.js support. / exports.templayed = fromStringRenderer('templayed'); /* * templayed.js string support. / exports.templayed.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.templayed \|\| (requires.templayed = require('templayed')); try { var tmpl = cache(options) \|\| cache(options, engine(str)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Handlebars support. / exports.handlebars = fromStringRenderer('handlebars'); /* * Handlebars string support. / exports.handlebars.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.handlebars \|\| (requires.handlebars = require('handlebars')); try { for (var partial in options.partials) { engine.registerPartial(partial, options.partials[partial]); } for (var helper in options.helpers) { engine.registerHelper(helper, options.helpers[helper]); } var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Underscore support. / exports.underscore = fromStringRenderer('underscore'); /* * Underscore string support. / exports.underscore.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.underscore \|\| (requires.underscore = require('underscore')); try { const partials = {}; for (var partial in options.partials) { partials[partial] = engine.template(options.partials[partial]); } options.partials = partials; var tmpl = cache(options) \|\| cache(options, engine.template(str, null, options)); cb(null, tmpl(options).replace(/\n$/, '')); } catch (err) { cb(err); } }); }; /* * Lodash support. / exports.lodash = fromStringRenderer('lodash'); /* * Lodash string support. / exports.lodash.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.lodash \|\| (requires.lodash = require('lodash')); try { var tmpl = cache(options) \|\| cache(options, engine.template(str, options)); cb(null, tmpl(options).replace(/\n$/, '')); } catch (err) { cb(err); } }); }; /* * Pug support. (formerly Jade) / exports.pug = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.pug; if (!engine) { try { engine = requires.pug = require('pug'); } catch (err) { try { engine = requires.pug = require('then-pug'); } catch (otherError) { throw err; } } } try { var tmpl = cache(options) \|\| cache(options, engine.compileFile(path, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Pug string support. / exports.pug.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.pug; if (!engine) { try { engine = requires.pug = require('pug'); } catch (err) { try { engine = requires.pug = require('then-pug'); } catch (otherError) { throw err; } } } try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * QEJS support. / exports.qejs = fromStringRenderer('qejs'); /* * QEJS string support. / exports.qejs.render = function(str, options, cb) { return promisify(cb, function(cb) { try { var engine = requires.qejs \|\| (requires.qejs = require('qejs')); engine.render(str, options).then(function(result) { cb(null, result); }, function(err) { cb(err); }).done(); } catch (err) { cb(err); } }); }; /* * Walrus support. / exports.walrus = fromStringRenderer('walrus'); /* * Walrus string support. / exports.walrus.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.walrus \|\| (requires.walrus = require('walrus')); try { var tmpl = cache(options) \|\| cache(options, engine.parse(str)); cb(null, tmpl.compile(options)); } catch (err) { cb(err); } }); }; /* * Mustache support. / exports.mustache = fromStringRenderer('mustache'); /* * Mustache string support. / exports.mustache.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.mustache \|\| (requires.mustache = require('mustache')); try { cb(null, engine.render(str, options, options.partials)); } catch (err) { cb(err); } }); }; /* * Just support. / exports.just = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.just; if (!engine) { var JUST = require('just'); engine = requires.just = new JUST(); } engine.configure({ useCache: options.cache }); engine.render(path, options, cb); }); }; /* * Just string support. / exports.just.render = function(str, options, cb) { return promisify(cb, function(cb) { var JUST = require('just'); var engine = new JUST({ root: { page: str }}); engine.render('page', options, cb); }); }; /* * ECT support. / exports.ect = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.ect; if (!engine) { var ECT = require('ect'); engine = requires.ect = new ECT(options); } engine.configure({ cache: options.cache }); engine.render(path, options, cb); }); }; /* * ECT string support. / exports.ect.render = function(str, options, cb) { return promisify(cb, function(cb) { var ECT = require('ect'); var engine = new ECT({ root: { page: str }}); engine.render('page', options, cb); }); }; /* * mote support. / exports.mote = fromStringRenderer('mote'); /* * mote string support. / exports.mote.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.mote \|\| (requires.mote = require('mote')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Toffee support. / exports.toffee = function(path, options, cb) { return promisify(cb, function(cb) { var toffee = requires.toffee \|\| (requires.toffee = require('toffee')); toffee.__consolidate_engine_render(path, options, cb); }); }; /* * Toffee string support. / exports.toffee.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.toffee \|\| (requires.toffee = require('toffee')); try { engine.str_render(str, options, cb); } catch (err) { cb(err); } }); }; /* * doT support. / exports.dot = fromStringRenderer('dot'); /* * doT string support. / exports.dot.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.dot \|\| (requires.dot = require('dot')); var extend = (requires.extend \|\| (requires.extend = require$$2__default["default"]._extend)); try { var settings = {}; settings = extend(settings, engine.templateSettings); settings = extend(settings, options ? options.dot : {}); var tmpl = cache(options) \|\| cache(options, engine.template(str, settings, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * bracket support. / exports.bracket = fromStringRenderer('bracket'); /* * bracket string support. / exports.bracket.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.bracket \|\| (requires.bracket = require('bracket-template')); try { var tmpl = cache(options) \|\| cache(options, engine.default.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Ractive support. / exports.ractive = fromStringRenderer('ractive'); /* * Ractive string support. / exports.ractive.render = function(str, options, cb) { return promisify(cb, function(cb) { var Engine = requires.ractive \|\| (requires.ractive = require('ractive')); var template = cache(options) \|\| cache(options, Engine.parse(str)); options.template = template; if (options.data === null \|\| options.data === undefined) { var extend = (requires.extend \|\| (requires.extend = require$$2__default["default"]._extend)); // Shallow clone the options object options.data = extend({}, options); // Remove consolidate-specific properties from the clone var i; var length; var properties = ['template', 'filename', 'cache', 'partials']; for (i = 0, length = properties.length; i < length; i++) { var property = properties[i]; delete options.data[property]; } } try { cb(null, new Engine(options).toHTML()); } catch (err) { cb(err); } }); }; /* * Nunjucks support. / exports.nunjucks = fromStringRenderer('nunjucks'); /* * Nunjucks string support. / exports.nunjucks.render = function(str, options, cb) { return promisify(cb, function(cb) { try { var engine = options.nunjucksEnv \|\| requires.nunjucks \|\| (requires.nunjucks = require('nunjucks')); var env = engine; // deprecated fallback support for express // <https://github.com/tj/consolidate.js/pull/152> // <https://github.com/tj/consolidate.js/pull/224> if (options.settings && options.settings.views) { env = engine.configure(options.settings.views); } else if (options.nunjucks && options.nunjucks.configure) { env = engine.configure.apply(engine, options.nunjucks.configure); } // // because `renderString` does not initiate loaders // we must manually create a loader for it based off // either `options.settings.views` or `options.nunjucks` or `options.nunjucks.root` // // <https://github.com/mozilla/nunjucks/issues/730> // <https://github.com/crocodilejs/node-email-templates/issues/182> // // so instead we simply check if we passed a custom loader // otherwise we create a simple file based loader if (options.loader) { env = new engine.Environment(options.loader); } else if (options.settings && options.settings.views) { env = new engine.Environment( new engine.FileSystemLoader(options.settings.views) ); } else if (options.nunjucks && options.nunjucks.loader) { if (typeof options.nunjucks.loader === 'string') { env = new engine.Environment(new engine.FileSystemLoader(options.nunjucks.loader)); } else { env = new engine.Environment( new engine.FileSystemLoader( options.nunjucks.loader[0], options.nunjucks.loader[1] ) ); } } env.renderString(str, options, cb); } catch (err) { throw cb(err); } }); }; /* * HTMLing support. / exports.htmling = fromStringRenderer('htmling'); /* * HTMLing string support. / exports.htmling.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.htmling \|\| (requires.htmling = require('htmling')); try { var tmpl = cache(options) \|\| cache(options, engine.string(str)); cb(null, tmpl.render(options)); } catch (err) { cb(err); } }); }; /* * Rendering function / function requireReact(module, filename) { var babel = requires.babel \|\| (requires.babel = require('babel-core')); var compiled = babel.transformFileSync(filename, { presets: [ 'react' ] }).code; return module._compile(compiled, filename); } exports.requireReact = requireReact; /* * Converting a string into a node module. / function requireReactString(src, filename) { var babel = requires.babel \|\| (requires.babel = require('babel-core')); if (!filename) filename = ''; var m = new module.constructor(); filename = filename \|\| ''; // Compile Using React var compiled = babel.transform(src, { presets: [ 'react' ] }).code; // Compile as a module m.paths = module.paths; m._compile(compiled, filename); return m.exports; } /* * A naive helper to replace {{tags}} with options.tags content / function reactBaseTmpl(data, options) { var exp; var regex; // Iterates through the keys in file object // and interpolate / replace {{key}} with it's value for (var k in options) { if (options.hasOwnProperty(k)) { exp = '{{' + k + '}}'; regex = new RegExp(exp, 'g'); if (data.match(regex)) { data = data.replace(regex, options[k]); } } } return data; } /* * Plates Support. / exports.plates = fromStringRenderer('plates'); /* * Plates string support. / exports.plates.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.plates \|\| (requires.plates = require('plates')); var map = options.map \|\| undefined; try { var tmpl = engine.bind(str, options, map); cb(null, tmpl); } catch (err) { cb(err); } }); }; /* * The main render parser for React bsaed templates / function reactRenderer(type) { if (commonjsRequire.extensions) { // Ensure JSX is transformed on require if (!commonjsRequire.extensions['.jsx']) { commonjsRequire.extensions['.jsx'] = requireReact; } // Supporting .react extension as well as test cases // Using .react extension is not recommended. if (!commonjsRequire.extensions['.react']) { commonjsRequire.extensions['.react'] = requireReact; } } // Return rendering fx return function(str, options, cb) { return promisify(cb, function(cb) { // React Import var ReactDOM = requires.ReactDOM \|\| (requires.ReactDOM = require('react-dom/server')); var react = requires.react \|\| (requires.react = require('react')); // Assign HTML Base var base = options.base; delete options.base; var enableCache = options.cache; delete options.cache; var isNonStatic = options.isNonStatic; delete options.isNonStatic; // Start Conversion try { var Code; var Factory; var baseStr; var content; var parsed; if (!cache(options)) { // Parsing if (type === 'path') { var path = resolve(str); delete require.cache[path]; Code = commonjsRequire(path); } else { Code = requireReactString(str); } Factory = cache(options, react.createFactory(Code)); } else { Factory = cache(options); } parsed = new Factory(options); content = (isNonStatic) ? ReactDOM.renderToString(parsed) : ReactDOM.renderToStaticMarkup(parsed); if (base) { baseStr = readCache[str] \|\| fs.readFileSync(resolve(base), 'utf8'); if (enableCache) { readCache[str] = baseStr; } options.content = content; content = reactBaseTmpl(baseStr, options); } cb(null, content); } catch (err) { cb(err); } }); }; } /* * React JS Support / exports.react = reactRenderer('path'); /* * React JS string support. / exports.react.render = reactRenderer('string'); /* * ARC-templates support. / exports['arc-templates'] = fromStringRenderer('arc-templates'); /* * ARC-templates string support. / exports['arc-templates'].render = function(str, options, cb) { var readFileWithOptions = util.promisify(read); var consolidateFileSystem = {}; consolidateFileSystem.readFile = function(path) { return readFileWithOptions(path, options); }; return promisify(cb, function(cb) { try { var engine = requires['arc-templates']; if (!engine) { var Engine = require('arc-templates/dist/es5'); engine = requires['arc-templates'] = new Engine({ filesystem: consolidateFileSystem }); } var compiler = cache(options) \|\| cache(options, engine.compileString(str, options.filename)); compiler.then(function(func) { return func(options); }) .then(function(result) { cb(null, result.content); }) .catch(cb); } catch (err) { cb(err); } }); }; /* * Vash support / exports.vash = fromStringRenderer('vash'); /* * Vash string support / exports.vash.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.vash \|\| (requires.vash = require('vash')); try { // helper system : https://github.com/kirbysayshi/vash#helper-system if (options.helpers) { for (var key in options.helpers) { if (!options.helpers.hasOwnProperty(key) \|\| typeof options.helpers[key] !== 'function') { continue; } engine.helpers[key] = options.helpers[key]; } } var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); tmpl(options, function sealLayout(err, ctx) { if (err) cb(err); ctx.finishLayout(); cb(null, ctx.toString().replace(/\n$/, '')); }); } catch (err) { cb(err); } }); }; /* * Slm support. / exports.slm = fromStringRenderer('slm'); /* * Slm string support. / exports.slm.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.slm \|\| (requires.slm = require('slm')); try { var tmpl = cache(options) \|\| cache(options, engine.compile(str, options)); cb(null, tmpl(options)); } catch (err) { cb(err); } }); }; /* * Marko support. / exports.marko = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.marko \|\| (requires.marko = require('marko')); options.writeToDisk = !!options.cache; try { var tmpl = cache(options) \|\| cache(options, engine.load(path, options)); tmpl.renderToString(options, cb); } catch (err) { cb(err); } }); }; /* * Marko string support. / exports.marko.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.marko \|\| (requires.marko = require('marko')); options.writeToDisk = !!options.cache; options.filename = options.filename \|\| 'string.marko'; try { var tmpl = cache(options) \|\| cache(options, engine.load(options.filename, str, options)); tmpl.renderToString(options, cb); } catch (err) { cb(err); } }); }; /* * Teacup support. / exports.teacup = function(path, options, cb) { return promisify(cb, function(cb) { var engine = requires.teacup \|\| (requires.teacup = require('teacup/lib/express')); commonjsRequire.extensions['.teacup'] = commonjsRequire.extensions['.coffee']; if (path[0] !== '/') { path = join(process.cwd(), path); } if (!options.cache) { var callback = cb; cb = function() { delete require.cache[path]; callback.apply(this, arguments); }; } engine.renderFile(path, options, cb); }); }; /* * Teacup string support. / exports.teacup.render = function(str, options, cb) { var coffee = require('coffee-script'); var vm = require('vm'); var sandbox = { module: {exports: {}}, require: commonjsRequire }; return promisify(cb, function(cb) { vm.runInNewContext(coffee.compile(str), sandbox); var tmpl = sandbox.module.exports; cb(null, tmpl(options)); }); }; /* * Squirrelly support. / exports.squirrelly = fromStringRenderer('squirrelly'); /* * Squirrelly string support. / exports.squirrelly.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.squirrelly \|\| (requires.squirrelly = require('squirrelly')); try { for (var partial in options.partials) { engine.definePartial(partial, options.partials[partial]); } for (var helper in options.helpers) { engine.defineHelper(helper, options.helpers[helper]); } var tmpl = cache(options) \|\| cache(options, engine.Compile(str, options)); cb(null, tmpl(options, engine)); } catch (err) { cb(err); } }); }; /* * Twing support. / exports.twing = fromStringRenderer('twing'); /* * Twing string support. / exports.twing.render = function(str, options, cb) { return promisify(cb, function(cb) { var engine = requires.twing \|\| (requires.twing = require('twing')); try { new engine.TwingEnvironment(new engine.TwingLoaderNull()).createTemplate(str).then((twingTemplate) => { twingTemplate.render(options).then((rendTmpl) => { var tmpl = cache(options) \|\| cache(options, rendTmpl); cb(null, tmpl); }); }); } catch (err) { cb(err); } }); }; /* * expose the instance of the engine / exports.requires = requires; } (consolidate$1, consolidate$1.exports)); (function (module) { module.exports = consolidate$1.exports; } (consolidate$2)); var consolidate = /@__PURE__/getDefaultExportFromCjs(consolidate$2.exports); let isStaticKey; let isPlatformReservedTag$1; const genStaticKeysCached = cached(genStaticKeys); /* * Goal of the optimizer: walk the generated template AST tree * and detect sub-trees that are purely static, i.e. parts of * the DOM that never needs to change. * * Once we detect these sub-trees, we can: * * 1. Hoist them into constants, so that we no longer need to * create fresh nodes for them on each re-render; * 2. Completely skip them in the patching process. / function optimize$1(root, options) { if (!root) return; isStaticKey = genStaticKeysCached(options.staticKeys \|\| ''); isPlatformReservedTag$1 = options.isReservedTag \|\| no; // first pass: mark all non-static nodes. markStatic(root); // second pass: mark static roots. markStaticRoots(root, false); } function genStaticKeys(keys) { return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' + (keys ? ',' + keys : '')); } function markStatic(node) { node.static = isStatic(node); if (node.type === 1) { // do not make component slot content static. this avoids // 1. components not able to mutate slot nodes // 2. static slot content fails for hot-reloading if (!isPlatformReservedTag$1(node.tag) && node.tag !== 'slot' && node.attrsMap['inline-template'] == null) { return; } for (let i = 0, l = node.children.length; i < l; i++) { const child = node.children[i]; markStatic(child); if (!child.static) { node.static = false; } } if (node.ifConditions) { for (let i = 1, l = node.ifConditions.length; i < l; i++) { const block = node.ifConditions[i].block; markStatic(block); if (!block.static) { node.static = false; } } } } } function markStaticRoots(node, isInFor) { if (node.type === 1) { if (node.static \|\| node.once) { node.staticInFor = isInFor; } // For a node to qualify as a static root, it should have children that // are not just static text. Otherwise the cost of hoisting out will // outweigh the benefits and it's better off to just always render it fresh. if (node.static && node.children.length && !(node.children.length === 1 && node.children[0].type === 3)) { node.staticRoot = true; return; } else { node.staticRoot = false; } if (node.children) { for (let i = 0, l = node.children.length; i < l; i++) { markStaticRoots(node.children[i], isInFor \|\| !!node.for); } } if (node.ifConditions) { for (let i = 1, l = node.ifConditions.length; i < l; i++) { markStaticRoots(node.ifConditions[i].block, isInFor); } } } } function isStatic(node) { if (node.type === 2) { // expression return false; } if (node.type === 3) { // text return true; } return !!(node.pre \|\| (!node.hasBindings && // no dynamic bindings !node.if && !node.for && // not v-if or v-for or v-else !isBuiltInTag(node.tag) && // not a built-in isPlatformReservedTag$1(node.tag) && // not a component !isDirectChildOfTemplateFor(node) && Object.keys(node).every(isStaticKey))); } function isDirectChildOfTemplateFor(node) { while (node.parent) { node = node.parent; if (node.tag !== 'template') { return false; } if (node.for) { return true; } } return false; } const fnExpRE = /^([\w$_]+\|$[^)]?$)\s=>\|^function(?:\s+[\w$]+)?\s$/; const fnInvokeRE = /\([^)]?$;$/; const simplePathRE = /^[A-Za-z_$][\w$](?:\.[A-Za-z_$][\w$]\|\['[^']?']\|\["[^"]?"]\|\[\d+]\|\[[A-Za-z_$][\w$]])$/; // KeyboardEvent.keyCode aliases const keyCodes = { esc: 27, tab: 9, enter: 13, space: 32, up: 38, left: 37, right: 39, down: 40, delete: [8, 46] }; // KeyboardEvent.key aliases const keyNames = { // #7880: IE11 and Edge use `Esc` for Escape key name. esc: ['Esc', 'Escape'], tab: 'Tab', enter: 'Enter', // #9112: IE11 uses `Spacebar` for Space key name. space: [' ', 'Spacebar'], // #7806: IE11 uses key names without `Arrow` prefix for arrow keys. up: ['Up', 'ArrowUp'], left: ['Left', 'ArrowLeft'], right: ['Right', 'ArrowRight'], down: ['Down', 'ArrowDown'], // #9112: IE11 uses `Del` for Delete key name. delete: ['Backspace', 'Delete', 'Del'] }; // #4868: modifiers that prevent the execution of the listener // need to explicitly return null so that we can determine whether to remove // the listener for .once const genGuard = condition => `if(${condition})return null;`; const modifierCode = { stop: '$event.stopPropagation();', prevent: '$event.preventDefault();', self: genGuard(`$event.target !== $event.currentTarget`), ctrl: genGuard(`!$event.ctrlKey`), shift: genGuard(`!$event.shiftKey`), alt: genGuard(`!$event.altKey`), meta: genGuard(`!$event.metaKey`), left: genGuard(`'button' in $event && $event.button !== 0`), middle: genGuard(`'button' in $event && $event.button !== 1`), right: genGuard(`'button' in $event && $event.button !== 2`) }; function genHandlers(events, isNative) { const prefix = isNative ? 'nativeOn:' : 'on:'; let staticHandlers = ``; let dynamicHandlers = ``; for (const name in events) { const handlerCode = genHandler(events[name]); //@ts-expect-error if (events[name] && events[name].dynamic) { dynamicHandlers += `${name},${handlerCode},`; } else { staticHandlers += `"${name}":${handlerCode},`; } } staticHandlers = `{${staticHandlers.slice(0, -1)}}`; if (dynamicHandlers) { return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`; } else { return prefix + staticHandlers; } } function genHandler(handler) { if (!handler) { return 'function(){}'; } if (Array.isArray(handler)) { return `[${handler.map(handler => genHandler(handler)).join(',')}]`; } const isMethodPath = simplePathRE.test(handler.value); const isFunctionExpression = fnExpRE.test(handler.value); const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, '')); if (!handler.modifiers) { if (isMethodPath \|\| isFunctionExpression) { return handler.value; } return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement } else { let code = ''; let genModifierCode = ''; const keys = []; for (const key in handler.modifiers) { if (modifierCode[key]) { genModifierCode += modifierCode[key]; // left/right if (keyCodes[key]) { keys.push(key); } } else if (key === 'exact') { const modifiers = handler.modifiers; genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta'] .filter(keyModifier => !modifiers[keyModifier]) .map(keyModifier => `$event.${keyModifier}Key`) .join('\|\|')); } else { keys.push(key); } } if (keys.length) { code += genKeyFilter(keys); } // Make sure modifiers like prevent and stop get executed after key filtering if (genModifierCode) { code += genModifierCode; } const handlerCode = isMethodPath ? `return ${handler.value}.apply(null, arguments)` : isFunctionExpression ? `return (${handler.value}).apply(null, arguments)` : isFunctionInvocation ? `return ${handler.value}` : handler.value; return `function($event){${code}${handlerCode}}`; } } function genKeyFilter(keys) { return ( // make sure the key filters only apply to KeyboardEvents // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake // key events that do not have keyCode property... `if(!$event.type.indexOf('key')&&` + `${keys.map(genFilterCode).join('&&')})return null;`); } function genFilterCode(key) { const keyVal = parseInt(key, 10); if (keyVal) { return `$event.keyCode!==${keyVal}`; } const keyCode = keyCodes[key]; const keyName = keyNames[key]; return (`_k($event.keyCode,` + `${JSON.stringify(key)},` + `${JSON.stringify(keyCode)},` + `$event.key,` + `${JSON.stringify(keyName)}` + `)`); } function on(el, dir) { if (process.env.NODE_ENV !== 'production' && dir.modifiers) { warn$3(`v-on without argument does not support modifiers.`); } el.wrapListeners = (code) => `_g(${code},${dir.value})`; } function bind(el, dir) { el.wrapData = (code) => { return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`; }; } var baseDirectives = { on, bind, cloak: noop }; class CodegenState { constructor(options) { this.options = options; this.warn = options.warn \|\| baseWarn; this.transforms = pluckModuleFunction(options.modules, 'transformCode'); this.dataGenFns = pluckModuleFunction(options.modules, 'genData'); this.directives = extend(extend({}, baseDirectives), options.directives); const isReservedTag = options.isReservedTag \|\| no; this.maybeComponent = (el) => !!el.component \|\| !isReservedTag(el.tag); this.onceId = 0; this.staticRenderFns = []; this.pre = false; } } function generate$1(ast, options) { const state = new CodegenState(options); // fix #11483, Root level <script> tags should not be rendered. const code = ast ? ast.tag === 'script' ? 'null' : genElement(ast, state) : '_c("div")'; return { render: `with(this){return ${code}}`, staticRenderFns: state.staticRenderFns }; } function genElement(el, state) { if (el.parent) { el.pre = el.pre \|\| el.parent.pre; } if (el.staticRoot && !el.staticProcessed) { return genStatic(el, state); } else if (el.once && !el.onceProcessed) { return genOnce(el, state); } else if (el.for && !el.forProcessed) { return genFor(el, state); } else if (el.if && !el.ifProcessed) { return genIf(el, state); } else if (el.tag === 'template' && !el.slotTarget && !state.pre) { return genChildren(el, state) \|\| 'void 0'; } else if (el.tag === 'slot') { return genSlot(el, state); } else { // component or element let code; if (el.component) { code = genComponent(el.component, el, state); } else { let data; const maybeComponent = state.maybeComponent(el); if (!el.plain \|\| (el.pre && maybeComponent)) { data = genData(el, state); } let tag; // check if this is a component in <script setup> const bindings = state.options.bindings; if (maybeComponent && bindings && bindings.__isScriptSetup !== false) { tag = checkBindingType(bindings, el.tag); } if (!tag) tag = `'${el.tag}'`; const children = el.inlineTemplate ? null : genChildren(el, state, true); code = `_c(${tag}${data ? `,${data}` : '' // data }${children ? `,${children}` : '' // children })`; } // module transforms for (let i = 0; i < state.transforms.length; i++) { code = state.transforms[i](el, code); } return code; } } function checkBindingType(bindings, key) { const camelName = camelize(key); const PascalName = capitalize(camelName); const checkType = (type) => { if (bindings[key] === type) { return key; } if (bindings[camelName] === type) { return camelName; } if (bindings[PascalName] === type) { return PascalName; } }; const fromConst = checkType("setup-const" /* BindingTypes.SETUP_CONST /) \|\| checkType("setup-reactive-const" / BindingTypes.SETUP_REACTIVE_CONST /); if (fromConst) { return fromConst; } const fromMaybeRef = checkType("setup-let" / BindingTypes.SETUP_LET /) \|\| checkType("setup-ref" / BindingTypes.SETUP_REF /) \|\| checkType("setup-maybe-ref" / BindingTypes.SETUP_MAYBE_REF /); if (fromMaybeRef) { return fromMaybeRef; } } // hoist static sub-trees out function genStatic(el, state) { el.staticProcessed = true; // Some elements (templates) need to behave differently inside of a v-pre // node. All pre nodes are static roots, so we can use this as a location to // wrap a state change and reset it upon exiting the pre node. const originalPreState = state.pre; if (el.pre) { state.pre = el.pre; } state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`); state.pre = originalPreState; return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`; } // v-once function genOnce(el, state) { el.onceProcessed = true; if (el.if && !el.ifProcessed) { return genIf(el, state); } else if (el.staticInFor) { let key = ''; let parent = el.parent; while (parent) { if (parent.for) { key = parent.key; break; } parent = parent.parent; } if (!key) { process.env.NODE_ENV !== 'production' && state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']); return genElement(el, state); } return `_o(${genElement(el, state)},${state.onceId++},${key})`; } else { return genStatic(el, state); } } function genIf(el, state, altGen, altEmpty) { el.ifProcessed = true; // avoid recursion return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty); } function genIfConditions(conditions, state, altGen, altEmpty) { if (!conditions.length) { return altEmpty \|\| '_e()'; } const condition = conditions.shift(); if (condition.exp) { return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`; } else { return `${genTernaryExp(condition.block)}`; } // v-if with v-once should generate code like (a)?_m(0):_m(1) function genTernaryExp(el) { return altGen ? altGen(el, state) : el.once ? genOnce(el, state) : genElement(el, state); } } function genFor(el, state, altGen, altHelper) { const exp = el.for; const alias = el.alias; const iterator1 = el.iterator1 ? `,${el.iterator1}` : ''; const iterator2 = el.iterator2 ? `,${el.iterator2}` : ''; if (process.env.NODE_ENV !== 'production' && state.maybeComponent(el) && el.tag !== 'slot' && el.tag !== 'template' && !el.key) { state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` + `v-for should have explicit keys. ` + `See https://v2.vuejs.org/v2/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true / tip /); } el.forProcessed = true; // avoid recursion return (`${altHelper \|\| '_l'}((${exp}),` + `function(${alias}${iterator1}${iterator2}){` + `return ${(altGen \|\| genElement)(el, state)}` + '})'); } function genData(el, state) { let data = '{'; // directives first. // directives may mutate the el's other properties before they are generated. const dirs = genDirectives(el, state); if (dirs) data += dirs + ','; // key if (el.key) { data += `key:${el.key},`; } // ref if (el.ref) { data += `ref:${el.ref},`; } if (el.refInFor) { data += `refInFor:true,`; } // pre if (el.pre) { data += `pre:true,`; } // record original tag name for components using "is" attribute if (el.component) { data += `tag:"${el.tag}",`; } // module data generation functions for (let i = 0; i < state.dataGenFns.length; i++) { data += state.dataGenFns[i](el); } // attributes if (el.attrs) { data += `attrs:${genProps(el.attrs)},`; } // DOM props if (el.props) { data += `domProps:${genProps(el.props)},`; } // event handlers if (el.events) { data += `${genHandlers(el.events, false)},`; } if (el.nativeEvents) { data += `${genHandlers(el.nativeEvents, true)},`; } // slot target // only for non-scoped slots if (el.slotTarget && !el.slotScope) { data += `slot:${el.slotTarget},`; } // scoped slots if (el.scopedSlots) { data += `${genScopedSlots(el, el.scopedSlots, state)},`; } // component v-model if (el.model) { data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`; } // inline-template if (el.inlineTemplate) { const inlineTemplate = genInlineTemplate(el, state); if (inlineTemplate) { data += `${inlineTemplate},`; } } data = data.replace(/,$/, '') + '}'; // v-bind dynamic argument wrap // v-bind with dynamic arguments must be applied using the same v-bind object // merge helper so that class/style/mustUseProp attrs are handled correctly. if (el.dynamicAttrs) { data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`; } // v-bind data wrap if (el.wrapData) { data = el.wrapData(data); } // v-on data wrap if (el.wrapListeners) { data = el.wrapListeners(data); } return data; } function genDirectives(el, state) { const dirs = el.directives; if (!dirs) return; let res = 'directives:['; let hasRuntime = false; let i, l, dir, needRuntime; for (i = 0, l = dirs.length; i < l; i++) { dir = dirs[i]; needRuntime = true; const gen = state.directives[dir.name]; if (gen) { // compile-time directive that manipulates AST. // returns true if it also needs a runtime counterpart. needRuntime = !!gen(el, dir, state.warn); } if (needRuntime) { hasRuntime = true; res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}` : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`; } } if (hasRuntime) { return res.slice(0, -1) + ']'; } } function genInlineTemplate(el, state) { const ast = el.children[0]; if (process.env.NODE_ENV !== 'production' && (el.children.length !== 1 \|\| ast.type !== 1)) { state.warn('Inline-template components must have exactly one child element.', { start: el.start }); } if (ast && ast.type === 1) { const inlineRenderFns = generate$1(ast, state.options); return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns .map(code => `function(){${code}}`) .join(',')}]}`; } } function genScopedSlots(el, slots, state) { // by default scoped slots are considered "stable", this allows child // components with only scoped slots to skip forced updates from parent. // but in some cases we have to bail-out of this optimization // for example if the slot contains dynamic names, has v-if or v-for on them... let needsForceUpdate = el.for \|\| Object.keys(slots).some(key => { const slot = slots[key]; return (slot.slotTargetDynamic \|\| slot.if \|\| slot.for \|\| containsSlotChild(slot) // is passing down slot from parent which may be dynamic ); }); // #9534: if a component with scoped slots is inside a conditional branch, // it's possible for the same component to be reused but with different // compiled slot content. To avoid that, we generate a unique key based on // the generated code of all the slot contents. let needsKey = !!el.if; // OR when it is inside another scoped slot or v-for (the reactivity may be // disconnected due to the intermediate scope variable) // #9438, #9506 // TODO: this can be further optimized by properly analyzing in-scope bindings // and skip force updating ones that do not actually use scope variables. if (!needsForceUpdate) { let parent = el.parent; while (parent) { if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) \|\| parent.for) { needsForceUpdate = true; break; } if (parent.if) { needsKey = true; } parent = parent.parent; } } const generatedSlots = Object.keys(slots) .map(key => genScopedSlot(slots[key], state)) .join(','); return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`; } function hash(str) { let hash = 5381; let i = str.length; while (i) { hash = (hash 33) ^ str.charCodeAt(--i); } return hash >>> 0; } function containsSlotChild(el) { if (el.type === 1) { if (el.tag === 'slot') { return true; } return el.children.some(containsSlotChild); } return false; } function genScopedSlot(el, state) { const isLegacySyntax = el.attrsMap['slot-scope']; if (el.if && !el.ifProcessed && !isLegacySyntax) { return genIf(el, state, genScopedSlot, `null`); } if (el.for && !el.forProcessed) { return genFor(el, state, genScopedSlot); } const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope); const fn = `function(${slotScope}){` + `return ${el.tag === 'template' ? el.if && isLegacySyntax ? `(${el.if})?${genChildren(el, state) \|\| 'undefined'}:undefined` : genChildren(el, state) \|\| 'undefined' : genElement(el, state)}}`; // reverse proxy v-slot without scope on this.$slots const reverseProxy = slotScope ? `` : `,proxy:true`; return `{key:${el.slotTarget \|\| `"default"`},fn:${fn}${reverseProxy}}`; } function genChildren(el, state, checkSkip, altGenElement, altGenNode) { const children = el.children; if (children.length) { const el = children[0]; // optimize single v-for if (children.length === 1 && el.for && el.tag !== 'template' && el.tag !== 'slot') { const normalizationType = checkSkip ? state.maybeComponent(el) ? `,1` : `,0` : ``; return `${(altGenElement \|\| genElement)(el, state)}${normalizationType}`; } const normalizationType = checkSkip ? getNormalizationType(children, state.maybeComponent) : 0; const gen = altGenNode \|\| genNode; return `[${children.map(c => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`; } } // determine the normalization needed for the children array. // 0: no normalization needed // 1: simple normalization needed (possible 1-level deep nested array) // 2: full normalization needed function getNormalizationType(children, maybeComponent) { let res = 0; for (let i = 0; i < children.length; i++) { const el = children[i]; if (el.type !== 1) { continue; } if (needsNormalization(el) \|\| (el.ifConditions && el.ifConditions.some(c => needsNormalization(c.block)))) { res = 2; break; } if (maybeComponent(el) \|\| (el.ifConditions && el.ifConditions.some(c => maybeComponent(c.block)))) { res = 1; } } return res; } function needsNormalization(el) { return el.for !== undefined \|\| el.tag === 'template' \|\| el.tag === 'slot'; } function genNode(node, state) { if (node.type === 1) { return genElement(node, state); } else if (node.type === 3 && node.isComment) { return genComment(node); } else { return genText(node); } } function genText(text) { return `_v(${text.type === 2 ? text.expression // no need for () because already wrapped in _s() : transformSpecialNewlines(JSON.stringify(text.text))})`; } function genComment(comment) { return `_e(${JSON.stringify(comment.text)})`; } function genSlot(el, state) { const slotName = el.slotName \|\| '"default"'; const children = genChildren(el, state); let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`; const attrs = el.attrs \|\| el.dynamicAttrs ? genProps((el.attrs \|\| []).concat(el.dynamicAttrs \|\| []).map(attr => ({ // slot props are camelized name: camelize(attr.name), value: attr.value, dynamic: attr.dynamic }))) : null; const bind = el.attrsMap['v-bind']; if ((attrs \|\| bind) && !children) { res += `,null`; } if (attrs) { res += `,${attrs}`; } if (bind) { res += `${attrs ? '' : ',null'},${bind}`; } return res + ')'; } // componentName is el.component, take it as argument to shun flow's pessimistic refinement function genComponent(componentName, el, state) { const children = el.inlineTemplate ? null : genChildren(el, state, true); return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`; } function genProps(props) { let staticProps = ``; let dynamicProps = ``; for (let i = 0; i < props.length; i++) { const prop = props[i]; const value = transformSpecialNewlines(prop.value); if (prop.dynamic) { dynamicProps += `${prop.name},${value},`; } else { staticProps += `"${prop.name}":${value},`; } } staticProps = `{${staticProps.slice(0, -1)}}`; if (dynamicProps) { return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`; } else { return staticProps; } } // #3895, #4268 function transformSpecialNewlines(text) { return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029'); } // these keywords should not appear inside expressions, but operators like // typeof, instanceof and in are allowed const prohibitedKeywordRE = new RegExp('\\b' + ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' + 'super,throw,while,yield,delete,export,import,return,switch,default,' + 'extends,finally,continue,debugger,function,arguments') .split(',') .join('\\b\|\\b') + '\\b'); // these unary operators should not be used as property/method names const unaryOperatorsRE = new RegExp('\\b' + 'delete,typeof,void'.split(',').join('\\s\$[^\$]\\)\|\\b') + '\\s\$[^\$]\\)'); // strip strings in expressions const stripStringRE = /'(?:[^'\\]\|\\.)'\|"(?:[^"\\]\|\\.)"\|`(?:[^`\\]\|\\.)\$\{\|\}(?:[^`\\]\|\\.)`\|`(?:[^`\\]\|\\.)`/g; // detect problematic expressions in a template function detectErrors(ast, warn) { if (ast) { checkNode(ast, warn); } } function checkNode(node, warn) { if (node.type === 1) { for (const name in node.attrsMap) { if (dirRE.test(name)) { const value = node.attrsMap[name]; if (value) { const range = node.rawAttrsMap[name]; if (name === 'v-for') { checkFor(node, `v-for="${value}"`, warn, range); } else if (name === 'v-slot' \|\| name[0] === '#') { checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range); } else if (onRE.test(name)) { checkEvent(value, `${name}="${value}"`, warn, range); } else { checkExpression(value, `${name}="${value}"`, warn, range); } } } } if (node.children) { for (let i = 0; i < node.children.length; i++) { checkNode(node.children[i], warn); } } } else if (node.type === 2) { checkExpression(node.expression, node.text, warn, node); } } function checkEvent(exp, text, warn, range) { const stripped = exp.replace(stripStringRE, ''); const keywordMatch = stripped.match(unaryOperatorsRE); if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') { warn(`avoid using JavaScript unary operator as property name: ` + `"${keywordMatch[0]}" in expression ${text.trim()}`, range); } checkExpression(exp, text, warn, range); } function checkFor(node, text, warn, range) { checkExpression(node.for \|\| '', text, warn, range); checkIdentifier(node.alias, 'v-for alias', text, warn, range); checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range); checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range); } function checkIdentifier(ident, type, text, warn, range) { if (typeof ident === 'string') { try { new Function(`var ${ident}=_`); } catch (e) { warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range); } } } function checkExpression(exp, text, warn, range) { try { new Function(`return ${exp}`); } catch (e) { const keywordMatch = exp .replace(stripStringRE, '') .match(prohibitedKeywordRE); if (keywordMatch) { warn(`avoid using JavaScript keyword as property name: ` + `"${keywordMatch[0]}"\n Raw expression: ${text.trim()}`, range); } else { warn(`invalid expression: ${e.message} in\n\n` + ` ${exp}\n\n` + ` Raw expression: ${text.trim()}\n`, range); } } } function checkFunctionParameterExpression(exp, text, warn, range) { try { new Function(exp, ''); } catch (e) { warn(`invalid function parameter expression: ${e.message} in\n\n` + ` ${exp}\n\n` + ` Raw expression: ${text.trim()}\n`, range); } } function createFunction(code, errors) { try { return new Function(code); } catch (err) { errors.push({ err, code }); return noop; } } function createCompileToFunctionFn(compile) { const cache = Object.create(null); return function compileToFunctions(template, options, vm) { options = extend({}, options); const warn = options.warn \|\| warn$3; delete options.warn; / istanbul ignore if / if (process.env.NODE_ENV !== 'production') { // detect possible CSP restriction try { new Function('return 1'); } catch (e) { if (e.toString().match(/unsafe-eval\|CSP/)) { warn('It seems you are using the standalone build of Vue.js in an ' + 'environment with Content Security Policy that prohibits unsafe-eval. ' + 'The template compiler cannot work in this environment. Consider ' + 'relaxing the policy to allow unsafe-eval or pre-compiling your ' + 'templates into render functions.'); } } } // check cache const key = options.delimiters ? String(options.delimiters) + template : template; if (cache[key]) { return cache[key]; } // compile const compiled = compile(template, options); // check compilation errors/tips if (process.env.NODE_ENV !== 'production') { if (compiled.errors && compiled.errors.length) { if (options.outputSourceRange) { compiled.errors.forEach(e => { warn(`Error compiling template:\n\n${e.msg}\n\n` + generateCodeFrame(template, e.start, e.end), vm); }); } else { warn(`Error compiling template:\n\n${template}\n\n` + compiled.errors.map(e => `- ${e}`).join('\n') + '\n', vm); } } if (compiled.tips && compiled.tips.length) { if (options.outputSourceRange) { compiled.tips.forEach(e => tip(e.msg, vm)); } else { compiled.tips.forEach(msg => tip(msg, vm)); } } } // turn code into functions const res = {}; const fnGenErrors = []; res.render = createFunction(compiled.render, fnGenErrors); res.staticRenderFns = compiled.staticRenderFns.map(code => { return createFunction(code, fnGenErrors); }); // check function generation errors. // this should only happen if there is a bug in the compiler itself. // mostly for codegen development use / istanbul ignore if / if (process.env.NODE_ENV !== 'production') { if ((!compiled.errors \|\| !compiled.errors.length) && fnGenErrors.length) { warn(`Failed to generate render function:\n\n` + fnGenErrors .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`) .join('\n'), vm); } } return (cache[key] = res); }; } function createCompilerCreator(baseCompile) { return function createCompiler(baseOptions) { function compile(template, options) { const finalOptions = Object.create(baseOptions); const errors = []; const tips = []; let warn = (msg, range, tip) => { (tip ? tips : errors).push(msg); }; if (options) { if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) { // $flow-disable-line const leadingSpaceLength = template.match(/^\s/)[0].length; warn = (msg, range, tip) => { const data = typeof msg === 'string' ? { msg } : msg; if (range) { if (range.start != null) { data.start = range.start + leadingSpaceLength; } if (range.end != null) { data.end = range.end + leadingSpaceLength; } } (tip ? tips : errors).push(data); }; } // merge custom modules if (options.modules) { finalOptions.modules = (baseOptions.modules \|\| []).concat(options.modules); } // merge custom directives if (options.directives) { finalOptions.directives = extend(Object.create(baseOptions.directives \|\| null), options.directives); } // copy other options for (const key in options) { if (key !== 'modules' && key !== 'directives') { finalOptions[key] = options[key]; } } } finalOptions.warn = warn; const compiled = baseCompile(template.trim(), finalOptions); if (process.env.NODE_ENV !== 'production') { detectErrors(compiled.ast, warn); } compiled.errors = errors; compiled.tips = tips; return compiled; } return { compile, compileToFunctions: createCompileToFunctionFn(compile) }; }; } // `createCompilerCreator` allows creating compilers that use alternative // parser/optimizer/codegen, e.g the SSR optimizing compiler. // Here we just export a default compiler using the default parts. const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) { const ast = parse$1(template.trim(), options); if (options.optimize !== false) { optimize$1(ast, options); } const code = generate$1(ast, options); return { ast, render: code.render, staticRenderFns: code.staticRenderFns }; }); const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions); const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' + 'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' + 'checked,cite,class,code,codebase,color,cols,colspan,content,' + 'contenteditable,contextmenu,controls,coords,data,datetime,default,' + 'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' + 'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' + 'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' + 'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' + 'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' + 'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' + 'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' + 'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' + 'target,title,usemap,value,width,wrap'); /* istanbul ignore next / const isRenderableAttr = (name) => { return (isAttr(name) \|\| name.indexOf('data-') === 0 \|\| name.indexOf('aria-') === 0); }; const propsToAttrMap = { acceptCharset: 'accept-charset', className: 'class', htmlFor: 'for', httpEquiv: 'http-equiv' }; const ESC = { '<': '<', '>': '>', '"': '"', '&': '&' }; function escape(s) { return s.replace(/[<>"&]/g, escapeChar); } function escapeChar(a) { return ESC[a] \|\| a; } const plainStringRE = /^"(?:[^"\\]\|\\.)"$\|^'(?:[^'\\]\|\\.)'$/; // let the model AST transform translate v-model into appropriate // props bindings function applyModelTransform(el, state) { if (el.directives) { for (let i = 0; i < el.directives.length; i++) { const dir = el.directives[i]; if (dir.name === 'model') { state.directives.model(el, dir, state.warn); // remove value for textarea as its converted to text if (el.tag === 'textarea' && el.props) { el.props = el.props.filter(p => p.name !== 'value'); } break; } } } } function genAttrSegments(attrs) { return attrs.map(({ name, value }) => genAttrSegment(name, value)); } function genDOMPropSegments(props, attrs) { const segments = []; props.forEach(({ name, value }) => { name = propsToAttrMap[name] \|\| name.toLowerCase(); if (isRenderableAttr(name) && !(attrs && attrs.some(a => a.name === name))) { segments.push(genAttrSegment(name, value)); } }); return segments; } function genAttrSegment(name, value) { if (plainStringRE.test(value)) { // force double quote value = value.replace(/^'\|'$/g, '"'); // force enumerated attr to "true" if (isEnumeratedAttr(name) && value !== `"false"`) { value = `"true"`; } return { type: RAW, value: isBooleanAttr(name) ? ` ${name}="${name}"` : value === '""' ? ` ${name}` : ` ${name}="${JSON.parse(value)}"` }; } else { return { type: EXPRESSION, value: `_ssrAttr(${JSON.stringify(name)},${value})` }; } } function genClassSegments(staticClass, classBinding) { if (staticClass && !classBinding) { return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }]; } else { return [ { type: EXPRESSION, value: `_ssrClass(${staticClass \|\| 'null'},${classBinding \|\| 'null'})` } ]; } } function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) { if (staticStyle && !styleBinding && !vShowExpression) { return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }]; } else { return [ { type: EXPRESSION, value: `_ssrStyle(${parsedStaticStyle \|\| 'null'},${styleBinding \|\| 'null'}, ${vShowExpression ? `{ display: (${vShowExpression}) ? '' : 'none' }` : 'null'})` } ]; } } /* * In SSR, the vdom tree is generated only once and never patched, so * we can optimize most element / trees into plain string render functions. * The SSR optimizer walks the AST tree to detect optimizable elements and trees. * * The criteria for SSR optimizability is quite a bit looser than static tree * detection (which is designed for client re-render). In SSR we bail only for * components/slots/custom directives. / // optimizability constants const optimizability = { FALSE: 0, FULL: 1, SELF: 2, CHILDREN: 3, PARTIAL: 4 // self un-optimizable with some un-optimizable children }; let isPlatformReservedTag; function optimize(root, options) { if (!root) return; isPlatformReservedTag = options.isReservedTag \|\| no; walk(root, true); } function walk(node, isRoot) { if (isUnOptimizableTree(node)) { node.ssrOptimizability = optimizability.FALSE; return; } // root node or nodes with custom directives should always be a VNode const selfUnoptimizable = isRoot \|\| hasCustomDirective(node); const check = child => { if (child.ssrOptimizability !== optimizability.FULL) { node.ssrOptimizability = selfUnoptimizable ? optimizability.PARTIAL : optimizability.SELF; } }; if (selfUnoptimizable) { node.ssrOptimizability = optimizability.CHILDREN; } if (node.type === 1) { for (let i = 0, l = node.children.length; i < l; i++) { const child = node.children[i]; walk(child); check(child); } if (node.ifConditions) { for (let i = 1, l = node.ifConditions.length; i < l; i++) { const block = node.ifConditions[i].block; walk(block, isRoot); check(block); } } if (node.ssrOptimizability == null \|\| (!isRoot && (node.attrsMap['v-html'] \|\| node.attrsMap['v-text']))) { node.ssrOptimizability = optimizability.FULL; } else { node.children = optimizeSiblings(node); } } else { node.ssrOptimizability = optimizability.FULL; } } function optimizeSiblings(el) { const children = el.children; const optimizedChildren = []; let currentOptimizableGroup = []; const pushGroup = () => { if (currentOptimizableGroup.length) { optimizedChildren.push({ type: 1, parent: el, tag: 'template', attrsList: [], attrsMap: {}, rawAttrsMap: {}, children: currentOptimizableGroup, ssrOptimizability: optimizability.FULL }); } currentOptimizableGroup = []; }; for (let i = 0; i < children.length; i++) { const c = children[i]; if (c.ssrOptimizability === optimizability.FULL) { currentOptimizableGroup.push(c); } else { // wrap fully-optimizable adjacent siblings inside a template tag // so that they can be optimized into a single ssrNode by codegen pushGroup(); optimizedChildren.push(c); } } pushGroup(); return optimizedChildren; } function isUnOptimizableTree(node) { if (node.type === 2 \|\| node.type === 3) { // text or expression return false; } return (isBuiltInTag(node.tag) \|\| // built-in (slot, component) !isPlatformReservedTag(node.tag) \|\| // custom component !!node.component \|\| // "is" component isSelectWithModel(node) // <select v-model> requires runtime inspection ); } const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once'); function hasCustomDirective(node) { return (node.type === 1 && node.directives && node.directives.some(d => !isBuiltInDir(d.name))); } // <select v-model> cannot be optimized because it requires a runtime check // to determine proper selected option function isSelectWithModel(node) { return (node.type === 1 && node.tag === 'select' && node.directives != null && node.directives.some(d => d.name === 'model')); } // The SSR codegen is essentially extending the default codegen to handle // segment types const RAW = 0; const INTERPOLATION = 1; const EXPRESSION = 2; function generate(ast, options) { const state = new CodegenState(options); const code = ast ? genSSRElement(ast, state) : '_c("div")'; return { render: `with(this){return ${code}}`, staticRenderFns: state.staticRenderFns }; } function genSSRElement(el, state) { if (el.for && !el.forProcessed) { return genFor(el, state, genSSRElement); } else if (el.if && !el.ifProcessed) { return genIf(el, state, genSSRElement); } else if (el.tag === 'template' && !el.slotTarget) { return el.ssrOptimizability === optimizability.FULL ? genChildrenAsStringNode(el, state) : genSSRChildren(el, state) \|\| 'void 0'; } switch (el.ssrOptimizability) { case optimizability.FULL: // stringify whole tree return genStringElement(el, state); case optimizability.SELF: // stringify self and check children return genStringElementWithChildren(el, state); case optimizability.CHILDREN: // generate self as VNode and stringify children return genNormalElement(el, state, true); case optimizability.PARTIAL: // generate self as VNode and check children return genNormalElement(el, state, false); default: // bail whole tree return genElement(el, state); } } function genNormalElement(el, state, stringifyChildren) { const data = el.plain ? undefined : genData(el, state); const children = stringifyChildren ? `[${genChildrenAsStringNode(el, state)}]` : genSSRChildren(el, state, true); return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`; } function genSSRChildren(el, state, checkSkip) { return genChildren(el, state, checkSkip, genSSRElement, genSSRNode); } function genSSRNode(el, state) { return el.type === 1 ? genSSRElement(el, state) : genText(el); } function genChildrenAsStringNode(el, state) { return el.children.length ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})` : ''; } function genStringElement(el, state) { return `_ssrNode(${elementToString(el, state)})`; } function genStringElementWithChildren(el, state) { const children = genSSRChildren(el, state, true); return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`; } function elementToString(el, state) { return `(${flattenSegments(elementToSegments(el, state))})`; } function elementToSegments(el, state) { // v-for / v-if if (el.for && !el.forProcessed) { el.forProcessed = true; return [ { type: EXPRESSION, value: genFor(el, state, elementToString, '_ssrList') } ]; } else if (el.if && !el.ifProcessed) { el.ifProcessed = true; return [ { type: EXPRESSION, value: genIf(el, state, elementToString, '"<!---->"') } ]; } else if (el.tag === 'template') { return childrenToSegments(el, state); } const openSegments = elementToOpenTagSegments(el, state); const childrenSegments = childrenToSegments(el, state); const { isUnaryTag } = state.options; const close = isUnaryTag && isUnaryTag(el.tag) ? [] : [{ type: RAW, value: `</${el.tag}>` }]; return openSegments.concat(childrenSegments, close); } function elementToOpenTagSegments(el, state) { applyModelTransform(el, state); let binding; const segments = [{ type: RAW, value: `<${el.tag}` }]; // attrs if (el.attrs) { segments.push.apply(segments, genAttrSegments(el.attrs)); } // domProps if (el.props) { segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs)); } // v-bind="object" if ((binding = el.attrsMap['v-bind'])) { segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` }); } // v-bind.prop="object" if ((binding = el.attrsMap['v-bind.prop'])) { segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` }); } // class if (el.staticClass \|\| el.classBinding) { segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding)); } // style & v-show if (el.staticStyle \|\| el.styleBinding \|\| el.attrsMap['v-show']) { segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show'])); } // _scopedId if (state.options.scopeId) { segments.push({ type: RAW, value: ` ${state.options.scopeId}` }); } segments.push({ type: RAW, value: `>` }); return segments; } function childrenToSegments(el, state) { let binding; if ((binding = el.attrsMap['v-html'])) { return [{ type: EXPRESSION, value: `_s(${binding})` }]; } if ((binding = el.attrsMap['v-text'])) { return [{ type: INTERPOLATION, value: `_s(${binding})` }]; } if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) { return [{ type: INTERPOLATION, value: `_s(${binding})` }]; } return el.children ? nodesToSegments(el.children, state) : []; } function nodesToSegments(children, state) { const segments = []; for (let i = 0; i < children.length; i++) { const c = children[i]; if (c.type === 1) { segments.push.apply(segments, elementToSegments(c, state)); } else if (c.type === 2) { segments.push({ type: INTERPOLATION, value: c.expression }); } else if (c.type === 3) { let text = escape(c.text); if (c.isComment) { text = '<!--' + text + '-->'; } segments.push({ type: RAW, value: text }); } } return segments; } function flattenSegments(segments) { const mergedSegments = []; let textBuffer = ''; const pushBuffer = () => { if (textBuffer) { mergedSegments.push(JSON.stringify(textBuffer)); textBuffer = ''; } }; for (let i = 0; i < segments.length; i++) { const s = segments[i]; if (s.type === RAW) { textBuffer += s.value; } else if (s.type === INTERPOLATION) { pushBuffer(); mergedSegments.push(`_ssrEscape(${s.value})`); } else if (s.type === EXPRESSION) { pushBuffer(); mergedSegments.push(`(${s.value})`); } } pushBuffer(); return mergedSegments.join('+'); } const createCompiler = createCompilerCreator(function baseCompile(template, options) { const ast = parse$1(template.trim(), options); optimize(ast, options); const code = generate(ast, options); return { ast, render: code.render, staticRenderFns: code.staticRenderFns }; }); const { compile, compileToFunctions } = createCompiler(baseOptions); var _compiler = /#__PURE__/Object.freeze({ __proto__: null, parseComponent: parseComponent, compile: compile$1, compileToFunctions: compileToFunctions$1, ssrCompile: compile, ssrCompileToFunctions: compileToFunctions, generateCodeFrame: generateCodeFrame }); function compileTemplate(options) { const { preprocessLang } = options; const preprocessor = preprocessLang && consolidate[preprocessLang]; if (preprocessor) { return actuallyCompile(Object.assign({}, options, { source: preprocess$1(options, preprocessor) })); } else if (preprocessLang) { return { ast: {}, code: `var render = function () {}\n` + `var staticRenderFns = []\n`, source: options.source, tips: [ `Component ${options.filename} uses lang ${preprocessLang} for template. Please install the language preprocessor.` ], errors: [ `Component ${options.filename} uses lang ${preprocessLang} for template, however it is not installed.` ] }; } else { return actuallyCompile(options); } } function preprocess$1(options, preprocessor) { const { source, filename, preprocessOptions } = options; const finalPreprocessOptions = Object.assign({ filename }, preprocessOptions); // Consolidate exposes a callback based API, but the callback is in fact // called synchronously for most templating engines. In our case, we have to // expose a synchronous API so that it is usable in Jest transforms (which // have to be sync because they are applied via Node.js require hooks) let res, err; preprocessor.render(source, finalPreprocessOptions, (_err, _res) => { if (_err) err = _err; res = _res; }); if (err) throw err; return res; } function actuallyCompile(options) { const { source, compiler = _compiler, compilerOptions = {}, transpileOptions = {}, transformAssetUrls, transformAssetUrlsOptions, isProduction = process.env.NODE_ENV === 'production', isFunctional = false, optimizeSSR = false, prettify = true, isTS = false, bindings } = options; const compile = optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile; let finalCompilerOptions = compilerOptions; if (transformAssetUrls) { const builtInModules = [ transformAssetUrls === true ? assetUrlsModule(undefined, transformAssetUrlsOptions) : assetUrlsModule(transformAssetUrls, transformAssetUrlsOptions), srcsetModule(transformAssetUrlsOptions) ]; finalCompilerOptions = Object.assign({}, compilerOptions, { modules: [...builtInModules, ...(compilerOptions.modules \|\| [])], filename: options.filename }); } finalCompilerOptions.bindings = bindings; const { ast, render, staticRenderFns, tips, errors } = compile(source, finalCompilerOptions); if (errors && errors.length) { return { ast, code: `var render = function () {}\n` + `var staticRenderFns = []\n`, source, tips, errors }; } else { // stripping `with` usage let code = `var __render__ = ${prefixIdentifiers(`function render(${isFunctional ? `_c,_vm` : ``}){${render}\n}`, isFunctional, isTS, transpileOptions, bindings)}\n` + `var __staticRenderFns__ = [${staticRenderFns.map(code => prefixIdentifiers(`function (${isFunctional ? `_c,_vm` : ``}){${code}\n}`, isFunctional, isTS, transpileOptions, bindings))}]` + `\n`; // #23 we use __render__ to avoid `render` not being prefixed by the // transpiler when stripping with, but revert it back to `render` to // maintain backwards compat code = code.replace(/\s__(render\|staticRenderFns)__\s/g, ' $1 '); if (!isProduction) { // mark with stripped (this enables Vue to use correct runtime proxy // detection) code += `render._withStripped = true`; if (prettify) { try { code = require('prettier').format(code, { semi: false, parser: 'babel' }); } catch (e) { if (e.code === 'MODULE_NOT_FOUND') { tips.push('The `prettify` option is on, but the dependency `prettier` is not found.\n' + 'Please either turn off `prettify` or manually install `prettier`.'); } tips.push(`Failed to prettify component ${options.filename} template source after compilation.`); } } } return { ast, code, source, tips, errors }; } } const trimPlugin = () => { return { postcssPlugin: 'vue-sfc-trim', Once(root) { root.walk(({ type, raws }) => { if (type === 'rule' \|\| type === 'atrule') { if (raws.before) raws.before = '\n'; if ('after' in raws && raws.after) raws.after = '\n'; } }); } }; }; trimPlugin.postcss = true; var dist = {exports: {}}; var processor = {exports: {}}; var parser = {exports: {}}; var root$1 = {exports: {}}; var container = {exports: {}}; var node$1 = {exports: {}}; var util = {}; var unesc = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = unesc; // Many thanks for this post which made this migration much easier. // https://mathiasbynens.be/notes/css-escapes /* * * @param {string} str * @returns {[string, number]\|undefined} / function gobbleHex(str) { var lower = str.toLowerCase(); var hex = ''; var spaceTerminated = false; for (var i = 0; i < 6 && lower[i] !== undefined; i++) { var code = lower.charCodeAt(i); // check to see if we are dealing with a valid hex char [a-f\|0-9] var valid = code >= 97 && code <= 102 \|\| code >= 48 && code <= 57; // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point spaceTerminated = code === 32; if (!valid) { break; } hex += lower[i]; } if (hex.length === 0) { return undefined; } var codePoint = parseInt(hex, 16); var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF; // Add special case for // "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point" // https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point if (isSurrogate \|\| codePoint === 0x0000 \|\| codePoint > 0x10FFFF) { return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)]; } return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)]; } var CONTAINS_ESCAPE = /\\/; function unesc(str) { var needToProcess = CONTAINS_ESCAPE.test(str); if (!needToProcess) { return str; } var ret = ""; for (var i = 0; i < str.length; i++) { if (str[i] === "\\") { var gobbled = gobbleHex(str.slice(i + 1, i + 7)); if (gobbled !== undefined) { ret += gobbled[0]; i += gobbled[1]; continue; } // Retain a pair of \\ if double escaped `\\\\` // https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e if (str[i + 1] === "\\") { ret += "\\"; i++; continue; } // if \\ is at the end of the string retain it // https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb if (str.length === i + 1) { ret += str[i]; } continue; } ret += str[i]; } return ret; } module.exports = exports.default; } (unesc, unesc.exports)); var getProp = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = getProp; function getProp(obj) { for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { props[_key - 1] = arguments[_key]; } while (props.length > 0) { var prop = props.shift(); if (!obj[prop]) { return undefined; } obj = obj[prop]; } return obj; } module.exports = exports.default; } (getProp, getProp.exports)); var ensureObject = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = ensureObject; function ensureObject(obj) { for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { props[_key - 1] = arguments[_key]; } while (props.length > 0) { var prop = props.shift(); if (!obj[prop]) { obj[prop] = {}; } obj = obj[prop]; } } module.exports = exports.default; } (ensureObject, ensureObject.exports)); var stripComments = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = stripComments; function stripComments(str) { var s = ""; var commentStart = str.indexOf("/"); var lastEnd = 0; while (commentStart >= 0) { s = s + str.slice(lastEnd, commentStart); var commentEnd = str.indexOf("/", commentStart + 2); if (commentEnd < 0) { return s; } lastEnd = commentEnd + 2; commentStart = str.indexOf("/", lastEnd); } s = s + str.slice(lastEnd); return s; } module.exports = exports.default; } (stripComments, stripComments.exports)); util.__esModule = true; util.stripComments = util.ensureObject = util.getProp = util.unesc = void 0; var _unesc = _interopRequireDefault$1(unesc.exports); util.unesc = _unesc["default"]; var _getProp = _interopRequireDefault$1(getProp.exports); util.getProp = _getProp["default"]; var _ensureObject = _interopRequireDefault$1(ensureObject.exports); util.ensureObject = _ensureObject["default"]; var _stripComments = _interopRequireDefault$1(stripComments.exports); util.stripComments = _stripComments["default"]; function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _util = util; function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } var cloneNode = function cloneNode(obj, parent) { if (typeof obj !== 'object' \|\| obj === null) { return obj; } var cloned = new obj.constructor(); for (var i in obj) { if (!obj.hasOwnProperty(i)) { continue; } var value = obj[i]; var type = typeof value; if (i === 'parent' && type === 'object') { if (parent) { cloned[i] = parent; } } else if (value instanceof Array) { cloned[i] = value.map(function (j) { return cloneNode(j, cloned); }); } else { cloned[i] = cloneNode(value, cloned); } } return cloned; }; var Node = /#__PURE__/function () { function Node(opts) { if (opts === void 0) { opts = {}; } Object.assign(this, opts); this.spaces = this.spaces \|\| {}; this.spaces.before = this.spaces.before \|\| ''; this.spaces.after = this.spaces.after \|\| ''; } var _proto = Node.prototype; _proto.remove = function remove() { if (this.parent) { this.parent.removeChild(this); } this.parent = undefined; return this; }; _proto.replaceWith = function replaceWith() { if (this.parent) { for (var index in arguments) { this.parent.insertBefore(this, arguments[index]); } this.remove(); } return this; }; _proto.next = function next() { return this.parent.at(this.parent.index(this) + 1); }; _proto.prev = function prev() { return this.parent.at(this.parent.index(this) - 1); }; _proto.clone = function clone(overrides) { if (overrides === void 0) { overrides = {}; } var cloned = cloneNode(this); for (var name in overrides) { cloned[name] = overrides[name]; } return cloned; } /** * Some non-standard syntax doesn't follow normal escaping rules for css. * This allows non standard syntax to be appended to an existing property * by specifying the escaped value. By specifying the escaped value, * illegal characters are allowed to be directly inserted into css output. * @param {string} name the property to set * @param {any} value the unescaped value of the property * @param {string} valueEscaped optional. the escaped value of the property. / ; _proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) { if (!this.raws) { this.raws = {}; } var originalValue = this[name]; var originalEscaped = this.raws[name]; this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first. if (originalEscaped \|\| valueEscaped !== value) { this.raws[name] = (originalEscaped \|\| originalValue) + valueEscaped; } else { delete this.raws[name]; // delete any escaped value that was created by the setter. } } /* * Some non-standard syntax doesn't follow normal escaping rules for css. * This allows the escaped value to be specified directly, allowing illegal * characters to be directly inserted into css output. * @param {string} name the property to set * @param {any} value the unescaped value of the property * @param {string} valueEscaped the escaped value of the property. / ; _proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) { if (!this.raws) { this.raws = {}; } this[name] = value; // this may trigger a setter that updates raws, so it has to be set first. this.raws[name] = valueEscaped; } /* * When you want a value to passed through to CSS directly. This method * deletes the corresponding raw value causing the stringifier to fallback * to the unescaped value. * @param {string} name the property to set. * @param {any} value The value that is both escaped and unescaped. / ; _proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) { this[name] = value; // this may trigger a setter that updates raws, so it has to be set first. if (this.raws) { delete this.raws[name]; } } /* * * @param {number} line The number (starting with 1) * @param {number} column The column number (starting with 1) / ; _proto.isAtPosition = function isAtPosition(line, column) { if (this.source && this.source.start && this.source.end) { if (this.source.start.line > line) { return false; } if (this.source.end.line < line) { return false; } if (this.source.start.line === line && this.source.start.column > column) { return false; } if (this.source.end.line === line && this.source.end.column < column) { return false; } return true; } return undefined; }; _proto.stringifyProperty = function stringifyProperty(name) { return this.raws && this.raws[name] \|\| this[name]; }; _proto.valueToString = function valueToString() { return String(this.stringifyProperty("value")); }; _proto.toString = function toString() { return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join(''); }; _createClass(Node, [{ key: "rawSpaceBefore", get: function get() { var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before; if (rawSpace === undefined) { rawSpace = this.spaces && this.spaces.before; } return rawSpace \|\| ""; }, set: function set(raw) { (0, _util.ensureObject)(this, "raws", "spaces"); this.raws.spaces.before = raw; } }, { key: "rawSpaceAfter", get: function get() { var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after; if (rawSpace === undefined) { rawSpace = this.spaces.after; } return rawSpace \|\| ""; }, set: function set(raw) { (0, _util.ensureObject)(this, "raws", "spaces"); this.raws.spaces.after = raw; } }]); return Node; }(); exports["default"] = Node; module.exports = exports.default; } (node$1, node$1.exports)); var types = {}; types.__esModule = true; types.UNIVERSAL = types.ATTRIBUTE = types.CLASS = types.COMBINATOR = types.COMMENT = types.ID = types.NESTING = types.PSEUDO = types.ROOT = types.SELECTOR = types.STRING = types.TAG = void 0; var TAG = 'tag'; types.TAG = TAG; var STRING = 'string'; types.STRING = STRING; var SELECTOR = 'selector'; types.SELECTOR = SELECTOR; var ROOT = 'root'; types.ROOT = ROOT; var PSEUDO = 'pseudo'; types.PSEUDO = PSEUDO; var NESTING = 'nesting'; types.NESTING = NESTING; var ID = 'id'; types.ID = ID; var COMMENT = 'comment'; types.COMMENT = COMMENT; var COMBINATOR = 'combinator'; types.COMBINATOR = COMBINATOR; var CLASS = 'class'; types.CLASS = CLASS; var ATTRIBUTE = 'attribute'; types.ATTRIBUTE = ATTRIBUTE; var UNIVERSAL = 'universal'; types.UNIVERSAL = UNIVERSAL; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _node = _interopRequireDefault(node$1.exports); var types$1 = _interopRequireWildcard(types); function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null \|\| typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get \|\| desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" \|\| o[Symbol.iterator] == null) { if (Array.isArray(o) \|\| (it = _unsupportedIterableToArray(o)) \|\| allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); } function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" \|\| n === "Set") return Array.from(o); if (n === "Arguments" \|\| /^(?:Ui\|I)nt(?:8\|16\|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } function _arrayLikeToArray(arr, len) { if (len == null \|\| len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Container = /#__PURE__/function (_Node) { _inheritsLoose(Container, _Node); function Container(opts) { var _this; _this = _Node.call(this, opts) \|\| this; if (!_this.nodes) { _this.nodes = []; } return _this; } var _proto = Container.prototype; _proto.append = function append(selector) { selector.parent = this; this.nodes.push(selector); return this; }; _proto.prepend = function prepend(selector) { selector.parent = this; this.nodes.unshift(selector); return this; }; _proto.at = function at(index) { return this.nodes[index]; }; _proto.index = function index(child) { if (typeof child === 'number') { return child; } return this.nodes.indexOf(child); }; _proto.removeChild = function removeChild(child) { child = this.index(child); this.at(child).parent = undefined; this.nodes.splice(child, 1); var index; for (var id in this.indexes) { index = this.indexes[id]; if (index >= child) { this.indexes[id] = index - 1; } } return this; }; _proto.removeAll = function removeAll() { for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) { var node = _step.value; node.parent = undefined; } this.nodes = []; return this; }; _proto.empty = function empty() { return this.removeAll(); }; _proto.insertAfter = function insertAfter(oldNode, newNode) { newNode.parent = this; var oldIndex = this.index(oldNode); this.nodes.splice(oldIndex + 1, 0, newNode); newNode.parent = this; var index; for (var id in this.indexes) { index = this.indexes[id]; if (oldIndex <= index) { this.indexes[id] = index + 1; } } return this; }; _proto.insertBefore = function insertBefore(oldNode, newNode) { newNode.parent = this; var oldIndex = this.index(oldNode); this.nodes.splice(oldIndex, 0, newNode); newNode.parent = this; var index; for (var id in this.indexes) { index = this.indexes[id]; if (index <= oldIndex) { this.indexes[id] = index + 1; } } return this; }; _proto._findChildAtPosition = function _findChildAtPosition(line, col) { var found = undefined; this.each(function (node) { if (node.atPosition) { var foundChild = node.atPosition(line, col); if (foundChild) { found = foundChild; return false; } } else if (node.isAtPosition(line, col)) { found = node; return false; } }); return found; } /* * Return the most specific node at the line and column number given. * The source location is based on the original parsed location, locations aren't * updated as selector nodes are mutated. * * Note that this location is relative to the location of the first character * of the selector, and not the location of the selector in the overall document * when used in conjunction with postcss. * * If not found, returns undefined. * @param {number} line The line number of the node to find. (1-based index) * @param {number} col The column number of the node to find. (1-based index) / ; _proto.atPosition = function atPosition(line, col) { if (this.isAtPosition(line, col)) { return this._findChildAtPosition(line, col) \|\| this; } else { return undefined; } }; _proto._inferEndPosition = function _inferEndPosition() { if (this.last && this.last.source && this.last.source.end) { this.source = this.source \|\| {}; this.source.end = this.source.end \|\| {}; Object.assign(this.source.end, this.last.source.end); } }; _proto.each = function each(callback) { if (!this.lastEach) { this.lastEach = 0; } if (!this.indexes) { this.indexes = {}; } this.lastEach++; var id = this.lastEach; this.indexes[id] = 0; if (!this.length) { return undefined; } var index, result; while (this.indexes[id] < this.length) { index = this.indexes[id]; result = callback(this.at(index), index); if (result === false) { break; } this.indexes[id] += 1; } delete this.indexes[id]; if (result === false) { return false; } }; _proto.walk = function walk(callback) { return this.each(function (node, i) { var result = callback(node, i); if (result !== false && node.length) { result = node.walk(callback); } if (result === false) { return false; } }); }; _proto.walkAttributes = function walkAttributes(callback) { var _this2 = this; return this.walk(function (selector) { if (selector.type === types$1.ATTRIBUTE) { return callback.call(_this2, selector); } }); }; _proto.walkClasses = function walkClasses(callback) { var _this3 = this; return this.walk(function (selector) { if (selector.type === types$1.CLASS) { return callback.call(_this3, selector); } }); }; _proto.walkCombinators = function walkCombinators(callback) { var _this4 = this; return this.walk(function (selector) { if (selector.type === types$1.COMBINATOR) { return callback.call(_this4, selector); } }); }; _proto.walkComments = function walkComments(callback) { var _this5 = this; return this.walk(function (selector) { if (selector.type === types$1.COMMENT) { return callback.call(_this5, selector); } }); }; _proto.walkIds = function walkIds(callback) { var _this6 = this; return this.walk(function (selector) { if (selector.type === types$1.ID) { return callback.call(_this6, selector); } }); }; _proto.walkNesting = function walkNesting(callback) { var _this7 = this; return this.walk(function (selector) { if (selector.type === types$1.NESTING) { return callback.call(_this7, selector); } }); }; _proto.walkPseudos = function walkPseudos(callback) { var _this8 = this; return this.walk(function (selector) { if (selector.type === types$1.PSEUDO) { return callback.call(_this8, selector); } }); }; _proto.walkTags = function walkTags(callback) { var _this9 = this; return this.walk(function (selector) { if (selector.type === types$1.TAG) { return callback.call(_this9, selector); } }); }; _proto.walkUniversals = function walkUniversals(callback) { var _this10 = this; return this.walk(function (selector) { if (selector.type === types$1.UNIVERSAL) { return callback.call(_this10, selector); } }); }; _proto.split = function split(callback) { var _this11 = this; var current = []; return this.reduce(function (memo, node, index) { var split = callback.call(_this11, node); current.push(node); if (split) { memo.push(current); current = []; } else if (index === _this11.length - 1) { memo.push(current); } return memo; }, []); }; _proto.map = function map(callback) { return this.nodes.map(callback); }; _proto.reduce = function reduce(callback, memo) { return this.nodes.reduce(callback, memo); }; _proto.every = function every(callback) { return this.nodes.every(callback); }; _proto.some = function some(callback) { return this.nodes.some(callback); }; _proto.filter = function filter(callback) { return this.nodes.filter(callback); }; _proto.sort = function sort(callback) { return this.nodes.sort(callback); }; _proto.toString = function toString() { return this.map(String).join(''); }; _createClass(Container, [{ key: "first", get: function get() { return this.at(0); } }, { key: "last", get: function get() { return this.at(this.length - 1); } }, { key: "length", get: function get() { return this.nodes.length; } }]); return Container; }(_node["default"]); exports["default"] = Container; module.exports = exports.default; } (container, container.exports)); (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _container = _interopRequireDefault(container.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Root = /#__PURE__/function (_Container) { _inheritsLoose(Root, _Container); function Root(opts) { var _this; _this = _Container.call(this, opts) \|\| this; _this.type = _types.ROOT; return _this; } var _proto = Root.prototype; _proto.toString = function toString() { var str = this.reduce(function (memo, selector) { memo.push(String(selector)); return memo; }, []).join(','); return this.trailingComma ? str + ',' : str; }; _proto.error = function error(message, options) { if (this._error) { return this._error(message, options); } else { return new Error(message); } }; _createClass(Root, [{ key: "errorGenerator", set: function set(handler) { this._error = handler; } }]); return Root; }(_container["default"]); exports["default"] = Root; module.exports = exports.default; } (root$1, root$1.exports)); var selector$1 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _container = _interopRequireDefault(container.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Selector = /#__PURE__/function (_Container) { _inheritsLoose(Selector, _Container); function Selector(opts) { var _this; _this = _Container.call(this, opts) \|\| this; _this.type = _types.SELECTOR; return _this; } return Selector; }(_container["default"]); exports["default"] = Selector; module.exports = exports.default; } (selector$1, selector$1.exports)); var className$1 = {exports: {}}; /! https://mths.be/cssesc v3.0.0 by @mathias / var object = {}; var hasOwnProperty = object.hasOwnProperty; var merge$1 = function merge(options, defaults) { if (!options) { return defaults; } var result = {}; for (var key in defaults) { // `if (defaults.hasOwnProperty(key) { … }` is not needed here, since // only recognized option names are used. result[key] = hasOwnProperty.call(options, key) ? options[key] : defaults[key]; } return result; }; var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/; var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/; var regexExcessiveSpaces = /(^\|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g; // https://mathiasbynens.be/notes/css-escapes#css var cssesc = function cssesc(string, options) { options = merge$1(options, cssesc.options); if (options.quotes != 'single' && options.quotes != 'double') { options.quotes = 'single'; } var quote = options.quotes == 'double' ? '"' : '\''; var isIdentifier = options.isIdentifier; var firstChar = string.charAt(0); var output = ''; var counter = 0; var length = string.length; while (counter < length) { var character = string.charAt(counter++); var codePoint = character.charCodeAt(); var value = void 0; // If it’s not a printable ASCII character… if (codePoint < 0x20 \|\| codePoint > 0x7E) { if (codePoint >= 0xD800 && codePoint <= 0xDBFF && counter < length) { // It’s a high surrogate, and there is a next character. var extra = string.charCodeAt(counter++); if ((extra & 0xFC00) == 0xDC00) { // next character is low surrogate codePoint = ((codePoint & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000; } else { // It’s an unmatched surrogate; only append this code unit, in case // the next code unit is the high surrogate of a surrogate pair. counter--; } } value = '\\' + codePoint.toString(16).toUpperCase() + ' '; } else { if (options.escapeEverything) { if (regexAnySingleEscape.test(character)) { value = '\\' + character; } else { value = '\\' + codePoint.toString(16).toUpperCase() + ' '; } } else if (/[\t\n\f\r\x0B]/.test(character)) { value = '\\' + codePoint.toString(16).toUpperCase() + ' '; } else if (character == '\\' \|\| !isIdentifier && (character == '"' && quote == character \|\| character == '\'' && quote == character) \|\| isIdentifier && regexSingleEscape.test(character)) { value = '\\' + character; } else { value = character; } } output += value; } if (isIdentifier) { if (/^-[-\d]/.test(output)) { output = '\\-' + output.slice(1); } else if (/\d/.test(firstChar)) { output = '\\3' + firstChar + ' ' + output.slice(1); } } // Remove spaces after `\HEX` escapes that are not followed by a hex digit, // since they’re redundant. Note that this is only possible if the escape // sequence isn’t preceded by an odd number of backslashes. output = output.replace(regexExcessiveSpaces, function ($0, $1, $2) { if ($1 && $1.length % 2) { // It’s not safe to remove the space, so don’t. return $0; } // Strip the space. return ($1 \|\| '') + $2; }); if (!isIdentifier && options.wrap) { return quote + output + quote; } return output; }; // Expose default options (so they can be overridden globally). cssesc.options = { 'escapeEverything': false, 'isIdentifier': false, 'quotes': 'single', 'wrap': false }; cssesc.version = '3.0.0'; var cssesc_1 = cssesc; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _cssesc = _interopRequireDefault(cssesc_1); var _util = util; var _node = _interopRequireDefault(node$1.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var ClassName = /#__PURE__/function (_Node) { _inheritsLoose(ClassName, _Node); function ClassName(opts) { var _this; _this = _Node.call(this, opts) \|\| this; _this.type = _types.CLASS; _this._constructed = true; return _this; } var _proto = ClassName.prototype; _proto.valueToString = function valueToString() { return '.' + _Node.prototype.valueToString.call(this); }; _createClass(ClassName, [{ key: "value", get: function get() { return this._value; }, set: function set(v) { if (this._constructed) { var escaped = (0, _cssesc["default"])(v, { isIdentifier: true }); if (escaped !== v) { (0, _util.ensureObject)(this, "raws"); this.raws.value = escaped; } else if (this.raws) { delete this.raws.value; } } this._value = v; } }]); return ClassName; }(_node["default"]); exports["default"] = ClassName; module.exports = exports.default; } (className$1, className$1.exports)); var comment$2 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _node = _interopRequireDefault(node$1.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Comment = /#__PURE__/function (_Node) { _inheritsLoose(Comment, _Node); function Comment(opts) { var _this; _this = _Node.call(this, opts) \|\| this; _this.type = _types.COMMENT; return _this; } return Comment; }(_node["default"]); exports["default"] = Comment; module.exports = exports.default; } (comment$2, comment$2.exports)); var id$1 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _node = _interopRequireDefault(node$1.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var ID = /#__PURE__/function (_Node) { _inheritsLoose(ID, _Node); function ID(opts) { var _this; _this = _Node.call(this, opts) \|\| this; _this.type = _types.ID; return _this; } var _proto = ID.prototype; _proto.valueToString = function valueToString() { return '#' + _Node.prototype.valueToString.call(this); }; return ID; }(_node["default"]); exports["default"] = ID; module.exports = exports.default; } (id$1, id$1.exports)); var tag$1 = {exports: {}}; var namespace = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _cssesc = _interopRequireDefault(cssesc_1); var _util = util; var _node = _interopRequireDefault(node$1.exports); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Namespace = /#__PURE__/function (_Node) { _inheritsLoose(Namespace, _Node); function Namespace() { return _Node.apply(this, arguments) \|\| this; } var _proto = Namespace.prototype; _proto.qualifiedName = function qualifiedName(value) { if (this.namespace) { return this.namespaceString + "\|" + value; } else { return value; } }; _proto.valueToString = function valueToString() { return this.qualifiedName(_Node.prototype.valueToString.call(this)); }; _createClass(Namespace, [{ key: "namespace", get: function get() { return this._namespace; }, set: function set(namespace) { if (namespace === true \|\| namespace === "" \|\| namespace === "&") { this._namespace = namespace; if (this.raws) { delete this.raws.namespace; } return; } var escaped = (0, _cssesc["default"])(namespace, { isIdentifier: true }); this._namespace = namespace; if (escaped !== namespace) { (0, _util.ensureObject)(this, "raws"); this.raws.namespace = escaped; } else if (this.raws) { delete this.raws.namespace; } } }, { key: "ns", get: function get() { return this._namespace; }, set: function set(namespace) { this.namespace = namespace; } }, { key: "namespaceString", get: function get() { if (this.namespace) { var ns = this.stringifyProperty("namespace"); if (ns === true) { return ''; } else { return ns; } } else { return ''; } } }]); return Namespace; }(_node["default"]); exports["default"] = Namespace; module.exports = exports.default; } (namespace, namespace.exports)); (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _namespace = _interopRequireDefault(namespace.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Tag = /#__PURE__/function (_Namespace) { _inheritsLoose(Tag, _Namespace); function Tag(opts) { var _this; _this = _Namespace.call(this, opts) \|\| this; _this.type = _types.TAG; return _this; } return Tag; }(_namespace["default"]); exports["default"] = Tag; module.exports = exports.default; } (tag$1, tag$1.exports)); var string$1 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _node = _interopRequireDefault(node$1.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var String = /#__PURE__/function (_Node) { _inheritsLoose(String, _Node); function String(opts) { var _this; _this = _Node.call(this, opts) \|\| this; _this.type = _types.STRING; return _this; } return String; }(_node["default"]); exports["default"] = String; module.exports = exports.default; } (string$1, string$1.exports)); var pseudo$1 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _container = _interopRequireDefault(container.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Pseudo = /#__PURE__/function (_Container) { _inheritsLoose(Pseudo, _Container); function Pseudo(opts) { var _this; _this = _Container.call(this, opts) \|\| this; _this.type = _types.PSEUDO; return _this; } var _proto = Pseudo.prototype; _proto.toString = function toString() { var params = this.length ? '(' + this.map(String).join(',') + ')' : ''; return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join(''); }; return Pseudo; }(_container["default"]); exports["default"] = Pseudo; module.exports = exports.default; } (pseudo$1, pseudo$1.exports)); var attribute$1 = {}; /** * For Node.js, simply re-export the core `util.deprecate` function. / var node = require$$2__default["default"].deprecate; (function (exports) { exports.__esModule = true; exports.unescapeValue = unescapeValue; exports["default"] = void 0; var _cssesc = _interopRequireDefault(cssesc_1); var _unesc = _interopRequireDefault(unesc.exports); var _namespace = _interopRequireDefault(namespace.exports); var _types = types; var _CSSESC_QUOTE_OPTIONS; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var deprecate = node; var WRAPPED_IN_QUOTES = /^('\|")([^])\1$/; var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead."); var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead."); var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now."); function unescapeValue(value) { var deprecatedUsage = false; var quoteMark = null; var unescaped = value; var m = unescaped.match(WRAPPED_IN_QUOTES); if (m) { quoteMark = m[1]; unescaped = m[2]; } unescaped = (0, _unesc["default"])(unescaped); if (unescaped !== value) { deprecatedUsage = true; } return { deprecatedUsage: deprecatedUsage, unescaped: unescaped, quoteMark: quoteMark }; } function handleDeprecatedContructorOpts(opts) { if (opts.quoteMark !== undefined) { return opts; } if (opts.value === undefined) { return opts; } warnOfDeprecatedConstructor(); var _unescapeValue = unescapeValue(opts.value), quoteMark = _unescapeValue.quoteMark, unescaped = _unescapeValue.unescaped; if (!opts.raws) { opts.raws = {}; } if (opts.raws.value === undefined) { opts.raws.value = opts.value; } opts.value = unescaped; opts.quoteMark = quoteMark; return opts; } var Attribute = /#__PURE__/function (_Namespace) { _inheritsLoose(Attribute, _Namespace); function Attribute(opts) { var _this; if (opts === void 0) { opts = {}; } _this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) \|\| this; _this.type = _types.ATTRIBUTE; _this.raws = _this.raws \|\| {}; Object.defineProperty(_this.raws, 'unquoted', { get: deprecate(function () { return _this.value; }, "attr.raws.unquoted is deprecated. Call attr.value instead."), set: deprecate(function () { return _this.value; }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.") }); _this._constructed = true; return _this; } /** * Returns the Attribute's value quoted such that it would be legal to use * in the value of a css file. The original value's quotation setting * used for stringification is left unchanged. See `setValue(value, options)` * if you want to control the quote settings of a new value for the attribute. * * You can also change the quotation used for the current value by setting quoteMark. * * Options: * * quoteMark {'"' \| "'" \| null} - Use this value to quote the value. If this * option is not set, the original value for quoteMark will be used. If * indeterminate, a double quote is used. The legal values are: * * `null` - the value will be unquoted and characters will be escaped as necessary. * * `'` - the value will be quoted with a single quote and single quotes are escaped. * * `"` - the value will be quoted with a double quote and double quotes are escaped. * * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark * over the quoteMark option value. * * smart {boolean} - if true, will select a quote mark based on the value * and the other options specified here. See the `smartQuoteMark()` * method. / var _proto = Attribute.prototype; _proto.getQuotedValue = function getQuotedValue(options) { if (options === void 0) { options = {}; } var quoteMark = this._determineQuoteMark(options); var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark]; var escaped = (0, _cssesc["default"])(this._value, cssescopts); return escaped; }; _proto._determineQuoteMark = function _determineQuoteMark(options) { return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options); } / * Set the unescaped value with the specified quotation options. The value * provided must not include any wrapping quote marks -- those quotes will * be interpreted as part of the value and escaped accordingly. / ; _proto.setValue = function setValue(value, options) { if (options === void 0) { options = {}; } this._value = value; this._quoteMark = this._determineQuoteMark(options); this._syncRawValue(); } /* * Intelligently select a quoteMark value based on the value's contents. If * the value is a legal CSS ident, it will not be quoted. Otherwise a quote * mark will be picked that minimizes the number of escapes. * * If there's no clear winner, the quote mark from these options is used, * then the source quote mark (this is inverted if `preferCurrentQuoteMark` is * true). If the quoteMark is unspecified, a double quote is used. * * @param options This takes the quoteMark and preferCurrentQuoteMark options * from the quoteValue method. / ; _proto.smartQuoteMark = function smartQuoteMark(options) { var v = this.value; var numSingleQuotes = v.replace(/[^']/g, '').length; var numDoubleQuotes = v.replace(/[^"]/g, '').length; if (numSingleQuotes + numDoubleQuotes === 0) { var escaped = (0, _cssesc["default"])(v, { isIdentifier: true }); if (escaped === v) { return Attribute.NO_QUOTE; } else { var pref = this.preferredQuoteMark(options); if (pref === Attribute.NO_QUOTE) { // pick a quote mark that isn't none and see if it's smaller var quote = this.quoteMark \|\| options.quoteMark \|\| Attribute.DOUBLE_QUOTE; var opts = CSSESC_QUOTE_OPTIONS[quote]; var quoteValue = (0, _cssesc["default"])(v, opts); if (quoteValue.length < escaped.length) { return quote; } } return pref; } } else if (numDoubleQuotes === numSingleQuotes) { return this.preferredQuoteMark(options); } else if (numDoubleQuotes < numSingleQuotes) { return Attribute.DOUBLE_QUOTE; } else { return Attribute.SINGLE_QUOTE; } } /* * Selects the preferred quote mark based on the options and the current quote mark value. * If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)` * instead. / ; _proto.preferredQuoteMark = function preferredQuoteMark(options) { var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark; if (quoteMark === undefined) { quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark; } if (quoteMark === undefined) { quoteMark = Attribute.DOUBLE_QUOTE; } return quoteMark; }; _proto._syncRawValue = function _syncRawValue() { var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]); if (rawValue === this._value) { if (this.raws) { delete this.raws.value; } } else { this.raws.value = rawValue; } }; _proto._handleEscapes = function _handleEscapes(prop, value) { if (this._constructed) { var escaped = (0, _cssesc["default"])(value, { isIdentifier: true }); if (escaped !== value) { this.raws[prop] = escaped; } else { delete this.raws[prop]; } } }; _proto._spacesFor = function _spacesFor(name) { var attrSpaces = { before: '', after: '' }; var spaces = this.spaces[name] \|\| {}; var rawSpaces = this.raws.spaces && this.raws.spaces[name] \|\| {}; return Object.assign(attrSpaces, spaces, rawSpaces); }; _proto._stringFor = function _stringFor(name, spaceName, concat) { if (spaceName === void 0) { spaceName = name; } if (concat === void 0) { concat = defaultAttrConcat; } var attrSpaces = this._spacesFor(spaceName); return concat(this.stringifyProperty(name), attrSpaces); } /* * returns the offset of the attribute part specified relative to the * start of the node of the output string. * * * "ns" - alias for "namespace" * * "namespace" - the namespace if it exists. * * "attribute" - the attribute name * * "attributeNS" - the start of the attribute or its namespace * * "operator" - the match operator of the attribute * * "value" - The value (string or identifier) * * "insensitive" - the case insensitivity flag; * @param part One of the possible values inside an attribute. * @returns -1 if the name is invalid or the value doesn't exist in this attribute. / ; _proto.offsetOf = function offsetOf(name) { var count = 1; var attributeSpaces = this._spacesFor("attribute"); count += attributeSpaces.before.length; if (name === "namespace" \|\| name === "ns") { return this.namespace ? count : -1; } if (name === "attributeNS") { return count; } count += this.namespaceString.length; if (this.namespace) { count += 1; } if (name === "attribute") { return count; } count += this.stringifyProperty("attribute").length; count += attributeSpaces.after.length; var operatorSpaces = this._spacesFor("operator"); count += operatorSpaces.before.length; var operator = this.stringifyProperty("operator"); if (name === "operator") { return operator ? count : -1; } count += operator.length; count += operatorSpaces.after.length; var valueSpaces = this._spacesFor("value"); count += valueSpaces.before.length; var value = this.stringifyProperty("value"); if (name === "value") { return value ? count : -1; } count += value.length; count += valueSpaces.after.length; var insensitiveSpaces = this._spacesFor("insensitive"); count += insensitiveSpaces.before.length; if (name === "insensitive") { return this.insensitive ? count : -1; } return -1; }; _proto.toString = function toString() { var _this2 = this; var selector = [this.rawSpaceBefore, '[']; selector.push(this._stringFor('qualifiedAttribute', 'attribute')); if (this.operator && (this.value \|\| this.value === '')) { selector.push(this._stringFor('operator')); selector.push(this._stringFor('value')); selector.push(this._stringFor('insensitiveFlag', 'insensitive', function (attrValue, attrSpaces) { if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) { attrSpaces.before = " "; } return defaultAttrConcat(attrValue, attrSpaces); })); } selector.push(']'); selector.push(this.rawSpaceAfter); return selector.join(''); }; _createClass(Attribute, [{ key: "quoted", get: function get() { var qm = this.quoteMark; return qm === "'" \|\| qm === '"'; }, set: function set(value) { warnOfDeprecatedQuotedAssignment(); } /* * returns a single (`'`) or double (`"`) quote character if the value is quoted. * returns `null` if the value is not quoted. * returns `undefined` if the quotation state is unknown (this can happen when * the attribute is constructed without specifying a quote mark.) / }, { key: "quoteMark", get: function get() { return this._quoteMark; } /* * Set the quote mark to be used by this attribute's value. * If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute * value is updated accordingly. * * @param {"'" \| '"' \| null} quoteMark The quote mark or `null` if the value should be unquoted. / , set: function set(quoteMark) { if (!this._constructed) { this._quoteMark = quoteMark; return; } if (this._quoteMark !== quoteMark) { this._quoteMark = quoteMark; this._syncRawValue(); } } }, { key: "qualifiedAttribute", get: function get() { return this.qualifiedName(this.raws.attribute \|\| this.attribute); } }, { key: "insensitiveFlag", get: function get() { return this.insensitive ? 'i' : ''; } }, { key: "value", get: function get() { return this._value; } /* * Before 3.0, the value had to be set to an escaped value including any wrapped * quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value * is unescaped during parsing and any quote marks are removed. * * Because the ambiguity of this semantic change, if you set `attr.value = newValue`, * a deprecation warning is raised when the new value contains any characters that would * require escaping (including if it contains wrapped quotes). * * Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe * how the new value is quoted. / , set: function set(v) { if (this._constructed) { var _unescapeValue2 = unescapeValue(v), deprecatedUsage = _unescapeValue2.deprecatedUsage, unescaped = _unescapeValue2.unescaped, quoteMark = _unescapeValue2.quoteMark; if (deprecatedUsage) { warnOfDeprecatedValueAssignment(); } if (unescaped === this._value && quoteMark === this._quoteMark) { return; } this._value = unescaped; this._quoteMark = quoteMark; this._syncRawValue(); } else { this._value = v; } } }, { key: "attribute", get: function get() { return this._attribute; }, set: function set(name) { this._handleEscapes("attribute", name); this._attribute = name; } }]); return Attribute; }(_namespace["default"]); exports["default"] = Attribute; Attribute.NO_QUOTE = null; Attribute.SINGLE_QUOTE = "'"; Attribute.DOUBLE_QUOTE = '"'; var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = { "'": { quotes: 'single', wrap: true }, '"': { quotes: 'double', wrap: true } }, _CSSESC_QUOTE_OPTIONS[null] = { isIdentifier: true }, _CSSESC_QUOTE_OPTIONS); function defaultAttrConcat(attrValue, attrSpaces) { return "" + attrSpaces.before + attrValue + attrSpaces.after; } } (attribute$1)); var universal$1 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _namespace = _interopRequireDefault(namespace.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Universal = /#__PURE__/function (_Namespace) { _inheritsLoose(Universal, _Namespace); function Universal(opts) { var _this; _this = _Namespace.call(this, opts) \|\| this; _this.type = _types.UNIVERSAL; _this.value = ''; return _this; } return Universal; }(_namespace["default"]); exports["default"] = Universal; module.exports = exports.default; } (universal$1, universal$1.exports)); var combinator$2 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _node = _interopRequireDefault(node$1.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Combinator = /#__PURE__/function (_Node) { _inheritsLoose(Combinator, _Node); function Combinator(opts) { var _this; _this = _Node.call(this, opts) \|\| this; _this.type = _types.COMBINATOR; return _this; } return Combinator; }(_node["default"]); exports["default"] = Combinator; module.exports = exports.default; } (combinator$2, combinator$2.exports)); var nesting$1 = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _node = _interopRequireDefault(node$1.exports); var _types = types; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); } function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } var Nesting = /#__PURE__/function (_Node) { _inheritsLoose(Nesting, _Node); function Nesting(opts) { var _this; _this = _Node.call(this, opts) \|\| this; _this.type = _types.NESTING; _this.value = '&'; return _this; } return Nesting; }(_node["default"]); exports["default"] = Nesting; module.exports = exports.default; } (nesting$1, nesting$1.exports)); var sortAscending = {exports: {}}; (function (module, exports) { exports.__esModule = true; exports["default"] = sortAscending; function sortAscending(list) { return list.sort(function (a, b) { return a - b; }); } module.exports = exports.default; } (sortAscending, sortAscending.exports)); var tokenize = {}; var tokenTypes = {}; tokenTypes.__esModule = true; tokenTypes.combinator = tokenTypes.word = tokenTypes.comment = tokenTypes.str = tokenTypes.tab = tokenTypes.newline = tokenTypes.feed = tokenTypes.cr = tokenTypes.backslash = tokenTypes.bang = tokenTypes.slash = tokenTypes.doubleQuote = tokenTypes.singleQuote = tokenTypes.space = tokenTypes.greaterThan = tokenTypes.pipe = tokenTypes.equals = tokenTypes.plus = tokenTypes.caret = tokenTypes.tilde = tokenTypes.dollar = tokenTypes.closeSquare = tokenTypes.openSquare = tokenTypes.closeParenthesis = tokenTypes.openParenthesis = tokenTypes.semicolon = tokenTypes.colon = tokenTypes.comma = tokenTypes.at = tokenTypes.asterisk = tokenTypes.ampersand = void 0; var ampersand = 38; // `&`.charCodeAt(0); tokenTypes.ampersand = ampersand; var asterisk = 42; // ``.charCodeAt(0); tokenTypes.asterisk = asterisk; var at = 64; // `@`.charCodeAt(0); tokenTypes.at = at; var comma = 44; // `,`.charCodeAt(0); tokenTypes.comma = comma; var colon = 58; // `:`.charCodeAt(0); tokenTypes.colon = colon; var semicolon = 59; // `;`.charCodeAt(0); tokenTypes.semicolon = semicolon; var openParenthesis = 40; // `(`.charCodeAt(0); tokenTypes.openParenthesis = openParenthesis; var closeParenthesis = 41; // `)`.charCodeAt(0); tokenTypes.closeParenthesis = closeParenthesis; var openSquare = 91; // `[`.charCodeAt(0); tokenTypes.openSquare = openSquare; var closeSquare = 93; // `]`.charCodeAt(0); tokenTypes.closeSquare = closeSquare; var dollar = 36; // `$`.charCodeAt(0); tokenTypes.dollar = dollar; var tilde = 126; // `~`.charCodeAt(0); tokenTypes.tilde = tilde; var caret = 94; // `^`.charCodeAt(0); tokenTypes.caret = caret; var plus = 43; // `+`.charCodeAt(0); tokenTypes.plus = plus; var equals = 61; // `=`.charCodeAt(0); tokenTypes.equals = equals; var pipe = 124; // `\|`.charCodeAt(0); tokenTypes.pipe = pipe; var greaterThan = 62; // `>`.charCodeAt(0); tokenTypes.greaterThan = greaterThan; var space = 32; // ` `.charCodeAt(0); tokenTypes.space = space; var singleQuote = 39; // `'`.charCodeAt(0); tokenTypes.singleQuote = singleQuote; var doubleQuote = 34; // `"`.charCodeAt(0); tokenTypes.doubleQuote = doubleQuote; var slash = 47; // `/`.charCodeAt(0); tokenTypes.slash = slash; var bang = 33; // `!`.charCodeAt(0); tokenTypes.bang = bang; var backslash = 92; // '\\'.charCodeAt(0); tokenTypes.backslash = backslash; var cr = 13; // '\r'.charCodeAt(0); tokenTypes.cr = cr; var feed = 12; // '\f'.charCodeAt(0); tokenTypes.feed = feed; var newline = 10; // '\n'.charCodeAt(0); tokenTypes.newline = newline; var tab = 9; // '\t'.charCodeAt(0); // Expose aliases primarily for readability. tokenTypes.tab = tab; var str = singleQuote; // No good single character representation! tokenTypes.str = str; var comment$1 = -1; tokenTypes.comment = comment$1; var word = -2; tokenTypes.word = word; var combinator$1 = -3; tokenTypes.combinator = combinator$1; (function (exports) { exports.__esModule = true; exports["default"] = tokenize; exports.FIELDS = void 0; var t = _interopRequireWildcard(tokenTypes); var _unescapable, _wordDelimiters; function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null \|\| typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get \|\| desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable); var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters); var hex = {}; var hexChars = "0123456789abcdefABCDEF"; for (var i = 0; i < hexChars.length; i++) { hex[hexChars.charCodeAt(i)] = true; } /* * Returns the last index of the bar css word * @param {string} css The string in which the word begins * @param {number} start The index into the string where word's first letter occurs / function consumeWord(css, start) { var next = start; var code; do { code = css.charCodeAt(next); if (wordDelimiters[code]) { return next - 1; } else if (code === t.backslash) { next = consumeEscape(css, next) + 1; } else { // All other characters are part of the word next++; } } while (next < css.length); return next - 1; } /* * Returns the last index of the escape sequence * @param {string} css The string in which the sequence begins * @param {number} start The index into the string where escape character (`\`) occurs. / function consumeEscape(css, start) { var next = start; var code = css.charCodeAt(next + 1); if (unescapable[code]) ; else if (hex[code]) { var hexDigits = 0; // consume up to 6 hex chars do { next++; hexDigits++; code = css.charCodeAt(next + 1); } while (hex[code] && hexDigits < 6); // if fewer than 6 hex chars, a trailing space ends the escape if (hexDigits < 6 && code === t.space) { next++; } } else { // the next char is part of the current word next++; } return next; } var FIELDS = { TYPE: 0, START_LINE: 1, START_COL: 2, END_LINE: 3, END_COL: 4, START_POS: 5, END_POS: 6 }; exports.FIELDS = FIELDS; function tokenize(input) { var tokens = []; var css = input.css.valueOf(); var _css = css, length = _css.length; var offset = -1; var line = 1; var start = 0; var end = 0; var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType; function unclosed(what, fix) { if (input.safe) { // fyi: this is never set to true. css += fix; next = css.length - 1; } else { throw input.error('Unclosed ' + what, line, start - offset, start); } } while (start < length) { code = css.charCodeAt(start); if (code === t.newline) { offset = start; line += 1; } switch (code) { case t.space: case t.tab: case t.newline: case t.cr: case t.feed: next = start; do { next += 1; code = css.charCodeAt(next); if (code === t.newline) { offset = next; line += 1; } } while (code === t.space \|\| code === t.newline \|\| code === t.tab \|\| code === t.cr \|\| code === t.feed); tokenType = t.space; endLine = line; endColumn = next - offset - 1; end = next; break; case t.plus: case t.greaterThan: case t.tilde: case t.pipe: next = start; do { next += 1; code = css.charCodeAt(next); } while (code === t.plus \|\| code === t.greaterThan \|\| code === t.tilde \|\| code === t.pipe); tokenType = t.combinator; endLine = line; endColumn = start - offset; end = next; break; // Consume these characters as single tokens. case t.asterisk: case t.ampersand: case t.bang: case t.comma: case t.equals: case t.dollar: case t.caret: case t.openSquare: case t.closeSquare: case t.colon: case t.semicolon: case t.openParenthesis: case t.closeParenthesis: next = start; tokenType = code; endLine = line; endColumn = start - offset; end = next + 1; break; case t.singleQuote: case t.doubleQuote: quote = code === t.singleQuote ? "'" : '"'; next = start; do { escaped = false; next = css.indexOf(quote, next + 1); if (next === -1) { unclosed('quote', quote); } escapePos = next; while (css.charCodeAt(escapePos - 1) === t.backslash) { escapePos -= 1; escaped = !escaped; } } while (escaped); tokenType = t.str; endLine = line; endColumn = start - offset; end = next + 1; break; default: if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) { next = css.indexOf('/', start + 2) + 1; if (next === 0) { unclosed('comment', '/'); } content = css.slice(start, next + 1); lines = content.split('\n'); last = lines.length - 1; if (last > 0) { nextLine = line + last; nextOffset = next - lines[last].length; } else { nextLine = line; nextOffset = offset; } tokenType = t.comment; line = nextLine; endLine = nextLine; endColumn = next - nextOffset; } else if (code === t.slash) { next = start; tokenType = code; endLine = line; endColumn = start - offset; end = next + 1; } else { next = consumeWord(css, start); tokenType = t.word; endLine = line; endColumn = next - offset; } end = next + 1; break; } // Ensure that the token structure remains consistent tokens.push([tokenType, // [0] Token type line, // [1] Starting line start - offset, // [2] Starting column endLine, // [3] Ending line endColumn, // [4] Ending column start, // [5] Start position / Source index end // [6] End position ]); // Reset offset for the next token if (nextOffset) { offset = nextOffset; nextOffset = null; } start = end; } return tokens; } } (tokenize)); (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _root = _interopRequireDefault(root$1.exports); var _selector = _interopRequireDefault(selector$1.exports); var _className = _interopRequireDefault(className$1.exports); var _comment = _interopRequireDefault(comment$2.exports); var _id = _interopRequireDefault(id$1.exports); var _tag = _interopRequireDefault(tag$1.exports); var _string = _interopRequireDefault(string$1.exports); var _pseudo = _interopRequireDefault(pseudo$1.exports); var _attribute = _interopRequireWildcard(attribute$1); var _universal = _interopRequireDefault(universal$1.exports); var _combinator = _interopRequireDefault(combinator$2.exports); var _nesting = _interopRequireDefault(nesting$1.exports); var _sortAscending = _interopRequireDefault(sortAscending.exports); var _tokenize = _interopRequireWildcard(tokenize); var tokens = _interopRequireWildcard(tokenTypes); var types$1 = _interopRequireWildcard(types); var _util = util; var _WHITESPACE_TOKENS, _Object$assign; function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null \|\| typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get \|\| desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS); var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign)); function tokenStart(token) { return { line: token[_tokenize.FIELDS.START_LINE], column: token[_tokenize.FIELDS.START_COL] }; } function tokenEnd(token) { return { line: token[_tokenize.FIELDS.END_LINE], column: token[_tokenize.FIELDS.END_COL] }; } function getSource(startLine, startColumn, endLine, endColumn) { return { start: { line: startLine, column: startColumn }, end: { line: endLine, column: endColumn } }; } function getTokenSource(token) { return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]); } function getTokenSourceSpan(startToken, endToken) { if (!startToken) { return undefined; } return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]); } function unescapeProp(node, prop) { var value = node[prop]; if (typeof value !== "string") { return; } if (value.indexOf("\\") !== -1) { (0, _util.ensureObject)(node, 'raws'); node[prop] = (0, _util.unesc)(value); if (node.raws[prop] === undefined) { node.raws[prop] = value; } } return node; } function indexesOf(array, item) { var i = -1; var indexes = []; while ((i = array.indexOf(item, i + 1)) !== -1) { indexes.push(i); } return indexes; } function uniqs() { var list = Array.prototype.concat.apply([], arguments); return list.filter(function (item, i) { return i === list.indexOf(item); }); } var Parser = /#__PURE__/function () { function Parser(rule, options) { if (options === void 0) { options = {}; } this.rule = rule; this.options = Object.assign({ lossy: false, safe: false }, options); this.position = 0; this.css = typeof this.rule === 'string' ? this.rule : this.rule.selector; this.tokens = (0, _tokenize["default"])({ css: this.css, error: this._errorGenerator(), safe: this.options.safe }); var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]); this.root = new _root["default"]({ source: rootSource }); this.root.errorGenerator = this._errorGenerator(); var selector = new _selector["default"]({ source: { start: { line: 1, column: 1 } } }); this.root.append(selector); this.current = selector; this.loop(); } var _proto = Parser.prototype; _proto._errorGenerator = function _errorGenerator() { var _this = this; return function (message, errorOptions) { if (typeof _this.rule === 'string') { return new Error(message); } return _this.rule.error(message, errorOptions); }; }; _proto.attribute = function attribute() { var attr = []; var startingToken = this.currToken; this.position++; while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) { attr.push(this.currToken); this.position++; } if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) { return this.expected('closing square bracket', this.currToken[_tokenize.FIELDS.START_POS]); } var len = attr.length; var node = { source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]), sourceIndex: startingToken[_tokenize.FIELDS.START_POS] }; if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) { return this.expected('attribute', attr[0][_tokenize.FIELDS.START_POS]); } var pos = 0; var spaceBefore = ''; var commentBefore = ''; var lastAdded = null; var spaceAfterMeaningfulToken = false; while (pos < len) { var token = attr[pos]; var content = this.content(token); var next = attr[pos + 1]; switch (token[_tokenize.FIELDS.TYPE]) { case tokens.space: // if ( // len === 1 \|\| // pos === 0 && this.content(next) === '\|' // ) { // return this.expected('attribute', token[TOKEN.START_POS], content); // } spaceAfterMeaningfulToken = true; if (this.options.lossy) { break; } if (lastAdded) { (0, _util.ensureObject)(node, 'spaces', lastAdded); var prevContent = node.spaces[lastAdded].after \|\| ''; node.spaces[lastAdded].after = prevContent + content; var existingComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') \|\| null; if (existingComment) { node.raws.spaces[lastAdded].after = existingComment + content; } } else { spaceBefore = spaceBefore + content; commentBefore = commentBefore + content; } break; case tokens.asterisk: if (next[_tokenize.FIELDS.TYPE] === tokens.equals) { node.operator = content; lastAdded = 'operator'; } else if ((!node.namespace \|\| lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) { if (spaceBefore) { (0, _util.ensureObject)(node, 'spaces', 'attribute'); node.spaces.attribute.before = spaceBefore; spaceBefore = ''; } if (commentBefore) { (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute'); node.raws.spaces.attribute.before = spaceBefore; commentBefore = ''; } node.namespace = (node.namespace \|\| "") + content; var rawValue = (0, _util.getProp)(node, 'raws', 'namespace') \|\| null; if (rawValue) { node.raws.namespace += content; } lastAdded = 'namespace'; } spaceAfterMeaningfulToken = false; break; case tokens.dollar: if (lastAdded === "value") { var oldRawValue = (0, _util.getProp)(node, 'raws', 'value'); node.value += "$"; if (oldRawValue) { node.raws.value = oldRawValue + "$"; } break; } // Falls through case tokens.caret: if (next[_tokenize.FIELDS.TYPE] === tokens.equals) { node.operator = content; lastAdded = 'operator'; } spaceAfterMeaningfulToken = false; break; case tokens.combinator: if (content === '~' && next[_tokenize.FIELDS.TYPE] === tokens.equals) { node.operator = content; lastAdded = 'operator'; } if (content !== '\|') { spaceAfterMeaningfulToken = false; break; } if (next[_tokenize.FIELDS.TYPE] === tokens.equals) { node.operator = content; lastAdded = 'operator'; } else if (!node.namespace && !node.attribute) { node.namespace = true; } spaceAfterMeaningfulToken = false; break; case tokens.word: if (next && this.content(next) === '\|' && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && // this look-ahead probably fails with comment nodes involved. !node.operator && !node.namespace) { node.namespace = content; lastAdded = 'namespace'; } else if (!node.attribute \|\| lastAdded === "attribute" && !spaceAfterMeaningfulToken) { if (spaceBefore) { (0, _util.ensureObject)(node, 'spaces', 'attribute'); node.spaces.attribute.before = spaceBefore; spaceBefore = ''; } if (commentBefore) { (0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute'); node.raws.spaces.attribute.before = commentBefore; commentBefore = ''; } node.attribute = (node.attribute \|\| "") + content; var _rawValue = (0, _util.getProp)(node, 'raws', 'attribute') \|\| null; if (_rawValue) { node.raws.attribute += content; } lastAdded = 'attribute'; } else if (!node.value && node.value !== "" \|\| lastAdded === "value" && !spaceAfterMeaningfulToken) { var _unescaped = (0, _util.unesc)(content); var _oldRawValue = (0, _util.getProp)(node, 'raws', 'value') \|\| ''; var oldValue = node.value \|\| ''; node.value = oldValue + _unescaped; node.quoteMark = null; if (_unescaped !== content \|\| _oldRawValue) { (0, _util.ensureObject)(node, 'raws'); node.raws.value = (_oldRawValue \|\| oldValue) + content; } lastAdded = 'value'; } else { var insensitive = content === 'i' \|\| content === "I"; if ((node.value \|\| node.value === '') && (node.quoteMark \|\| spaceAfterMeaningfulToken)) { node.insensitive = insensitive; if (!insensitive \|\| content === "I") { (0, _util.ensureObject)(node, 'raws'); node.raws.insensitiveFlag = content; } lastAdded = 'insensitive'; if (spaceBefore) { (0, _util.ensureObject)(node, 'spaces', 'insensitive'); node.spaces.insensitive.before = spaceBefore; spaceBefore = ''; } if (commentBefore) { (0, _util.ensureObject)(node, 'raws', 'spaces', 'insensitive'); node.raws.spaces.insensitive.before = commentBefore; commentBefore = ''; } } else if (node.value \|\| node.value === '') { lastAdded = 'value'; node.value += content; if (node.raws.value) { node.raws.value += content; } } } spaceAfterMeaningfulToken = false; break; case tokens.str: if (!node.attribute \|\| !node.operator) { return this.error("Expected an attribute followed by an operator preceding the string.", { index: token[_tokenize.FIELDS.START_POS] }); } var _unescapeValue = (0, _attribute.unescapeValue)(content), unescaped = _unescapeValue.unescaped, quoteMark = _unescapeValue.quoteMark; node.value = unescaped; node.quoteMark = quoteMark; lastAdded = 'value'; (0, _util.ensureObject)(node, 'raws'); node.raws.value = content; spaceAfterMeaningfulToken = false; break; case tokens.equals: if (!node.attribute) { return this.expected('attribute', token[_tokenize.FIELDS.START_POS], content); } if (node.value) { return this.error('Unexpected "=" found; an operator was already defined.', { index: token[_tokenize.FIELDS.START_POS] }); } node.operator = node.operator ? node.operator + content : content; lastAdded = 'operator'; spaceAfterMeaningfulToken = false; break; case tokens.comment: if (lastAdded) { if (spaceAfterMeaningfulToken \|\| next && next[_tokenize.FIELDS.TYPE] === tokens.space \|\| lastAdded === 'insensitive') { var lastComment = (0, _util.getProp)(node, 'spaces', lastAdded, 'after') \|\| ''; var rawLastComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') \|\| lastComment; (0, _util.ensureObject)(node, 'raws', 'spaces', lastAdded); node.raws.spaces[lastAdded].after = rawLastComment + content; } else { var lastValue = node[lastAdded] \|\| ''; var rawLastValue = (0, _util.getProp)(node, 'raws', lastAdded) \|\| lastValue; (0, _util.ensureObject)(node, 'raws'); node.raws[lastAdded] = rawLastValue + content; } } else { commentBefore = commentBefore + content; } break; default: return this.error("Unexpected \"" + content + "\" found.", { index: token[_tokenize.FIELDS.START_POS] }); } pos++; } unescapeProp(node, "attribute"); unescapeProp(node, "namespace"); this.newNode(new _attribute["default"](node)); this.position++; } /* * return a node containing meaningless garbage up to (but not including) the specified token position. * if the token position is negative, all remaining tokens are consumed. * * This returns an array containing a single string node if all whitespace, * otherwise an array of comment nodes with space before and after. * * These tokens are not added to the current selector, the caller can add them or use them to amend * a previous node's space metadata. * * In lossy mode, this returns only comments. / ; _proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) { if (stopPosition < 0) { stopPosition = this.tokens.length; } var startPosition = this.position; var nodes = []; var space = ""; var lastComment = undefined; do { if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) { if (!this.options.lossy) { space += this.content(); } } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) { var spaces = {}; if (space) { spaces.before = space; space = ""; } lastComment = new _comment["default"]({ value: this.content(), source: getTokenSource(this.currToken), sourceIndex: this.currToken[_tokenize.FIELDS.START_POS], spaces: spaces }); nodes.push(lastComment); } } while (++this.position < stopPosition); if (space) { if (lastComment) { lastComment.spaces.after = space; } else if (!this.options.lossy) { var firstToken = this.tokens[startPosition]; var lastToken = this.tokens[this.position - 1]; nodes.push(new _string["default"]({ value: '', source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]), sourceIndex: firstToken[_tokenize.FIELDS.START_POS], spaces: { before: space, after: '' } })); } } return nodes; } /* * * @param {} nodes / ; _proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) { var _this2 = this; if (requiredSpace === void 0) { requiredSpace = false; } var space = ""; var rawSpace = ""; nodes.forEach(function (n) { var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace); var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace); space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0); rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0); }); if (rawSpace === space) { rawSpace = undefined; } var result = { space: space, rawSpace: rawSpace }; return result; }; _proto.isNamedCombinator = function isNamedCombinator(position) { if (position === void 0) { position = this.position; } return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash; }; _proto.namedCombinator = function namedCombinator() { if (this.isNamedCombinator()) { var nameRaw = this.content(this.tokens[this.position + 1]); var name = (0, _util.unesc)(nameRaw).toLowerCase(); var raws = {}; if (name !== nameRaw) { raws.value = "/" + nameRaw + "/"; } var node = new _combinator["default"]({ value: "/" + name + "/", source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]), sourceIndex: this.currToken[_tokenize.FIELDS.START_POS], raws: raws }); this.position = this.position + 3; return node; } else { this.unexpected(); } }; _proto.combinator = function combinator() { var _this3 = this; if (this.content() === '\|') { return this.namespace(); } // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector. var nextSigTokenPos = this.locateNextMeaningfulToken(this.position); if (nextSigTokenPos < 0 \|\| this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) { var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos); if (nodes.length > 0) { var last = this.current.last; if (last) { var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes), space = _this$convertWhitespa.space, rawSpace = _this$convertWhitespa.rawSpace; if (rawSpace !== undefined) { last.rawSpaceAfter += rawSpace; } last.spaces.after += space; } else { nodes.forEach(function (n) { return _this3.newNode(n); }); } } return; } var firstToken = this.currToken; var spaceOrDescendantSelectorNodes = undefined; if (nextSigTokenPos > this.position) { spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos); } var node; if (this.isNamedCombinator()) { node = this.namedCombinator(); } else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) { node = new _combinator["default"]({ value: this.content(), source: getTokenSource(this.currToken), sourceIndex: this.currToken[_tokenize.FIELDS.START_POS] }); this.position++; } else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) ; else if (!spaceOrDescendantSelectorNodes) { this.unexpected(); } if (node) { if (spaceOrDescendantSelectorNodes) { var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes), _space = _this$convertWhitespa2.space, _rawSpace = _this$convertWhitespa2.rawSpace; node.spaces.before = _space; node.rawSpaceBefore = _rawSpace; } } else { // descendant combinator var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true), _space2 = _this$convertWhitespa3.space, _rawSpace2 = _this$convertWhitespa3.rawSpace; if (!_rawSpace2) { _rawSpace2 = _space2; } var spaces = {}; var raws = { spaces: {} }; if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) { spaces.before = _space2.slice(0, _space2.length - 1); raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1); } else if (_space2.startsWith(' ') && _rawSpace2.startsWith(' ')) { spaces.after = _space2.slice(1); raws.spaces.after = _rawSpace2.slice(1); } else { raws.value = _rawSpace2; } node = new _combinator["default"]({ value: ' ', source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]), sourceIndex: firstToken[_tokenize.FIELDS.START_POS], spaces: spaces, raws: raws }); } if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) { node.spaces.after = this.optionalSpace(this.content()); this.position++; } return this.newNode(node); }; _proto.comma = function comma() { if (this.position === this.tokens.length - 1) { this.root.trailingComma = true; this.position++; return; } this.current._inferEndPosition(); var selector = new _selector["default"]({ source: { start: tokenStart(this.tokens[this.position + 1]) } }); this.current.parent.append(selector); this.current = selector; this.position++; }; _proto.comment = function comment() { var current = this.currToken; this.newNode(new _comment["default"]({ value: this.content(), source: getTokenSource(current), sourceIndex: current[_tokenize.FIELDS.START_POS] })); this.position++; }; _proto.error = function error(message, opts) { throw this.root.error(message, opts); }; _proto.missingBackslash = function missingBackslash() { return this.error('Expected a backslash preceding the semicolon.', { index: this.currToken[_tokenize.FIELDS.START_POS] }); }; _proto.missingParenthesis = function missingParenthesis() { return this.expected('opening parenthesis', this.currToken[_tokenize.FIELDS.START_POS]); }; _proto.missingSquareBracket = function missingSquareBracket() { return this.expected('opening square bracket', this.currToken[_tokenize.FIELDS.START_POS]); }; _proto.unexpected = function unexpected() { return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]); }; _proto.namespace = function namespace() { var before = this.prevToken && this.content(this.prevToken) \|\| true; if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) { this.position++; return this.word(before); } else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) { this.position++; return this.universal(before); } }; _proto.nesting = function nesting() { if (this.nextToken) { var nextContent = this.content(this.nextToken); if (nextContent === "\|") { this.position++; return; } } var current = this.currToken; this.newNode(new _nesting["default"]({ value: this.content(), source: getTokenSource(current), sourceIndex: current[_tokenize.FIELDS.START_POS] })); this.position++; }; _proto.parentheses = function parentheses() { var last = this.current.last; var unbalanced = 1; this.position++; if (last && last.type === types$1.PSEUDO) { var selector = new _selector["default"]({ source: { start: tokenStart(this.tokens[this.position - 1]) } }); var cache = this.current; last.append(selector); this.current = selector; while (this.position < this.tokens.length && unbalanced) { if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) { unbalanced++; } if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) { unbalanced--; } if (unbalanced) { this.parse(); } else { this.current.source.end = tokenEnd(this.currToken); this.current.parent.source.end = tokenEnd(this.currToken); this.position++; } } this.current = cache; } else { // I think this case should be an error. It's used to implement a basic parse of media queries // but I don't think it's a good idea. var parenStart = this.currToken; var parenValue = "("; var parenEnd; while (this.position < this.tokens.length && unbalanced) { if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) { unbalanced++; } if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) { unbalanced--; } parenEnd = this.currToken; parenValue += this.parseParenthesisToken(this.currToken); this.position++; } if (last) { last.appendToPropertyAndEscape("value", parenValue, parenValue); } else { this.newNode(new _string["default"]({ value: parenValue, source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]), sourceIndex: parenStart[_tokenize.FIELDS.START_POS] })); } } if (unbalanced) { return this.expected('closing parenthesis', this.currToken[_tokenize.FIELDS.START_POS]); } }; _proto.pseudo = function pseudo() { var _this4 = this; var pseudoStr = ''; var startingToken = this.currToken; while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) { pseudoStr += this.content(); this.position++; } if (!this.currToken) { return this.expected(['pseudo-class', 'pseudo-element'], this.position - 1); } if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) { this.splitWord(false, function (first, length) { pseudoStr += first; _this4.newNode(new _pseudo["default"]({ value: pseudoStr, source: getTokenSourceSpan(startingToken, _this4.currToken), sourceIndex: startingToken[_tokenize.FIELDS.START_POS] })); if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) { _this4.error('Misplaced parenthesis.', { index: _this4.nextToken[_tokenize.FIELDS.START_POS] }); } }); } else { return this.expected(['pseudo-class', 'pseudo-element'], this.currToken[_tokenize.FIELDS.START_POS]); } }; _proto.space = function space() { var content = this.content(); // Handle space before and after the selector if (this.position === 0 \|\| this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma \|\| this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis \|\| this.current.nodes.every(function (node) { return node.type === 'comment'; })) { this.spaces = this.optionalSpace(content); this.position++; } else if (this.position === this.tokens.length - 1 \|\| this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma \|\| this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) { this.current.last.spaces.after = this.optionalSpace(content); this.position++; } else { this.combinator(); } }; _proto.string = function string() { var current = this.currToken; this.newNode(new _string["default"]({ value: this.content(), source: getTokenSource(current), sourceIndex: current[_tokenize.FIELDS.START_POS] })); this.position++; }; _proto.universal = function universal(namespace) { var nextToken = this.nextToken; if (nextToken && this.content(nextToken) === '\|') { this.position++; return this.namespace(); } var current = this.currToken; this.newNode(new _universal["default"]({ value: this.content(), source: getTokenSource(current), sourceIndex: current[_tokenize.FIELDS.START_POS] }), namespace); this.position++; }; _proto.splitWord = function splitWord(namespace, firstCallback) { var _this5 = this; var nextToken = this.nextToken; var word = this.content(); while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) { this.position++; var current = this.content(); word += current; if (current.lastIndexOf('\\') === current.length - 1) { var next = this.nextToken; if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) { word += this.requiredSpace(this.content(next)); this.position++; } } nextToken = this.nextToken; } var hasClass = indexesOf(word, '.').filter(function (i) { // Allow escaped dot within class name var escapedDot = word[i - 1] === '\\'; // Allow decimal numbers percent in @keyframes var isKeyframesPercent = /^\d+\.\d+%$/.test(word); return !escapedDot && !isKeyframesPercent; }); var hasId = indexesOf(word, '#').filter(function (i) { return word[i - 1] !== '\\'; }); // Eliminate Sass interpolations from the list of id indexes var interpolations = indexesOf(word, '#{'); if (interpolations.length) { hasId = hasId.filter(function (hashIndex) { return !~interpolations.indexOf(hashIndex); }); } var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId))); indices.forEach(function (ind, i) { var index = indices[i + 1] \|\| word.length; var value = word.slice(ind, index); if (i === 0 && firstCallback) { return firstCallback.call(_this5, value, indices.length); } var node; var current = _this5.currToken; var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i]; var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1)); if (~hasClass.indexOf(ind)) { var classNameOpts = { value: value.slice(1), source: source, sourceIndex: sourceIndex }; node = new _className["default"](unescapeProp(classNameOpts, "value")); } else if (~hasId.indexOf(ind)) { var idOpts = { value: value.slice(1), source: source, sourceIndex: sourceIndex }; node = new _id["default"](unescapeProp(idOpts, "value")); } else { var tagOpts = { value: value, source: source, sourceIndex: sourceIndex }; unescapeProp(tagOpts, "value"); node = new _tag["default"](tagOpts); } _this5.newNode(node, namespace); // Ensure that the namespace is used only once namespace = null; }); this.position++; }; _proto.word = function word(namespace) { var nextToken = this.nextToken; if (nextToken && this.content(nextToken) === '\|') { this.position++; return this.namespace(); } return this.splitWord(namespace); }; _proto.loop = function loop() { while (this.position < this.tokens.length) { this.parse(true); } this.current._inferEndPosition(); return this.root; }; _proto.parse = function parse(throwOnParenthesis) { switch (this.currToken[_tokenize.FIELDS.TYPE]) { case tokens.space: this.space(); break; case tokens.comment: this.comment(); break; case tokens.openParenthesis: this.parentheses(); break; case tokens.closeParenthesis: if (throwOnParenthesis) { this.missingParenthesis(); } break; case tokens.openSquare: this.attribute(); break; case tokens.dollar: case tokens.caret: case tokens.equals: case tokens.word: this.word(); break; case tokens.colon: this.pseudo(); break; case tokens.comma: this.comma(); break; case tokens.asterisk: this.universal(); break; case tokens.ampersand: this.nesting(); break; case tokens.slash: case tokens.combinator: this.combinator(); break; case tokens.str: this.string(); break; // These cases throw; no break needed. case tokens.closeSquare: this.missingSquareBracket(); case tokens.semicolon: this.missingBackslash(); default: this.unexpected(); } } /** * Helpers / ; _proto.expected = function expected(description, index, found) { if (Array.isArray(description)) { var last = description.pop(); description = description.join(', ') + " or " + last; } var an = /^[aeiou]/.test(description[0]) ? 'an' : 'a'; if (!found) { return this.error("Expected " + an + " " + description + ".", { index: index }); } return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", { index: index }); }; _proto.requiredSpace = function requiredSpace(space) { return this.options.lossy ? ' ' : space; }; _proto.optionalSpace = function optionalSpace(space) { return this.options.lossy ? '' : space; }; _proto.lossySpace = function lossySpace(space, required) { if (this.options.lossy) { return required ? ' ' : ''; } else { return space; } }; _proto.parseParenthesisToken = function parseParenthesisToken(token) { var content = this.content(token); if (token[_tokenize.FIELDS.TYPE] === tokens.space) { return this.requiredSpace(content); } else { return content; } }; _proto.newNode = function newNode(node, namespace) { if (namespace) { if (/^ +$/.test(namespace)) { if (!this.options.lossy) { this.spaces = (this.spaces \|\| '') + namespace; } namespace = true; } node.namespace = namespace; unescapeProp(node, "namespace"); } if (this.spaces) { node.spaces.before = this.spaces; this.spaces = ''; } return this.current.append(node); }; _proto.content = function content(token) { if (token === void 0) { token = this.currToken; } return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]); }; /* * returns the index of the next non-whitespace, non-comment token. * returns -1 if no meaningful token is found. / _proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) { if (startPosition === void 0) { startPosition = this.position + 1; } var searchPosition = startPosition; while (searchPosition < this.tokens.length) { if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) { searchPosition++; continue; } else { return searchPosition; } } return -1; }; _createClass(Parser, [{ key: "currToken", get: function get() { return this.tokens[this.position]; } }, { key: "nextToken", get: function get() { return this.tokens[this.position + 1]; } }, { key: "prevToken", get: function get() { return this.tokens[this.position - 1]; } }]); return Parser; }(); exports["default"] = Parser; module.exports = exports.default; } (parser, parser.exports)); (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _parser = _interopRequireDefault(parser.exports); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } var Processor = /#__PURE__/function () { function Processor(func, options) { this.func = func \|\| function noop() {}; this.funcRes = null; this.options = options; } var _proto = Processor.prototype; _proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) { if (options === void 0) { options = {}; } var merged = Object.assign({}, this.options, options); if (merged.updateSelector === false) { return false; } else { return typeof rule !== "string"; } }; _proto._isLossy = function _isLossy(options) { if (options === void 0) { options = {}; } var merged = Object.assign({}, this.options, options); if (merged.lossless === false) { return true; } else { return false; } }; _proto._root = function _root(rule, options) { if (options === void 0) { options = {}; } var parser = new _parser["default"](rule, this._parseOptions(options)); return parser.root; }; _proto._parseOptions = function _parseOptions(options) { return { lossy: this._isLossy(options) }; }; _proto._run = function _run(rule, options) { var _this = this; if (options === void 0) { options = {}; } return new Promise(function (resolve, reject) { try { var root = _this._root(rule, options); Promise.resolve(_this.func(root)).then(function (transform) { var string = undefined; if (_this._shouldUpdateSelector(rule, options)) { string = root.toString(); rule.selector = string; } return { transform: transform, root: root, string: string }; }).then(resolve, reject); } catch (e) { reject(e); return; } }); }; _proto._runSync = function _runSync(rule, options) { if (options === void 0) { options = {}; } var root = this._root(rule, options); var transform = this.func(root); if (transform && typeof transform.then === "function") { throw new Error("Selector processor returned a promise to a synchronous call."); } var string = undefined; if (options.updateSelector && typeof rule !== "string") { string = root.toString(); rule.selector = string; } return { transform: transform, root: root, string: string }; } /* * Process rule into a selector AST. * * @param rule {postcss.Rule \| string} The css selector to be processed * @param options The options for processing * @returns {Promise<parser.Root>} The AST of the selector after processing it. / ; _proto.ast = function ast(rule, options) { return this._run(rule, options).then(function (result) { return result.root; }); } /* * Process rule into a selector AST synchronously. * * @param rule {postcss.Rule \| string} The css selector to be processed * @param options The options for processing * @returns {parser.Root} The AST of the selector after processing it. / ; _proto.astSync = function astSync(rule, options) { return this._runSync(rule, options).root; } /* * Process a selector into a transformed value asynchronously * * @param rule {postcss.Rule \| string} The css selector to be processed * @param options The options for processing * @returns {Promise<any>} The value returned by the processor. / ; _proto.transform = function transform(rule, options) { return this._run(rule, options).then(function (result) { return result.transform; }); } /* * Process a selector into a transformed value synchronously. * * @param rule {postcss.Rule \| string} The css selector to be processed * @param options The options for processing * @returns {any} The value returned by the processor. / ; _proto.transformSync = function transformSync(rule, options) { return this._runSync(rule, options).transform; } /* * Process a selector into a new selector string asynchronously. * * @param rule {postcss.Rule \| string} The css selector to be processed * @param options The options for processing * @returns {string} the selector after processing. / ; _proto.process = function process(rule, options) { return this._run(rule, options).then(function (result) { return result.string \|\| result.root.toString(); }); } /* * Process a selector into a new selector string synchronously. * * @param rule {postcss.Rule \| string} The css selector to be processed * @param options The options for processing * @returns {string} the selector after processing. / ; _proto.processSync = function processSync(rule, options) { var result = this._runSync(rule, options); return result.string \|\| result.root.toString(); }; return Processor; }(); exports["default"] = Processor; module.exports = exports.default; } (processor, processor.exports)); var selectors = {}; var constructors = {}; constructors.__esModule = true; constructors.universal = constructors.tag = constructors.string = constructors.selector = constructors.root = constructors.pseudo = constructors.nesting = constructors.id = constructors.comment = constructors.combinator = constructors.className = constructors.attribute = void 0; var _attribute = _interopRequireDefault(attribute$1); var _className = _interopRequireDefault(className$1.exports); var _combinator = _interopRequireDefault(combinator$2.exports); var _comment = _interopRequireDefault(comment$2.exports); var _id = _interopRequireDefault(id$1.exports); var _nesting = _interopRequireDefault(nesting$1.exports); var _pseudo = _interopRequireDefault(pseudo$1.exports); var _root = _interopRequireDefault(root$1.exports); var _selector = _interopRequireDefault(selector$1.exports); var _string = _interopRequireDefault(string$1.exports); var _tag = _interopRequireDefault(tag$1.exports); var _universal = _interopRequireDefault(universal$1.exports); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } var attribute = function attribute(opts) { return new _attribute["default"](opts); }; constructors.attribute = attribute; var className = function className(opts) { return new _className["default"](opts); }; constructors.className = className; var combinator = function combinator(opts) { return new _combinator["default"](opts); }; constructors.combinator = combinator; var comment = function comment(opts) { return new _comment["default"](opts); }; constructors.comment = comment; var id = function id(opts) { return new _id["default"](opts); }; constructors.id = id; var nesting = function nesting(opts) { return new _nesting["default"](opts); }; constructors.nesting = nesting; var pseudo = function pseudo(opts) { return new _pseudo["default"](opts); }; constructors.pseudo = pseudo; var root = function root(opts) { return new _root["default"](opts); }; constructors.root = root; var selector = function selector(opts) { return new _selector["default"](opts); }; constructors.selector = selector; var string = function string(opts) { return new _string["default"](opts); }; constructors.string = string; var tag = function tag(opts) { return new _tag["default"](opts); }; constructors.tag = tag; var universal = function universal(opts) { return new _universal["default"](opts); }; constructors.universal = universal; var guards = {}; guards.__esModule = true; guards.isNode = isNode; guards.isPseudoElement = isPseudoElement; guards.isPseudoClass = isPseudoClass; guards.isContainer = isContainer; guards.isNamespace = isNamespace; guards.isUniversal = guards.isTag = guards.isString = guards.isSelector = guards.isRoot = guards.isPseudo = guards.isNesting = guards.isIdentifier = guards.isComment = guards.isCombinator = guards.isClassName = guards.isAttribute = void 0; var _types = types; var _IS_TYPE; var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE); function isNode(node) { return typeof node === "object" && IS_TYPE[node.type]; } function isNodeType(type, node) { return isNode(node) && node.type === type; } var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE); guards.isAttribute = isAttribute; var isClassName = isNodeType.bind(null, _types.CLASS); guards.isClassName = isClassName; var isCombinator = isNodeType.bind(null, _types.COMBINATOR); guards.isCombinator = isCombinator; var isComment = isNodeType.bind(null, _types.COMMENT); guards.isComment = isComment; var isIdentifier = isNodeType.bind(null, _types.ID); guards.isIdentifier = isIdentifier; var isNesting = isNodeType.bind(null, _types.NESTING); guards.isNesting = isNesting; var isPseudo = isNodeType.bind(null, _types.PSEUDO); guards.isPseudo = isPseudo; var isRoot = isNodeType.bind(null, _types.ROOT); guards.isRoot = isRoot; var isSelector = isNodeType.bind(null, _types.SELECTOR); guards.isSelector = isSelector; var isString = isNodeType.bind(null, _types.STRING); guards.isString = isString; var isTag = isNodeType.bind(null, _types.TAG); guards.isTag = isTag; var isUniversal = isNodeType.bind(null, _types.UNIVERSAL); guards.isUniversal = isUniversal; function isPseudoElement(node) { return isPseudo(node) && node.value && (node.value.startsWith("::") \|\| node.value.toLowerCase() === ":before" \|\| node.value.toLowerCase() === ":after" \|\| node.value.toLowerCase() === ":first-letter" \|\| node.value.toLowerCase() === ":first-line"); } function isPseudoClass(node) { return isPseudo(node) && !isPseudoElement(node); } function isContainer(node) { return !!(isNode(node) && node.walk); } function isNamespace(node) { return isAttribute(node) \|\| isTag(node); } (function (exports) { exports.__esModule = true; var _types = types; Object.keys(_types).forEach(function (key) { if (key === "default" \|\| key === "__esModule") return; if (key in exports && exports[key] === _types[key]) return; exports[key] = _types[key]; }); var _constructors = constructors; Object.keys(_constructors).forEach(function (key) { if (key === "default" \|\| key === "__esModule") return; if (key in exports && exports[key] === _constructors[key]) return; exports[key] = _constructors[key]; }); var _guards = guards; Object.keys(_guards).forEach(function (key) { if (key === "default" \|\| key === "__esModule") return; if (key in exports && exports[key] === _guards[key]) return; exports[key] = _guards[key]; }); } (selectors)); (function (module, exports) { exports.__esModule = true; exports["default"] = void 0; var _processor = _interopRequireDefault(processor.exports); var selectors$1 = _interopRequireWildcard(selectors); function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; } function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null \|\| typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get \|\| desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } var parser = function parser(processor) { return new _processor["default"](processor); }; Object.assign(parser, selectors$1); delete parser.__esModule; var _default = parser; exports["default"] = _default; module.exports = exports.default; } (dist, dist.exports)); var selectorParser = /@__PURE__/getDefaultExportFromCjs(dist.exports); const animationNameRE = /^(-\w+-)?animation-name$/; const animationRE = /^(-\w+-)?animation$/; const scopedPlugin = (id = '') => { const keyframes = Object.create(null); const shortId = id.replace(/^data-v-/, ''); return { postcssPlugin: 'vue-sfc-scoped', Rule(rule) { processRule(id, rule); }, AtRule(node) { if (/-?keyframes$/.test(node.name) && !node.params.endsWith(`-${shortId}`)) { // register keyframes keyframes[node.params] = node.params = node.params + '-' + shortId; } }, OnceExit(root) { if (Object.keys(keyframes).length) { // If keyframes are found in this <style>, find and rewrite animation names // in declarations. // Caveat: this only works for keyframes and animation rules in the same // <style> element. // individual animation-name declaration root.walkDecls(decl => { if (animationNameRE.test(decl.prop)) { decl.value = decl.value .split(',') .map(v => keyframes[v.trim()] \|\| v.trim()) .join(','); } // shorthand if (animationRE.test(decl.prop)) { decl.value = decl.value .split(',') .map(v => { const vals = v.trim().split(/\s+/); const i = vals.findIndex(val => keyframes[val]); if (i !== -1) { vals.splice(i, 1, keyframes[vals[i]]); return vals.join(' '); } else { return v; } }) .join(','); } }); } } }; }; const processedRules = new WeakSet(); function processRule(id, rule) { if (processedRules.has(rule) \|\| (rule.parent && rule.parent.type === 'atrule' && /-?keyframes$/.test(rule.parent.name))) { return; } processedRules.add(rule); rule.selector = selectorParser(selectorRoot => { selectorRoot.each(selector => { rewriteSelector(id, selector, selectorRoot); }); }).processSync(rule.selector); } function rewriteSelector(id, selector, selectorRoot) { let node = null; // find the last child node to insert attribute selector selector.each(n => { // DEPRECATED ">>>" and "/deep/" combinator if (n.type === 'combinator' && (n.value === '>>>' \|\| n.value === '/deep/')) { n.value = ' '; n.spaces.before = n.spaces.after = ''; // warn( // `the >>> and /deep/ combinators have been deprecated. ` + // `Use :deep() instead.` // ) return false; } if (n.type === 'pseudo') { const { value } = n; // deep: inject [id] attribute at the node before the ::v-deep // combinator. if (value === ':deep' \|\| value === '::v-deep') { if (n.nodes.length) { // .foo ::v-deep(.bar) -> .foo[xxxxxxx] .bar // replace the current node with ::v-deep's inner selector let last = n; n.nodes[0].each(ss => { selector.insertAfter(last, ss); last = ss; }); // insert a space combinator before if it doesn't already have one const prev = selector.at(selector.index(n) - 1); if (!prev \|\| !isSpaceCombinator(prev)) { selector.insertAfter(n, selectorParser.combinator({ value: ' ' })); } selector.removeChild(n); } else { // DEPRECATED usage in v3 // .foo ::v-deep .bar -> .foo[xxxxxxx] .bar // warn( // `::v-deep usage as a combinator has ` + // `been deprecated. Use :deep(<inner-selector>) instead.` // ) const prev = selector.at(selector.index(n) - 1); if (prev && isSpaceCombinator(prev)) { selector.removeChild(prev); } selector.removeChild(n); } return false; } // !!! Vue 2 does not have :slotted support // ::v-slotted(.foo) -> .foo[xxxxxxx-s] // if (value === ':slotted' \|\| value === '::v-slotted') { // rewriteSelector(id, n.nodes[0], selectorRoot, true / slotted /) // let last: selectorParser.Selector['nodes'][0] = n // n.nodes[0].each(ss => { // selector.insertAfter(last, ss) // last = ss // }) // // selector.insertAfter(n, n.nodes[0]) // selector.removeChild(n) // // since slotted attribute already scopes the selector there's no // // need for the non-slot attribute. // shouldInject = false // return false // } // global: replace with inner selector and do not inject [id]. // ::v-global(.foo) -> .foo if (value === ':global' \|\| value === '::v-global') { selectorRoot.insertAfter(selector, n.nodes[0]); selectorRoot.removeChild(selector); return false; } } if (n.type !== 'pseudo' && n.type !== 'combinator') { node = n; } }); if (node) { node.spaces.after = ''; } else { // For deep selectors & standalone pseudo selectors, // the attribute selectors are prepended rather than appended. // So all leading spaces must be eliminated to avoid problems. selector.first.spaces.before = ''; } { selector.insertAfter( // If node is null it means we need to inject [id] at the start // insertAfter can handle `null` here node, selectorParser.attribute({ attribute: id, value: id, raws: {}, quoteMark: `"` })); } } function isSpaceCombinator(node) { return node.type === 'combinator' && /^\s+$/.test(node.value); } scopedPlugin.postcss = true; var sourceMap = require$$0__default$1["default"]; var SourceMapConsumer = sourceMap.SourceMapConsumer; var SourceMapGenerator = sourceMap.SourceMapGenerator; var mergeSourceMap = merge; /* * Merge old source map and new source map and return merged. * If old or new source map value is falsy, return another one as it is. * * @param {object\|string} [oldMap] old source map object * @param {object\|string} [newmap] new source map object * @return {object\|undefined} merged source map object, or undefined when both old and new source map are undefined */ function merge(oldMap, newMap) { if (!oldMap) return newMap if (!newMap) return oldMap var oldMapConsumer = new SourceMapConsumer(oldMap); var newMapConsumer = new SourceMapConsumer(newMap); var mergedMapGenerator = new SourceMapGenerator(); // iterate on new map and overwrite original position of new map with one of old map newMapConsumer.eachMapping(function(m) { // pass when `originalLine` is null. // It occurs in case that the node does not have origin in original code. if (m.originalLine == null) return var origPosInOldMap = oldMapConsumer.originalPositionFor({ line: m.originalLine, column: m.originalColumn }); if (origPosInOldMap.source == null) return mergedMapGenerator.addMapping({ original: { line: origPosInOldMap.line, column: origPosInOldMap.column }, generated: { line: m.generatedLine, column: m.generatedColumn }, source: origPosInOldMap.source, name: origPosInOldMap.name }); }); var consumers = [oldMapConsumer, newMapConsumer]; consumers.forEach(function(consumer) { consumer.sources.forEach(function(sourceFile) { mergedMapGenerator._sources.add(sourceFile); var sourceContent = consumer.sourceContentFor(sourceFile); if (sourceContent != null) { mergedMapGenerator.setSourceContent(sourceFile, sourceContent); } }); }); mergedMapGenerator._sourceRoot = oldMap.sourceRoot; mergedMapGenerator._file = oldMap.file; return JSON.parse(mergedMapGenerator.toString()) } // .scss/.sass processor const scss = (source, map, options) => { const nodeSass = require('sass'); const finalOptions = Object.assign(Object.assign({}, options), { data: getSource(source, options.filename, options.additionalData), file: options.filename, outFile: options.filename, sourceMap: !!map }); try { const result = nodeSass.renderSync(finalOptions); const dependencies = result.stats.includedFiles; if (map) { return { code: result.css.toString(), map: mergeSourceMap(map, JSON.parse(result.map.toString())), errors: [], dependencies }; } return { code: result.css.toString(), errors: [], dependencies }; } catch (e) { return { code: '', errors: [e], dependencies: [] }; } }; const sass = (source, map, options) => scss(source, map, Object.assign(Object.assign({}, options), { indentedSyntax: true })); // .less const less = (source, map, options) => { const nodeLess = require('less'); let result; let error = null; nodeLess.render(getSource(source, options.filename, options.additionalData), Object.assign(Object.assign({}, options), { syncImport: true }), (err, output) => { error = err; result = output; }); if (error) return { code: '', errors: [error], dependencies: [] }; const dependencies = result.imports; if (map) { return { code: result.css.toString(), map: mergeSourceMap(map, result.map), errors: [], dependencies: dependencies }; } return { code: result.css.toString(), errors: [], dependencies: dependencies }; }; // .styl const styl = (source, map, options) => { const nodeStylus = require('stylus'); try { const ref = nodeStylus(source); Object.keys(options).forEach(key => ref.set(key, options[key])); if (map) ref.set('sourcemap', { inline: false, comment: false }); const result = ref.render(); const dependencies = ref.deps(); if (map) { return { code: result, map: mergeSourceMap(map, ref.sourcemap), errors: [], dependencies }; } return { code: result, errors: [], dependencies }; } catch (e) { return { code: '', errors: [e], dependencies: [] }; } }; function getSource(source, filename, additionalData) { if (!additionalData) return source; if (isFunction(additionalData)) { return additionalData(source, filename); } return additionalData + source; } const processors = { less, sass, scss, styl, stylus: styl }; const postcss = require('postcss'); function compileStyle(options) { return doCompileStyle(Object.assign(Object.assign({}, options), { isAsync: false })); } function compileStyleAsync(options) { return Promise.resolve(doCompileStyle(Object.assign(Object.assign({}, options), { isAsync: true }))); } function doCompileStyle(options) { const { filename, id, scoped = true, trim = true, isProd = false, preprocessLang, postcssOptions, postcssPlugins } = options; const preprocessor = preprocessLang && processors[preprocessLang]; const preProcessedSource = preprocessor && preprocess(options, preprocessor); const map = preProcessedSource ? preProcessedSource.map : options.map; const source = preProcessedSource ? preProcessedSource.code : options.source; const plugins = (postcssPlugins \|\| []).slice(); plugins.unshift(cssVarsPlugin({ id: id.replace(/^data-v-/, ''), isProd })); if (trim) { plugins.push(trimPlugin()); } if (scoped) { plugins.push(scopedPlugin(id)); } const postCSSOptions = Object.assign(Object.assign({}, postcssOptions), { to: filename, from: filename }); if (map) { postCSSOptions.map = { inline: false, annotation: false, prev: map }; } let result, code, outMap; const errors = []; if (preProcessedSource && preProcessedSource.errors.length) { errors.push(...preProcessedSource.errors); } try { result = postcss(plugins).process(source, postCSSOptions); // In async mode, return a promise. if (options.isAsync) { return result .then((result) => ({ code: result.css \|\| '', map: result.map && result.map.toJSON(), errors, rawResult: result })) .catch((error) => ({ code: '', map: undefined, errors: [...errors, error.message], rawResult: undefined })); } // force synchronous transform (we know we only have sync plugins) code = result.css; outMap = result.map; } catch (e) { errors.push(e); } return { code: code \|\| ``, map: outMap && outMap.toJSON(), errors, rawResult: result }; } function preprocess(options, preprocessor) { return preprocessor(options.source, options.map, Object.assign({ filename: options.filename }, options.preprocessOptions)); } exports.compileScript = compileScript; exports.compileStyle = compileStyle; exports.compileStyleAsync = compileStyleAsync; exports.compileTemplate = compileTemplate; exports.generateCodeFrame = generateCodeFrame; exports.parse = parse; exports.parseComponent = parseComponent; exports.rewriteDefault = rewriteDefault;