function makeMap(str, expectsLowerCase) {
|
const map = /* @__PURE__ */ 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];
|
}
|
|
const EMPTY_OBJ = Object.freeze({}) ;
|
const NOOP = () => {
|
};
|
const NO = () => false;
|
const onRE = /^on[^a-z]/;
|
const isOn = (key) => onRE.test(key);
|
const extend = Object.assign;
|
const hasOwnProperty$3 = Object.prototype.hasOwnProperty;
|
const hasOwn = (val, key) => hasOwnProperty$3.call(val, key);
|
const isArray$3 = Array.isArray;
|
const isMap = (val) => toTypeString(val) === "[object Map]";
|
const isSet = (val) => toTypeString(val) === "[object Set]";
|
const isFunction$1 = (val) => typeof val === "function";
|
const isString$2 = (val) => typeof val === "string";
|
const isSymbol$1 = (val) => typeof val === "symbol";
|
const isObject$2 = (val) => val !== null && typeof val === "object";
|
const objectToString$1 = Object.prototype.toString;
|
const toTypeString = (value) => objectToString$1.call(value);
|
const isPlainObject = (val) => toTypeString(val) === "[object Object]";
|
const isReservedProp = /* @__PURE__ */ makeMap(
|
// the leading comma is intentional so empty string "" is also included
|
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
|
);
|
const isBuiltInDirective = /* @__PURE__ */ makeMap(
|
"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
|
);
|
const cacheStringFunction = (fn) => {
|
const cache = /* @__PURE__ */ Object.create(null);
|
return (str) => {
|
const hit = cache[str];
|
return hit || (cache[str] = fn(str));
|
};
|
};
|
const camelizeRE = /-(\w)/g;
|
const camelize = cacheStringFunction((str) => {
|
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
|
});
|
const hyphenateRE = /\B([A-Z])/g;
|
const hyphenate = cacheStringFunction(
|
(str) => str.replace(hyphenateRE, "-$1").toLowerCase()
|
);
|
const capitalize$1 = cacheStringFunction(
|
(str) => str.charAt(0).toUpperCase() + str.slice(1)
|
);
|
const toHandlerKey = cacheStringFunction(
|
(str) => str ? `on${capitalize$1(str)}` : ``
|
);
|
const identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
|
function genPropsAccessExp(name) {
|
return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
|
}
|
|
const PatchFlagNames = {
|
[1]: `TEXT`,
|
[2]: `CLASS`,
|
[4]: `STYLE`,
|
[8]: `PROPS`,
|
[16]: `FULL_PROPS`,
|
[32]: `HYDRATE_EVENTS`,
|
[64]: `STABLE_FRAGMENT`,
|
[128]: `KEYED_FRAGMENT`,
|
[256]: `UNKEYED_FRAGMENT`,
|
[512]: `NEED_PATCH`,
|
[1024]: `DYNAMIC_SLOTS`,
|
[2048]: `DEV_ROOT_FRAGMENT`,
|
[-1]: `HOISTED`,
|
[-2]: `BAIL`
|
};
|
|
const slotFlagsText = {
|
[1]: "STABLE",
|
[2]: "DYNAMIC",
|
[3]: "FORWARDED"
|
};
|
|
const GLOBALS_WHITE_LISTED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console";
|
const isGloballyWhitelisted = /* @__PURE__ */ makeMap(GLOBALS_WHITE_LISTED);
|
|
const range = 2;
|
function generateCodeFrame(source, start = 0, end = source.length) {
|
let lines = source.split(/(\r?\n)/);
|
const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
|
lines = lines.filter((_, idx) => idx % 2 === 0);
|
let count = 0;
|
const res = [];
|
for (let i = 0; i < lines.length; i++) {
|
count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
|
if (count >= start) {
|
for (let j = i - range; j <= i + range || end > count; j++) {
|
if (j < 0 || j >= lines.length)
|
continue;
|
const line = j + 1;
|
res.push(
|
`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`
|
);
|
const lineLength = lines[j].length;
|
const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
|
if (j === i) {
|
const pad = start - (count - (lineLength + newLineSeqLength));
|
const length = Math.max(
|
1,
|
end > count ? lineLength - pad : end - start
|
);
|
res.push(` | ` + " ".repeat(pad) + "^".repeat(length));
|
} else if (j > i) {
|
if (end > count) {
|
const length = Math.max(Math.min(end - count, lineLength), 1);
|
res.push(` | ` + "^".repeat(length));
|
}
|
count += lineLength + newLineSeqLength;
|
}
|
}
|
break;
|
}
|
}
|
return res.join("\n");
|
}
|
|
function normalizeStyle(value) {
|
if (isArray$3(value)) {
|
const res = {};
|
for (let i = 0; i < value.length; i++) {
|
const item = value[i];
|
const normalized = isString$2(item) ? parseStringStyle(item) : normalizeStyle(item);
|
if (normalized) {
|
for (const key in normalized) {
|
res[key] = normalized[key];
|
}
|
}
|
}
|
return res;
|
} else if (isString$2(value)) {
|
return value;
|
} else if (isObject$2(value)) {
|
return value;
|
}
|
}
|
const listDelimiterRE = /;(?![^(]*\))/g;
|
const propertyDelimiterRE = /:([^]+)/;
|
const styleCommentRE = /\/\*[^]*?\*\//g;
|
function parseStringStyle(cssText) {
|
const ret = {};
|
cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
|
if (item) {
|
const tmp = item.split(propertyDelimiterRE);
|
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
|
}
|
});
|
return ret;
|
}
|
function stringifyStyle(styles) {
|
let ret = "";
|
if (!styles || isString$2(styles)) {
|
return ret;
|
}
|
for (const key in styles) {
|
const value = styles[key];
|
const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
|
if (isString$2(value) || typeof value === "number") {
|
ret += `${normalizedKey}:${value};`;
|
}
|
}
|
return ret;
|
}
|
function normalizeClass(value) {
|
let res = "";
|
if (isString$2(value)) {
|
res = value;
|
} else if (isArray$3(value)) {
|
for (let i = 0; i < value.length; i++) {
|
const normalized = normalizeClass(value[i]);
|
if (normalized) {
|
res += normalized + " ";
|
}
|
}
|
} else if (isObject$2(value)) {
|
for (const name in value) {
|
if (value[name]) {
|
res += name + " ";
|
}
|
}
|
}
|
return res.trim();
|
}
|
|
const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,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,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,summary,template,blockquote,iframe,tfoot";
|
const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
|
const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
|
const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
|
const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
|
const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
|
|
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
|
const isBooleanAttr = /* @__PURE__ */ makeMap(
|
specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
|
);
|
const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
|
const attrValidationCache = {};
|
function isSSRSafeAttrName(name) {
|
if (attrValidationCache.hasOwnProperty(name)) {
|
return attrValidationCache[name];
|
}
|
const isUnsafe = unsafeAttrCharRE.test(name);
|
if (isUnsafe) {
|
console.error(`unsafe attribute name: ${name}`);
|
}
|
return attrValidationCache[name] = !isUnsafe;
|
}
|
const propsToAttrMap = {
|
acceptCharset: "accept-charset",
|
className: "class",
|
htmlFor: "for",
|
httpEquiv: "http-equiv"
|
};
|
const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
|
`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
|
);
|
const isKnownSvgAttr = /* @__PURE__ */ makeMap(
|
`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
|
);
|
|
const escapeRE = /["'&<>]/;
|
function escapeHtml(string) {
|
const str = "" + string;
|
const match = escapeRE.exec(str);
|
if (!match) {
|
return str;
|
}
|
let html = "";
|
let escaped;
|
let index;
|
let lastIndex = 0;
|
for (index = match.index; index < str.length; index++) {
|
switch (str.charCodeAt(index)) {
|
case 34:
|
escaped = """;
|
break;
|
case 38:
|
escaped = "&";
|
break;
|
case 39:
|
escaped = "'";
|
break;
|
case 60:
|
escaped = "<";
|
break;
|
case 62:
|
escaped = ">";
|
break;
|
default:
|
continue;
|
}
|
if (lastIndex !== index) {
|
html += str.slice(lastIndex, index);
|
}
|
lastIndex = index + 1;
|
html += escaped;
|
}
|
return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
|
}
|
|
const toDisplayString = (val) => {
|
return isString$2(val) ? val : val == null ? "" : isArray$3(val) || isObject$2(val) && (val.toString === objectToString$1 || !isFunction$1(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
|
};
|
const replacer = (_key, val) => {
|
if (val && val.__v_isRef) {
|
return replacer(_key, val.value);
|
} else if (isMap(val)) {
|
return {
|
[`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => {
|
entries[`${key} =>`] = val2;
|
return entries;
|
}, {})
|
};
|
} else if (isSet(val)) {
|
return {
|
[`Set(${val.size})`]: [...val.values()]
|
};
|
} else if (isObject$2(val) && !isArray$3(val) && !isPlainObject(val)) {
|
return String(val);
|
}
|
return val;
|
};
|
|
function defaultOnError(error) {
|
throw error;
|
}
|
function defaultOnWarn(msg) {
|
console.warn(`[Vue warn] ${msg.message}`);
|
}
|
function createCompilerError(code, loc, messages, additionalMessage) {
|
const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;
|
const error = new SyntaxError(String(msg));
|
error.code = code;
|
error.loc = loc;
|
return error;
|
}
|
const errorMessages = {
|
// parse errors
|
[0]: "Illegal comment.",
|
[1]: "CDATA section is allowed only in XML context.",
|
[2]: "Duplicate attribute.",
|
[3]: "End tag cannot have attributes.",
|
[4]: "Illegal '/' in tags.",
|
[5]: "Unexpected EOF in tag.",
|
[6]: "Unexpected EOF in CDATA section.",
|
[7]: "Unexpected EOF in comment.",
|
[8]: "Unexpected EOF in script.",
|
[9]: "Unexpected EOF in tag.",
|
[10]: "Incorrectly closed comment.",
|
[11]: "Incorrectly opened comment.",
|
[12]: "Illegal tag name. Use '<' to print '<'.",
|
[13]: "Attribute value was expected.",
|
[14]: "End tag name was expected.",
|
[15]: "Whitespace was expected.",
|
[16]: "Unexpected '<!--' in comment.",
|
[17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
|
[18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
|
[19]: "Attribute name cannot start with '='.",
|
[21]: "'<?' is allowed only in XML context.",
|
[20]: `Unexpected null character.`,
|
[22]: "Illegal '/' in tags.",
|
// Vue-specific parse errors
|
[23]: "Invalid end tag.",
|
[24]: "Element is missing end tag.",
|
[25]: "Interpolation end sign was not found.",
|
[27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
|
[26]: "Legal directive name was expected.",
|
// transform errors
|
[28]: `v-if/v-else-if is missing expression.`,
|
[29]: `v-if/else branches must use unique keys.`,
|
[30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
|
[31]: `v-for is missing expression.`,
|
[32]: `v-for has invalid expression.`,
|
[33]: `<template v-for> key should be placed on the <template> tag.`,
|
[34]: `v-bind is missing expression.`,
|
[35]: `v-on is missing expression.`,
|
[36]: `Unexpected custom directive on <slot> outlet.`,
|
[37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
|
[38]: `Duplicate slot names found. `,
|
[39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
|
[40]: `v-slot can only be used on components or <template> tags.`,
|
[41]: `v-model is missing expression.`,
|
[42]: `v-model value must be a valid JavaScript member expression.`,
|
[43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
|
[44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
|
Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
|
[45]: `Error parsing JavaScript expression: `,
|
[46]: `<KeepAlive> expects exactly one child component.`,
|
// generic errors
|
[47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
|
[48]: `ES module mode is not supported in this build of compiler.`,
|
[49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
|
[50]: `"scopeId" option is only supported in module mode.`,
|
// deprecations
|
[51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
|
[52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
|
// just to fulfill types
|
[53]: ``
|
};
|
|
const FRAGMENT = Symbol(`Fragment` );
|
const TELEPORT = Symbol(`Teleport` );
|
const SUSPENSE = Symbol(`Suspense` );
|
const KEEP_ALIVE = Symbol(`KeepAlive` );
|
const BASE_TRANSITION = Symbol(`BaseTransition` );
|
const OPEN_BLOCK = Symbol(`openBlock` );
|
const CREATE_BLOCK = Symbol(`createBlock` );
|
const CREATE_ELEMENT_BLOCK = Symbol(`createElementBlock` );
|
const CREATE_VNODE = Symbol(`createVNode` );
|
const CREATE_ELEMENT_VNODE = Symbol(`createElementVNode` );
|
const CREATE_COMMENT = Symbol(`createCommentVNode` );
|
const CREATE_TEXT = Symbol(`createTextVNode` );
|
const CREATE_STATIC = Symbol(`createStaticVNode` );
|
const RESOLVE_COMPONENT = Symbol(`resolveComponent` );
|
const RESOLVE_DYNAMIC_COMPONENT = Symbol(
|
`resolveDynamicComponent`
|
);
|
const RESOLVE_DIRECTIVE = Symbol(`resolveDirective` );
|
const RESOLVE_FILTER = Symbol(`resolveFilter` );
|
const WITH_DIRECTIVES = Symbol(`withDirectives` );
|
const RENDER_LIST = Symbol(`renderList` );
|
const RENDER_SLOT = Symbol(`renderSlot` );
|
const CREATE_SLOTS = Symbol(`createSlots` );
|
const TO_DISPLAY_STRING = Symbol(`toDisplayString` );
|
const MERGE_PROPS = Symbol(`mergeProps` );
|
const NORMALIZE_CLASS = Symbol(`normalizeClass` );
|
const NORMALIZE_STYLE = Symbol(`normalizeStyle` );
|
const NORMALIZE_PROPS = Symbol(`normalizeProps` );
|
const GUARD_REACTIVE_PROPS = Symbol(`guardReactiveProps` );
|
const TO_HANDLERS = Symbol(`toHandlers` );
|
const CAMELIZE = Symbol(`camelize` );
|
const CAPITALIZE = Symbol(`capitalize` );
|
const TO_HANDLER_KEY = Symbol(`toHandlerKey` );
|
const SET_BLOCK_TRACKING = Symbol(`setBlockTracking` );
|
const PUSH_SCOPE_ID = Symbol(`pushScopeId` );
|
const POP_SCOPE_ID = Symbol(`popScopeId` );
|
const WITH_CTX = Symbol(`withCtx` );
|
const UNREF = Symbol(`unref` );
|
const IS_REF = Symbol(`isRef` );
|
const WITH_MEMO = Symbol(`withMemo` );
|
const IS_MEMO_SAME = Symbol(`isMemoSame` );
|
const helperNameMap = {
|
[FRAGMENT]: `Fragment`,
|
[TELEPORT]: `Teleport`,
|
[SUSPENSE]: `Suspense`,
|
[KEEP_ALIVE]: `KeepAlive`,
|
[BASE_TRANSITION]: `BaseTransition`,
|
[OPEN_BLOCK]: `openBlock`,
|
[CREATE_BLOCK]: `createBlock`,
|
[CREATE_ELEMENT_BLOCK]: `createElementBlock`,
|
[CREATE_VNODE]: `createVNode`,
|
[CREATE_ELEMENT_VNODE]: `createElementVNode`,
|
[CREATE_COMMENT]: `createCommentVNode`,
|
[CREATE_TEXT]: `createTextVNode`,
|
[CREATE_STATIC]: `createStaticVNode`,
|
[RESOLVE_COMPONENT]: `resolveComponent`,
|
[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
|
[RESOLVE_DIRECTIVE]: `resolveDirective`,
|
[RESOLVE_FILTER]: `resolveFilter`,
|
[WITH_DIRECTIVES]: `withDirectives`,
|
[RENDER_LIST]: `renderList`,
|
[RENDER_SLOT]: `renderSlot`,
|
[CREATE_SLOTS]: `createSlots`,
|
[TO_DISPLAY_STRING]: `toDisplayString`,
|
[MERGE_PROPS]: `mergeProps`,
|
[NORMALIZE_CLASS]: `normalizeClass`,
|
[NORMALIZE_STYLE]: `normalizeStyle`,
|
[NORMALIZE_PROPS]: `normalizeProps`,
|
[GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
|
[TO_HANDLERS]: `toHandlers`,
|
[CAMELIZE]: `camelize`,
|
[CAPITALIZE]: `capitalize`,
|
[TO_HANDLER_KEY]: `toHandlerKey`,
|
[SET_BLOCK_TRACKING]: `setBlockTracking`,
|
[PUSH_SCOPE_ID]: `pushScopeId`,
|
[POP_SCOPE_ID]: `popScopeId`,
|
[WITH_CTX]: `withCtx`,
|
[UNREF]: `unref`,
|
[IS_REF]: `isRef`,
|
[WITH_MEMO]: `withMemo`,
|
[IS_MEMO_SAME]: `isMemoSame`
|
};
|
function registerRuntimeHelpers(helpers) {
|
Object.getOwnPropertySymbols(helpers).forEach((s) => {
|
helperNameMap[s] = helpers[s];
|
});
|
}
|
|
const locStub = {
|
source: "",
|
start: { line: 1, column: 1, offset: 0 },
|
end: { line: 1, column: 1, offset: 0 }
|
};
|
function createRoot(children, loc = locStub) {
|
return {
|
type: 0,
|
children,
|
helpers: /* @__PURE__ */ new Set(),
|
components: [],
|
directives: [],
|
hoists: [],
|
imports: [],
|
cached: 0,
|
temps: 0,
|
codegenNode: void 0,
|
loc
|
};
|
}
|
function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
|
if (context) {
|
if (isBlock) {
|
context.helper(OPEN_BLOCK);
|
context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
|
} else {
|
context.helper(getVNodeHelper(context.inSSR, isComponent));
|
}
|
if (directives) {
|
context.helper(WITH_DIRECTIVES);
|
}
|
}
|
return {
|
type: 13,
|
tag,
|
props,
|
children,
|
patchFlag,
|
dynamicProps,
|
directives,
|
isBlock,
|
disableTracking,
|
isComponent,
|
loc
|
};
|
}
|
function createArrayExpression(elements, loc = locStub) {
|
return {
|
type: 17,
|
loc,
|
elements
|
};
|
}
|
function createObjectExpression(properties, loc = locStub) {
|
return {
|
type: 15,
|
loc,
|
properties
|
};
|
}
|
function createObjectProperty(key, value) {
|
return {
|
type: 16,
|
loc: locStub,
|
key: isString$2(key) ? createSimpleExpression(key, true) : key,
|
value
|
};
|
}
|
function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
|
return {
|
type: 4,
|
loc,
|
content,
|
isStatic,
|
constType: isStatic ? 3 : constType
|
};
|
}
|
function createInterpolation(content, loc) {
|
return {
|
type: 5,
|
loc,
|
content: isString$2(content) ? createSimpleExpression(content, false, loc) : content
|
};
|
}
|
function createCompoundExpression(children, loc = locStub) {
|
return {
|
type: 8,
|
loc,
|
children
|
};
|
}
|
function createCallExpression(callee, args = [], loc = locStub) {
|
return {
|
type: 14,
|
loc,
|
callee,
|
arguments: args
|
};
|
}
|
function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
|
return {
|
type: 18,
|
params,
|
returns,
|
newline,
|
isSlot,
|
loc
|
};
|
}
|
function createConditionalExpression(test, consequent, alternate, newline = true) {
|
return {
|
type: 19,
|
test,
|
consequent,
|
alternate,
|
newline,
|
loc: locStub
|
};
|
}
|
function createCacheExpression(index, value, isVNode = false) {
|
return {
|
type: 20,
|
index,
|
value,
|
isVNode,
|
loc: locStub
|
};
|
}
|
function createBlockStatement(body) {
|
return {
|
type: 21,
|
body,
|
loc: locStub
|
};
|
}
|
function createTemplateLiteral(elements) {
|
return {
|
type: 22,
|
elements,
|
loc: locStub
|
};
|
}
|
function createIfStatement(test, consequent, alternate) {
|
return {
|
type: 23,
|
test,
|
consequent,
|
alternate,
|
loc: locStub
|
};
|
}
|
function createAssignmentExpression(left, right) {
|
return {
|
type: 24,
|
left,
|
right,
|
loc: locStub
|
};
|
}
|
function createSequenceExpression(expressions) {
|
return {
|
type: 25,
|
expressions,
|
loc: locStub
|
};
|
}
|
function createReturnStatement(returns) {
|
return {
|
type: 26,
|
returns,
|
loc: locStub
|
};
|
}
|
function getVNodeHelper(ssr, isComponent) {
|
return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
|
}
|
function getVNodeBlockHelper(ssr, isComponent) {
|
return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
|
}
|
function convertToBlock(node, { helper, removeHelper, inSSR }) {
|
if (!node.isBlock) {
|
node.isBlock = true;
|
removeHelper(getVNodeHelper(inSSR, node.isComponent));
|
helper(OPEN_BLOCK);
|
helper(getVNodeBlockHelper(inSSR, node.isComponent));
|
}
|
}
|
|
function getDefaultExportFromCjs (x) {
|
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
|
}
|
|
function getAugmentedNamespace(n) {
|
if (n.__esModule) return n;
|
var f = n.default;
|
if (typeof f == "function") {
|
var a = function a () {
|
if (this instanceof a) {
|
var args = [null];
|
args.push.apply(args, arguments);
|
var Ctor = Function.bind.apply(f, args);
|
return new Ctor();
|
}
|
return f.apply(this, arguments);
|
};
|
a.prototype = f.prototype;
|
} else a = {};
|
Object.defineProperty(a, '__esModule', {value: true});
|
Object.keys(n).forEach(function (k) {
|
var d = Object.getOwnPropertyDescriptor(n, k);
|
Object.defineProperty(a, k, d.get ? d : {
|
enumerable: true,
|
get: function () {
|
return n[k];
|
}
|
});
|
});
|
return a;
|
}
|
|
var lib = {};
|
|
Object.defineProperty(lib, '__esModule', {
|
value: true
|
});
|
const defaultOptions = {
|
sourceType: "script",
|
sourceFilename: undefined,
|
startColumn: 0,
|
startLine: 1,
|
allowAwaitOutsideFunction: false,
|
allowReturnOutsideFunction: false,
|
allowNewTargetOutsideFunction: false,
|
allowImportExportEverywhere: false,
|
allowSuperOutsideMethod: false,
|
allowUndeclaredExports: false,
|
plugins: [],
|
strictMode: null,
|
ranges: false,
|
tokens: false,
|
createParenthesizedExpressions: false,
|
errorRecovery: false,
|
attachComment: true,
|
annexB: true
|
};
|
function getOptions(opts) {
|
if (opts && opts.annexB != null && opts.annexB !== false) {
|
throw new Error("The `annexB` option can only be set to `false`.");
|
}
|
const options = {};
|
for (const key of Object.keys(defaultOptions)) {
|
options[key] = opts && opts[key] != null ? opts[key] : defaultOptions[key];
|
}
|
return options;
|
}
|
class TokContext {
|
constructor(token, preserveSpace) {
|
this.token = void 0;
|
this.preserveSpace = void 0;
|
this.token = token;
|
this.preserveSpace = !!preserveSpace;
|
}
|
}
|
const types$1 = {
|
brace: new TokContext("{"),
|
j_oTag: new TokContext("<tag"),
|
j_cTag: new TokContext("</tag"),
|
j_expr: new TokContext("<tag>...</tag>", true)
|
};
|
{
|
types$1.template = new TokContext("`", true);
|
}
|
const beforeExpr = true;
|
const startsExpr = true;
|
const isLoop = true;
|
const isAssign = true;
|
const prefix = true;
|
const postfix = true;
|
class ExportedTokenType {
|
constructor(label, conf = {}) {
|
this.label = void 0;
|
this.keyword = void 0;
|
this.beforeExpr = void 0;
|
this.startsExpr = void 0;
|
this.rightAssociative = void 0;
|
this.isLoop = void 0;
|
this.isAssign = void 0;
|
this.prefix = void 0;
|
this.postfix = void 0;
|
this.binop = void 0;
|
this.label = label;
|
this.keyword = conf.keyword;
|
this.beforeExpr = !!conf.beforeExpr;
|
this.startsExpr = !!conf.startsExpr;
|
this.rightAssociative = !!conf.rightAssociative;
|
this.isLoop = !!conf.isLoop;
|
this.isAssign = !!conf.isAssign;
|
this.prefix = !!conf.prefix;
|
this.postfix = !!conf.postfix;
|
this.binop = conf.binop != null ? conf.binop : null;
|
{
|
this.updateContext = null;
|
}
|
}
|
}
|
const keywords$1 = new Map();
|
function createKeyword(name, options = {}) {
|
options.keyword = name;
|
const token = createToken(name, options);
|
keywords$1.set(name, token);
|
return token;
|
}
|
function createBinop(name, binop) {
|
return createToken(name, {
|
beforeExpr,
|
binop
|
});
|
}
|
let tokenTypeCounter = -1;
|
const tokenTypes$1 = [];
|
const tokenLabels = [];
|
const tokenBinops = [];
|
const tokenBeforeExprs = [];
|
const tokenStartsExprs = [];
|
const tokenPrefixes = [];
|
function createToken(name, options = {}) {
|
var _options$binop, _options$beforeExpr, _options$startsExpr, _options$prefix;
|
++tokenTypeCounter;
|
tokenLabels.push(name);
|
tokenBinops.push((_options$binop = options.binop) != null ? _options$binop : -1);
|
tokenBeforeExprs.push((_options$beforeExpr = options.beforeExpr) != null ? _options$beforeExpr : false);
|
tokenStartsExprs.push((_options$startsExpr = options.startsExpr) != null ? _options$startsExpr : false);
|
tokenPrefixes.push((_options$prefix = options.prefix) != null ? _options$prefix : false);
|
tokenTypes$1.push(new ExportedTokenType(name, options));
|
return tokenTypeCounter;
|
}
|
function createKeywordLike(name, options = {}) {
|
var _options$binop2, _options$beforeExpr2, _options$startsExpr2, _options$prefix2;
|
++tokenTypeCounter;
|
keywords$1.set(name, tokenTypeCounter);
|
tokenLabels.push(name);
|
tokenBinops.push((_options$binop2 = options.binop) != null ? _options$binop2 : -1);
|
tokenBeforeExprs.push((_options$beforeExpr2 = options.beforeExpr) != null ? _options$beforeExpr2 : false);
|
tokenStartsExprs.push((_options$startsExpr2 = options.startsExpr) != null ? _options$startsExpr2 : false);
|
tokenPrefixes.push((_options$prefix2 = options.prefix) != null ? _options$prefix2 : false);
|
tokenTypes$1.push(new ExportedTokenType("name", options));
|
return tokenTypeCounter;
|
}
|
const tt = {
|
bracketL: createToken("[", {
|
beforeExpr,
|
startsExpr
|
}),
|
bracketHashL: createToken("#[", {
|
beforeExpr,
|
startsExpr
|
}),
|
bracketBarL: createToken("[|", {
|
beforeExpr,
|
startsExpr
|
}),
|
bracketR: createToken("]"),
|
bracketBarR: createToken("|]"),
|
braceL: createToken("{", {
|
beforeExpr,
|
startsExpr
|
}),
|
braceBarL: createToken("{|", {
|
beforeExpr,
|
startsExpr
|
}),
|
braceHashL: createToken("#{", {
|
beforeExpr,
|
startsExpr
|
}),
|
braceR: createToken("}"),
|
braceBarR: createToken("|}"),
|
parenL: createToken("(", {
|
beforeExpr,
|
startsExpr
|
}),
|
parenR: createToken(")"),
|
comma: createToken(",", {
|
beforeExpr
|
}),
|
semi: createToken(";", {
|
beforeExpr
|
}),
|
colon: createToken(":", {
|
beforeExpr
|
}),
|
doubleColon: createToken("::", {
|
beforeExpr
|
}),
|
dot: createToken("."),
|
question: createToken("?", {
|
beforeExpr
|
}),
|
questionDot: createToken("?."),
|
arrow: createToken("=>", {
|
beforeExpr
|
}),
|
template: createToken("template"),
|
ellipsis: createToken("...", {
|
beforeExpr
|
}),
|
backQuote: createToken("`", {
|
startsExpr
|
}),
|
dollarBraceL: createToken("${", {
|
beforeExpr,
|
startsExpr
|
}),
|
templateTail: createToken("...`", {
|
startsExpr
|
}),
|
templateNonTail: createToken("...${", {
|
beforeExpr,
|
startsExpr
|
}),
|
at: createToken("@"),
|
hash: createToken("#", {
|
startsExpr
|
}),
|
interpreterDirective: createToken("#!..."),
|
eq: createToken("=", {
|
beforeExpr,
|
isAssign
|
}),
|
assign: createToken("_=", {
|
beforeExpr,
|
isAssign
|
}),
|
slashAssign: createToken("_=", {
|
beforeExpr,
|
isAssign
|
}),
|
xorAssign: createToken("_=", {
|
beforeExpr,
|
isAssign
|
}),
|
moduloAssign: createToken("_=", {
|
beforeExpr,
|
isAssign
|
}),
|
incDec: createToken("++/--", {
|
prefix,
|
postfix,
|
startsExpr
|
}),
|
bang: createToken("!", {
|
beforeExpr,
|
prefix,
|
startsExpr
|
}),
|
tilde: createToken("~", {
|
beforeExpr,
|
prefix,
|
startsExpr
|
}),
|
doubleCaret: createToken("^^", {
|
startsExpr
|
}),
|
doubleAt: createToken("@@", {
|
startsExpr
|
}),
|
pipeline: createBinop("|>", 0),
|
nullishCoalescing: createBinop("??", 1),
|
logicalOR: createBinop("||", 1),
|
logicalAND: createBinop("&&", 2),
|
bitwiseOR: createBinop("|", 3),
|
bitwiseXOR: createBinop("^", 4),
|
bitwiseAND: createBinop("&", 5),
|
equality: createBinop("==/!=/===/!==", 6),
|
lt: createBinop("</>/<=/>=", 7),
|
gt: createBinop("</>/<=/>=", 7),
|
relational: createBinop("</>/<=/>=", 7),
|
bitShift: createBinop("<</>>/>>>", 8),
|
bitShiftL: createBinop("<</>>/>>>", 8),
|
bitShiftR: createBinop("<</>>/>>>", 8),
|
plusMin: createToken("+/-", {
|
beforeExpr,
|
binop: 9,
|
prefix,
|
startsExpr
|
}),
|
modulo: createToken("%", {
|
binop: 10,
|
startsExpr
|
}),
|
star: createToken("*", {
|
binop: 10
|
}),
|
slash: createBinop("/", 10),
|
exponent: createToken("**", {
|
beforeExpr,
|
binop: 11,
|
rightAssociative: true
|
}),
|
_in: createKeyword("in", {
|
beforeExpr,
|
binop: 7
|
}),
|
_instanceof: createKeyword("instanceof", {
|
beforeExpr,
|
binop: 7
|
}),
|
_break: createKeyword("break"),
|
_case: createKeyword("case", {
|
beforeExpr
|
}),
|
_catch: createKeyword("catch"),
|
_continue: createKeyword("continue"),
|
_debugger: createKeyword("debugger"),
|
_default: createKeyword("default", {
|
beforeExpr
|
}),
|
_else: createKeyword("else", {
|
beforeExpr
|
}),
|
_finally: createKeyword("finally"),
|
_function: createKeyword("function", {
|
startsExpr
|
}),
|
_if: createKeyword("if"),
|
_return: createKeyword("return", {
|
beforeExpr
|
}),
|
_switch: createKeyword("switch"),
|
_throw: createKeyword("throw", {
|
beforeExpr,
|
prefix,
|
startsExpr
|
}),
|
_try: createKeyword("try"),
|
_var: createKeyword("var"),
|
_const: createKeyword("const"),
|
_with: createKeyword("with"),
|
_new: createKeyword("new", {
|
beforeExpr,
|
startsExpr
|
}),
|
_this: createKeyword("this", {
|
startsExpr
|
}),
|
_super: createKeyword("super", {
|
startsExpr
|
}),
|
_class: createKeyword("class", {
|
startsExpr
|
}),
|
_extends: createKeyword("extends", {
|
beforeExpr
|
}),
|
_export: createKeyword("export"),
|
_import: createKeyword("import", {
|
startsExpr
|
}),
|
_null: createKeyword("null", {
|
startsExpr
|
}),
|
_true: createKeyword("true", {
|
startsExpr
|
}),
|
_false: createKeyword("false", {
|
startsExpr
|
}),
|
_typeof: createKeyword("typeof", {
|
beforeExpr,
|
prefix,
|
startsExpr
|
}),
|
_void: createKeyword("void", {
|
beforeExpr,
|
prefix,
|
startsExpr
|
}),
|
_delete: createKeyword("delete", {
|
beforeExpr,
|
prefix,
|
startsExpr
|
}),
|
_do: createKeyword("do", {
|
isLoop,
|
beforeExpr
|
}),
|
_for: createKeyword("for", {
|
isLoop
|
}),
|
_while: createKeyword("while", {
|
isLoop
|
}),
|
_as: createKeywordLike("as", {
|
startsExpr
|
}),
|
_assert: createKeywordLike("assert", {
|
startsExpr
|
}),
|
_async: createKeywordLike("async", {
|
startsExpr
|
}),
|
_await: createKeywordLike("await", {
|
startsExpr
|
}),
|
_from: createKeywordLike("from", {
|
startsExpr
|
}),
|
_get: createKeywordLike("get", {
|
startsExpr
|
}),
|
_let: createKeywordLike("let", {
|
startsExpr
|
}),
|
_meta: createKeywordLike("meta", {
|
startsExpr
|
}),
|
_of: createKeywordLike("of", {
|
startsExpr
|
}),
|
_sent: createKeywordLike("sent", {
|
startsExpr
|
}),
|
_set: createKeywordLike("set", {
|
startsExpr
|
}),
|
_static: createKeywordLike("static", {
|
startsExpr
|
}),
|
_using: createKeywordLike("using", {
|
startsExpr
|
}),
|
_yield: createKeywordLike("yield", {
|
startsExpr
|
}),
|
_asserts: createKeywordLike("asserts", {
|
startsExpr
|
}),
|
_checks: createKeywordLike("checks", {
|
startsExpr
|
}),
|
_exports: createKeywordLike("exports", {
|
startsExpr
|
}),
|
_global: createKeywordLike("global", {
|
startsExpr
|
}),
|
_implements: createKeywordLike("implements", {
|
startsExpr
|
}),
|
_intrinsic: createKeywordLike("intrinsic", {
|
startsExpr
|
}),
|
_infer: createKeywordLike("infer", {
|
startsExpr
|
}),
|
_is: createKeywordLike("is", {
|
startsExpr
|
}),
|
_mixins: createKeywordLike("mixins", {
|
startsExpr
|
}),
|
_proto: createKeywordLike("proto", {
|
startsExpr
|
}),
|
_require: createKeywordLike("require", {
|
startsExpr
|
}),
|
_satisfies: createKeywordLike("satisfies", {
|
startsExpr
|
}),
|
_keyof: createKeywordLike("keyof", {
|
startsExpr
|
}),
|
_readonly: createKeywordLike("readonly", {
|
startsExpr
|
}),
|
_unique: createKeywordLike("unique", {
|
startsExpr
|
}),
|
_abstract: createKeywordLike("abstract", {
|
startsExpr
|
}),
|
_declare: createKeywordLike("declare", {
|
startsExpr
|
}),
|
_enum: createKeywordLike("enum", {
|
startsExpr
|
}),
|
_module: createKeywordLike("module", {
|
startsExpr
|
}),
|
_namespace: createKeywordLike("namespace", {
|
startsExpr
|
}),
|
_interface: createKeywordLike("interface", {
|
startsExpr
|
}),
|
_type: createKeywordLike("type", {
|
startsExpr
|
}),
|
_opaque: createKeywordLike("opaque", {
|
startsExpr
|
}),
|
name: createToken("name", {
|
startsExpr
|
}),
|
string: createToken("string", {
|
startsExpr
|
}),
|
num: createToken("num", {
|
startsExpr
|
}),
|
bigint: createToken("bigint", {
|
startsExpr
|
}),
|
decimal: createToken("decimal", {
|
startsExpr
|
}),
|
regexp: createToken("regexp", {
|
startsExpr
|
}),
|
privateName: createToken("#name", {
|
startsExpr
|
}),
|
eof: createToken("eof"),
|
jsxName: createToken("jsxName"),
|
jsxText: createToken("jsxText", {
|
beforeExpr: true
|
}),
|
jsxTagStart: createToken("jsxTagStart", {
|
startsExpr: true
|
}),
|
jsxTagEnd: createToken("jsxTagEnd"),
|
placeholder: createToken("%%", {
|
startsExpr: true
|
})
|
};
|
function tokenIsIdentifier(token) {
|
return token >= 93 && token <= 130;
|
}
|
function tokenKeywordOrIdentifierIsKeyword(token) {
|
return token <= 92;
|
}
|
function tokenIsKeywordOrIdentifier(token) {
|
return token >= 58 && token <= 130;
|
}
|
function tokenIsLiteralPropertyName(token) {
|
return token >= 58 && token <= 134;
|
}
|
function tokenComesBeforeExpression(token) {
|
return tokenBeforeExprs[token];
|
}
|
function tokenCanStartExpression(token) {
|
return tokenStartsExprs[token];
|
}
|
function tokenIsAssignment(token) {
|
return token >= 29 && token <= 33;
|
}
|
function tokenIsFlowInterfaceOrTypeOrOpaque(token) {
|
return token >= 127 && token <= 129;
|
}
|
function tokenIsLoop(token) {
|
return token >= 90 && token <= 92;
|
}
|
function tokenIsKeyword(token) {
|
return token >= 58 && token <= 92;
|
}
|
function tokenIsOperator(token) {
|
return token >= 39 && token <= 59;
|
}
|
function tokenIsPostfix(token) {
|
return token === 34;
|
}
|
function tokenIsPrefix(token) {
|
return tokenPrefixes[token];
|
}
|
function tokenIsTSTypeOperator(token) {
|
return token >= 119 && token <= 121;
|
}
|
function tokenIsTSDeclarationStart(token) {
|
return token >= 122 && token <= 128;
|
}
|
function tokenLabelName(token) {
|
return tokenLabels[token];
|
}
|
function tokenOperatorPrecedence(token) {
|
return tokenBinops[token];
|
}
|
function tokenIsRightAssociative(token) {
|
return token === 57;
|
}
|
function tokenIsTemplate(token) {
|
return token >= 24 && token <= 25;
|
}
|
function getExportedToken(token) {
|
return tokenTypes$1[token];
|
}
|
{
|
tokenTypes$1[8].updateContext = context => {
|
context.pop();
|
};
|
tokenTypes$1[5].updateContext = tokenTypes$1[7].updateContext = tokenTypes$1[23].updateContext = context => {
|
context.push(types$1.brace);
|
};
|
tokenTypes$1[22].updateContext = context => {
|
if (context[context.length - 1] === types$1.template) {
|
context.pop();
|
} else {
|
context.push(types$1.template);
|
}
|
};
|
tokenTypes$1[140].updateContext = context => {
|
context.push(types$1.j_expr, types$1.j_oTag);
|
};
|
}
|
function _objectWithoutPropertiesLoose(source, excluded) {
|
if (source == null) return {};
|
var target = {};
|
var sourceKeys = Object.keys(source);
|
var key, i;
|
for (i = 0; i < sourceKeys.length; i++) {
|
key = sourceKeys[i];
|
if (excluded.indexOf(key) >= 0) continue;
|
target[key] = source[key];
|
}
|
return target;
|
}
|
class Position {
|
constructor(line, col, index) {
|
this.line = void 0;
|
this.column = void 0;
|
this.index = void 0;
|
this.line = line;
|
this.column = col;
|
this.index = index;
|
}
|
}
|
class SourceLocation {
|
constructor(start, end) {
|
this.start = void 0;
|
this.end = void 0;
|
this.filename = void 0;
|
this.identifierName = void 0;
|
this.start = start;
|
this.end = end;
|
}
|
}
|
function createPositionWithColumnOffset(position, columnOffset) {
|
const {
|
line,
|
column,
|
index
|
} = position;
|
return new Position(line, column + columnOffset, index + columnOffset);
|
}
|
var ParseErrorCode = {
|
SyntaxError: "BABEL_PARSER_SYNTAX_ERROR",
|
SourceTypeModuleError: "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED"
|
};
|
const reflect = (keys, last = keys.length - 1) => ({
|
get() {
|
return keys.reduce((object, key) => object[key], this);
|
},
|
set(value) {
|
keys.reduce((item, key, i) => i === last ? item[key] = value : item[key], this);
|
}
|
});
|
const instantiate = (constructor, properties, descriptors) => Object.keys(descriptors).map(key => [key, descriptors[key]]).filter(([, descriptor]) => !!descriptor).map(([key, descriptor]) => [key, typeof descriptor === "function" ? {
|
value: descriptor,
|
enumerable: false
|
} : typeof descriptor.reflect === "string" ? Object.assign({}, descriptor, reflect(descriptor.reflect.split("."))) : descriptor]).reduce((instance, [key, descriptor]) => Object.defineProperty(instance, key, Object.assign({
|
configurable: true
|
}, descriptor)), Object.assign(new constructor(), properties));
|
var ModuleErrors = {
|
ImportMetaOutsideModule: {
|
message: `import.meta may appear only with 'sourceType: "module"'`,
|
code: ParseErrorCode.SourceTypeModuleError
|
},
|
ImportOutsideModule: {
|
message: `'import' and 'export' may appear only with 'sourceType: "module"'`,
|
code: ParseErrorCode.SourceTypeModuleError
|
}
|
};
|
const NodeDescriptions = {
|
ArrayPattern: "array destructuring pattern",
|
AssignmentExpression: "assignment expression",
|
AssignmentPattern: "assignment expression",
|
ArrowFunctionExpression: "arrow function expression",
|
ConditionalExpression: "conditional expression",
|
CatchClause: "catch clause",
|
ForOfStatement: "for-of statement",
|
ForInStatement: "for-in statement",
|
ForStatement: "for-loop",
|
FormalParameters: "function parameter list",
|
Identifier: "identifier",
|
ImportSpecifier: "import specifier",
|
ImportDefaultSpecifier: "import default specifier",
|
ImportNamespaceSpecifier: "import namespace specifier",
|
ObjectPattern: "object destructuring pattern",
|
ParenthesizedExpression: "parenthesized expression",
|
RestElement: "rest element",
|
UpdateExpression: {
|
true: "prefix operation",
|
false: "postfix operation"
|
},
|
VariableDeclarator: "variable declaration",
|
YieldExpression: "yield expression"
|
};
|
const toNodeDescription = ({
|
type,
|
prefix
|
}) => type === "UpdateExpression" ? NodeDescriptions.UpdateExpression[String(prefix)] : NodeDescriptions[type];
|
var StandardErrors = {
|
AccessorIsGenerator: ({
|
kind
|
}) => `A ${kind}ter cannot be a generator.`,
|
ArgumentsInClass: "'arguments' is only allowed in functions and class methods.",
|
AsyncFunctionInSingleStatementContext: "Async functions can only be declared at the top level or inside a block.",
|
AwaitBindingIdentifier: "Can not use 'await' as identifier inside an async function.",
|
AwaitBindingIdentifierInStaticBlock: "Can not use 'await' as identifier inside a static block.",
|
AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
|
AwaitInUsingBinding: "'await' is not allowed to be used as a name in 'using' declarations.",
|
AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
|
AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
|
BadGetterArity: "A 'get' accessor must not have any formal parameters.",
|
BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
|
BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
|
ConstructorClassField: "Classes may not have a field named 'constructor'.",
|
ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
|
ConstructorIsAccessor: "Class constructor may not be an accessor.",
|
ConstructorIsAsync: "Constructor can't be an async function.",
|
ConstructorIsGenerator: "Constructor can't be a generator.",
|
DeclarationMissingInitializer: ({
|
kind
|
}) => `Missing initializer in ${kind} declaration.`,
|
DecoratorArgumentsOutsideParentheses: "Decorator arguments must be moved inside parentheses: use '@(decorator(args))' instead of '@(decorator)(args)'.",
|
DecoratorBeforeExport: "Decorators must be placed *before* the 'export' keyword. Remove the 'decoratorsBeforeExport: true' option to use the 'export @decorator class {}' syntax.",
|
DecoratorsBeforeAfterExport: "Decorators can be placed *either* before or after the 'export' keyword, but not in both locations at the same time.",
|
DecoratorConstructor: "Decorators can't be used with a constructor. Did you mean '@dec class { ... }'?",
|
DecoratorExportClass: "Decorators must be placed *after* the 'export' keyword. Remove the 'decoratorsBeforeExport: false' option to use the '@decorator export class {}' syntax.",
|
DecoratorSemicolon: "Decorators must not be followed by a semicolon.",
|
DecoratorStaticBlock: "Decorators can't be used with a static block.",
|
DeletePrivateField: "Deleting a private field is not allowed.",
|
DestructureNamedImport: "ES2015 named imports do not destructure. Use another statement for destructuring after the import.",
|
DuplicateConstructor: "Duplicate constructor in the same class.",
|
DuplicateDefaultExport: "Only one default export allowed per module.",
|
DuplicateExport: ({
|
exportName
|
}) => `\`${exportName}\` has already been exported. Exported identifiers must be unique.`,
|
DuplicateProto: "Redefinition of __proto__ property.",
|
DuplicateRegExpFlags: "Duplicate regular expression flag.",
|
ElementAfterRest: "Rest element must be last element.",
|
EscapedCharNotAnIdentifier: "Invalid Unicode escape.",
|
ExportBindingIsString: ({
|
localName,
|
exportName
|
}) => `A string literal cannot be used as an exported binding without \`from\`.\n- Did you mean \`export { '${localName}' as '${exportName}' } from 'some-module'\`?`,
|
ExportDefaultFromAsIdentifier: "'from' is not allowed as an identifier after 'export default'.",
|
ForInOfLoopInitializer: ({
|
type
|
}) => `'${type === "ForInStatement" ? "for-in" : "for-of"}' loop variable declaration may not have an initializer.`,
|
ForInUsing: "For-in loop may not start with 'using' declaration.",
|
ForOfAsync: "The left-hand side of a for-of loop may not be 'async'.",
|
ForOfLet: "The left-hand side of a for-of loop may not start with 'let'.",
|
GeneratorInSingleStatementContext: "Generators can only be declared at the top level or inside a block.",
|
IllegalBreakContinue: ({
|
type
|
}) => `Unsyntactic ${type === "BreakStatement" ? "break" : "continue"}.`,
|
IllegalLanguageModeDirective: "Illegal 'use strict' directive in function with non-simple parameter list.",
|
IllegalReturn: "'return' outside of function.",
|
ImportBindingIsString: ({
|
importName
|
}) => `A string literal cannot be used as an imported binding.\n- Did you mean \`import { "${importName}" as foo }\`?`,
|
ImportCallArgumentTrailingComma: "Trailing comma is disallowed inside import(...) arguments.",
|
ImportCallArity: ({
|
maxArgumentCount
|
}) => `\`import()\` requires exactly ${maxArgumentCount === 1 ? "one argument" : "one or two arguments"}.`,
|
ImportCallNotNewExpression: "Cannot use new with import(...).",
|
ImportCallSpreadArgument: "`...` is not allowed in `import()`.",
|
ImportJSONBindingNotDefault: "A JSON module can only be imported with `default`.",
|
ImportReflectionHasAssertion: "`import module x` cannot have assertions.",
|
ImportReflectionNotBinding: 'Only `import module x from "./module"` is valid.',
|
IncompatibleRegExpUVFlags: "The 'u' and 'v' regular expression flags cannot be enabled at the same time.",
|
InvalidBigIntLiteral: "Invalid BigIntLiteral.",
|
InvalidCodePoint: "Code point out of bounds.",
|
InvalidCoverInitializedName: "Invalid shorthand property initializer.",
|
InvalidDecimal: "Invalid decimal.",
|
InvalidDigit: ({
|
radix
|
}) => `Expected number in radix ${radix}.`,
|
InvalidEscapeSequence: "Bad character escape sequence.",
|
InvalidEscapeSequenceTemplate: "Invalid escape sequence in template.",
|
InvalidEscapedReservedWord: ({
|
reservedWord
|
}) => `Escape sequence in keyword ${reservedWord}.`,
|
InvalidIdentifier: ({
|
identifierName
|
}) => `Invalid identifier ${identifierName}.`,
|
InvalidLhs: ({
|
ancestor
|
}) => `Invalid left-hand side in ${toNodeDescription(ancestor)}.`,
|
InvalidLhsBinding: ({
|
ancestor
|
}) => `Binding invalid left-hand side in ${toNodeDescription(ancestor)}.`,
|
InvalidNumber: "Invalid number.",
|
InvalidOrMissingExponent: "Floating-point numbers require a valid exponent after the 'e'.",
|
InvalidOrUnexpectedToken: ({
|
unexpected
|
}) => `Unexpected character '${unexpected}'.`,
|
InvalidParenthesizedAssignment: "Invalid parenthesized assignment pattern.",
|
InvalidPrivateFieldResolution: ({
|
identifierName
|
}) => `Private name #${identifierName} is not defined.`,
|
InvalidPropertyBindingPattern: "Binding member expression.",
|
InvalidRecordProperty: "Only properties and spread elements are allowed in record definitions.",
|
InvalidRestAssignmentPattern: "Invalid rest operator's argument.",
|
LabelRedeclaration: ({
|
labelName
|
}) => `Label '${labelName}' is already declared.`,
|
LetInLexicalBinding: "'let' is not allowed to be used as a name in 'let' or 'const' declarations.",
|
LineTerminatorBeforeArrow: "No line break is allowed before '=>'.",
|
MalformedRegExpFlags: "Invalid regular expression flag.",
|
MissingClassName: "A class name is required.",
|
MissingEqInAssignment: "Only '=' operator can be used for specifying default value.",
|
MissingSemicolon: "Missing semicolon.",
|
MissingPlugin: ({
|
missingPlugin
|
}) => `This experimental syntax requires enabling the parser plugin: ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
|
MissingOneOfPlugins: ({
|
missingPlugin
|
}) => `This experimental syntax requires enabling one of the following parser plugin(s): ${missingPlugin.map(name => JSON.stringify(name)).join(", ")}.`,
|
MissingUnicodeEscape: "Expecting Unicode escape sequence \\uXXXX.",
|
MixingCoalesceWithLogical: "Nullish coalescing operator(??) requires parens when mixing with logical operators.",
|
ModuleAttributeDifferentFromType: "The only accepted module attribute is `type`.",
|
ModuleAttributeInvalidValue: "Only string literals are allowed as module attribute values.",
|
ModuleAttributesWithDuplicateKeys: ({
|
key
|
}) => `Duplicate key "${key}" is not allowed in module attributes.`,
|
ModuleExportNameHasLoneSurrogate: ({
|
surrogateCharCode
|
}) => `An export name cannot include a lone surrogate, found '\\u${surrogateCharCode.toString(16)}'.`,
|
ModuleExportUndefined: ({
|
localName
|
}) => `Export '${localName}' is not defined.`,
|
MultipleDefaultsInSwitch: "Multiple default clauses.",
|
NewlineAfterThrow: "Illegal newline after throw.",
|
NoCatchOrFinally: "Missing catch or finally clause.",
|
NumberIdentifier: "Identifier directly after number.",
|
NumericSeparatorInEscapeSequence: "Numeric separators are not allowed inside unicode escape sequences or hex escape sequences.",
|
ObsoleteAwaitStar: "'await*' has been removed from the async functions proposal. Use Promise.all() instead.",
|
OptionalChainingNoNew: "Constructors in/after an Optional Chain are not allowed.",
|
OptionalChainingNoTemplate: "Tagged Template Literals are not allowed in optionalChain.",
|
OverrideOnConstructor: "'override' modifier cannot appear on a constructor declaration.",
|
ParamDupe: "Argument name clash.",
|
PatternHasAccessor: "Object pattern can't contain getter or setter.",
|
PatternHasMethod: "Object pattern can't contain methods.",
|
PrivateInExpectedIn: ({
|
identifierName
|
}) => `Private names are only allowed in property accesses (\`obj.#${identifierName}\`) or in \`in\` expressions (\`#${identifierName} in obj\`).`,
|
PrivateNameRedeclaration: ({
|
identifierName
|
}) => `Duplicate private name #${identifierName}.`,
|
RecordExpressionBarIncorrectEndSyntaxType: "Record expressions ending with '|}' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
|
RecordExpressionBarIncorrectStartSyntaxType: "Record expressions starting with '{|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
|
RecordExpressionHashIncorrectStartSyntaxType: "Record expressions starting with '#{' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
|
RecordNoProto: "'__proto__' is not allowed in Record expressions.",
|
RestTrailingComma: "Unexpected trailing comma after rest element.",
|
SloppyFunction: "In non-strict mode code, functions can only be declared at top level or inside a block.",
|
SloppyFunctionAnnexB: "In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement.",
|
StaticPrototype: "Classes may not have static property named prototype.",
|
SuperNotAllowed: "`super()` is only valid inside a class constructor of a subclass. Maybe a typo in the method name ('constructor') or not extending another class?",
|
SuperPrivateField: "Private fields can't be accessed on super.",
|
TrailingDecorator: "Decorators must be attached to a class element.",
|
TupleExpressionBarIncorrectEndSyntaxType: "Tuple expressions ending with '|]' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
|
TupleExpressionBarIncorrectStartSyntaxType: "Tuple expressions starting with '[|' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'bar'.",
|
TupleExpressionHashIncorrectStartSyntaxType: "Tuple expressions starting with '#[' are only allowed when the 'syntaxType' option of the 'recordAndTuple' plugin is set to 'hash'.",
|
UnexpectedArgumentPlaceholder: "Unexpected argument placeholder.",
|
UnexpectedAwaitAfterPipelineBody: 'Unexpected "await" after pipeline body; await must have parentheses in minimal proposal.',
|
UnexpectedDigitAfterHash: "Unexpected digit after hash token.",
|
UnexpectedImportExport: "'import' and 'export' may only appear at the top level.",
|
UnexpectedKeyword: ({
|
keyword
|
}) => `Unexpected keyword '${keyword}'.`,
|
UnexpectedLeadingDecorator: "Leading decorators must be attached to a class declaration.",
|
UnexpectedLexicalDeclaration: "Lexical declaration cannot appear in a single-statement context.",
|
UnexpectedNewTarget: "`new.target` can only be used in functions or class properties.",
|
UnexpectedNumericSeparator: "A numeric separator is only allowed between two digits.",
|
UnexpectedPrivateField: "Unexpected private name.",
|
UnexpectedReservedWord: ({
|
reservedWord
|
}) => `Unexpected reserved word '${reservedWord}'.`,
|
UnexpectedSuper: "'super' is only allowed in object methods and classes.",
|
UnexpectedToken: ({
|
expected,
|
unexpected
|
}) => `Unexpected token${unexpected ? ` '${unexpected}'.` : ""}${expected ? `, expected "${expected}"` : ""}`,
|
UnexpectedTokenUnaryExponentiation: "Illegal expression. Wrap left hand side or entire exponentiation in parentheses.",
|
UnexpectedUsingDeclaration: "Using declaration cannot appear in the top level when source type is `script`.",
|
UnsupportedBind: "Binding should be performed on object property.",
|
UnsupportedDecoratorExport: "A decorated export must export a class declaration.",
|
UnsupportedDefaultExport: "Only expressions, functions or classes are allowed as the `default` export.",
|
UnsupportedImport: "`import` can only be used in `import()` or `import.meta`.",
|
UnsupportedMetaProperty: ({
|
target,
|
onlyValidPropertyName
|
}) => `The only valid meta property for ${target} is ${target}.${onlyValidPropertyName}.`,
|
UnsupportedParameterDecorator: "Decorators cannot be used to decorate parameters.",
|
UnsupportedPropertyDecorator: "Decorators cannot be used to decorate object literal properties.",
|
UnsupportedSuper: "'super' can only be used with function calls (i.e. super()) or in property accesses (i.e. super.prop or super[prop]).",
|
UnterminatedComment: "Unterminated comment.",
|
UnterminatedRegExp: "Unterminated regular expression.",
|
UnterminatedString: "Unterminated string constant.",
|
UnterminatedTemplate: "Unterminated template.",
|
UsingDeclarationHasBindingPattern: "Using declaration cannot have destructuring patterns.",
|
VarRedeclaration: ({
|
identifierName
|
}) => `Identifier '${identifierName}' has already been declared.`,
|
YieldBindingIdentifier: "Can not use 'yield' as identifier inside a generator.",
|
YieldInParameter: "Yield expression is not allowed in formal parameters.",
|
ZeroDigitNumericSeparator: "Numeric separator can not be used after leading 0."
|
};
|
var StrictModeErrors = {
|
StrictDelete: "Deleting local variable in strict mode.",
|
StrictEvalArguments: ({
|
referenceName
|
}) => `Assigning to '${referenceName}' in strict mode.`,
|
StrictEvalArgumentsBinding: ({
|
bindingName
|
}) => `Binding '${bindingName}' in strict mode.`,
|
StrictFunction: "In strict mode code, functions can only be declared at top level or inside a block.",
|
StrictNumericEscape: "The only valid numeric escape in strict mode is '\\0'.",
|
StrictOctalLiteral: "Legacy octal literals are not allowed in strict mode.",
|
StrictWith: "'with' in strict mode."
|
};
|
const UnparenthesizedPipeBodyDescriptions = new Set(["ArrowFunctionExpression", "AssignmentExpression", "ConditionalExpression", "YieldExpression"]);
|
var PipelineOperatorErrors = {
|
PipeBodyIsTighter: "Unexpected yield after pipeline body; any yield expression acting as Hack-style pipe body must be parenthesized due to its loose operator precedence.",
|
PipeTopicRequiresHackPipes: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.',
|
PipeTopicUnbound: "Topic reference is unbound; it must be inside a pipe body.",
|
PipeTopicUnconfiguredToken: ({
|
token
|
}) => `Invalid topic token ${token}. In order to use ${token} as a topic reference, the pipelineOperator plugin must be configured with { "proposal": "hack", "topicToken": "${token}" }.`,
|
PipeTopicUnused: "Hack-style pipe body does not contain a topic reference; Hack-style pipes must use topic at least once.",
|
PipeUnparenthesizedBody: ({
|
type
|
}) => `Hack-style pipe body cannot be an unparenthesized ${toNodeDescription({
|
type
|
})}; please wrap it in parentheses.`,
|
PipelineBodyNoArrow: 'Unexpected arrow "=>" after pipeline body; arrow function in pipeline body must be parenthesized.',
|
PipelineBodySequenceExpression: "Pipeline body may not be a comma-separated sequence expression.",
|
PipelineHeadSequenceExpression: "Pipeline head should not be a comma-separated sequence expression.",
|
PipelineTopicUnused: "Pipeline is in topic style but does not use topic reference.",
|
PrimaryTopicNotAllowed: "Topic reference was used in a lexical context without topic binding.",
|
PrimaryTopicRequiresSmartPipeline: 'Topic reference is used, but the pipelineOperator plugin was not passed a "proposal": "hack" or "smart" option.'
|
};
|
const _excluded$1 = ["toMessage"],
|
_excluded2$1 = ["message"];
|
function toParseErrorConstructor(_ref) {
|
let {
|
toMessage
|
} = _ref,
|
properties = _objectWithoutPropertiesLoose(_ref, _excluded$1);
|
return function constructor({
|
loc,
|
details
|
}) {
|
return instantiate(SyntaxError, Object.assign({}, properties, {
|
loc
|
}), {
|
clone(overrides = {}) {
|
const loc = overrides.loc || {};
|
return constructor({
|
loc: new Position("line" in loc ? loc.line : this.loc.line, "column" in loc ? loc.column : this.loc.column, "index" in loc ? loc.index : this.loc.index),
|
details: Object.assign({}, this.details, overrides.details)
|
});
|
},
|
details: {
|
value: details,
|
enumerable: false
|
},
|
message: {
|
get() {
|
return `${toMessage(this.details)} (${this.loc.line}:${this.loc.column})`;
|
},
|
set(value) {
|
Object.defineProperty(this, "message", {
|
value
|
});
|
}
|
},
|
pos: {
|
reflect: "loc.index",
|
enumerable: true
|
},
|
missingPlugin: "missingPlugin" in details && {
|
reflect: "details.missingPlugin",
|
enumerable: true
|
}
|
});
|
};
|
}
|
function ParseErrorEnum(argument, syntaxPlugin) {
|
if (Array.isArray(argument)) {
|
return parseErrorTemplates => ParseErrorEnum(parseErrorTemplates, argument[0]);
|
}
|
const ParseErrorConstructors = {};
|
for (const reasonCode of Object.keys(argument)) {
|
const template = argument[reasonCode];
|
const _ref2 = typeof template === "string" ? {
|
message: () => template
|
} : typeof template === "function" ? {
|
message: template
|
} : template,
|
{
|
message
|
} = _ref2,
|
rest = _objectWithoutPropertiesLoose(_ref2, _excluded2$1);
|
const toMessage = typeof message === "string" ? () => message : message;
|
ParseErrorConstructors[reasonCode] = toParseErrorConstructor(Object.assign({
|
code: ParseErrorCode.SyntaxError,
|
reasonCode,
|
toMessage
|
}, syntaxPlugin ? {
|
syntaxPlugin
|
} : {}, rest));
|
}
|
return ParseErrorConstructors;
|
}
|
const Errors = Object.assign({}, ParseErrorEnum(ModuleErrors), ParseErrorEnum(StandardErrors), ParseErrorEnum(StrictModeErrors), ParseErrorEnum`pipelineOperator`(PipelineOperatorErrors));
|
const {
|
defineProperty
|
} = Object;
|
const toUnenumerable = (object, key) => defineProperty(object, key, {
|
enumerable: false,
|
value: object[key]
|
});
|
function toESTreeLocation(node) {
|
node.loc.start && toUnenumerable(node.loc.start, "index");
|
node.loc.end && toUnenumerable(node.loc.end, "index");
|
return node;
|
}
|
var estree = superClass => class ESTreeParserMixin extends superClass {
|
parse() {
|
const file = toESTreeLocation(super.parse());
|
if (this.options.tokens) {
|
file.tokens = file.tokens.map(toESTreeLocation);
|
}
|
return file;
|
}
|
parseRegExpLiteral({
|
pattern,
|
flags
|
}) {
|
let regex = null;
|
try {
|
regex = new RegExp(pattern, flags);
|
} catch (e) {}
|
const node = this.estreeParseLiteral(regex);
|
node.regex = {
|
pattern,
|
flags
|
};
|
return node;
|
}
|
parseBigIntLiteral(value) {
|
let bigInt;
|
try {
|
bigInt = BigInt(value);
|
} catch (_unused) {
|
bigInt = null;
|
}
|
const node = this.estreeParseLiteral(bigInt);
|
node.bigint = String(node.value || value);
|
return node;
|
}
|
parseDecimalLiteral(value) {
|
const decimal = null;
|
const node = this.estreeParseLiteral(decimal);
|
node.decimal = String(node.value || value);
|
return node;
|
}
|
estreeParseLiteral(value) {
|
return this.parseLiteral(value, "Literal");
|
}
|
parseStringLiteral(value) {
|
return this.estreeParseLiteral(value);
|
}
|
parseNumericLiteral(value) {
|
return this.estreeParseLiteral(value);
|
}
|
parseNullLiteral() {
|
return this.estreeParseLiteral(null);
|
}
|
parseBooleanLiteral(value) {
|
return this.estreeParseLiteral(value);
|
}
|
directiveToStmt(directive) {
|
const expression = directive.value;
|
delete directive.value;
|
expression.type = "Literal";
|
expression.raw = expression.extra.raw;
|
expression.value = expression.extra.expressionValue;
|
const stmt = directive;
|
stmt.type = "ExpressionStatement";
|
stmt.expression = expression;
|
stmt.directive = expression.extra.rawValue;
|
delete expression.extra;
|
return stmt;
|
}
|
initFunction(node, isAsync) {
|
super.initFunction(node, isAsync);
|
node.expression = false;
|
}
|
checkDeclaration(node) {
|
if (node != null && this.isObjectProperty(node)) {
|
this.checkDeclaration(node.value);
|
} else {
|
super.checkDeclaration(node);
|
}
|
}
|
getObjectOrClassMethodParams(method) {
|
return method.value.params;
|
}
|
isValidDirective(stmt) {
|
var _stmt$expression$extr;
|
return stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string" && !((_stmt$expression$extr = stmt.expression.extra) != null && _stmt$expression$extr.parenthesized);
|
}
|
parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
|
super.parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse);
|
const directiveStatements = node.directives.map(d => this.directiveToStmt(d));
|
node.body = directiveStatements.concat(node.body);
|
delete node.directives;
|
}
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
|
this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true);
|
if (method.typeParameters) {
|
method.value.typeParameters = method.typeParameters;
|
delete method.typeParameters;
|
}
|
classBody.body.push(method);
|
}
|
parsePrivateName() {
|
const node = super.parsePrivateName();
|
{
|
if (!this.getPluginOption("estree", "classFeatures")) {
|
return node;
|
}
|
}
|
return this.convertPrivateNameToPrivateIdentifier(node);
|
}
|
convertPrivateNameToPrivateIdentifier(node) {
|
const name = super.getPrivateNameSV(node);
|
node = node;
|
delete node.id;
|
node.name = name;
|
node.type = "PrivateIdentifier";
|
return node;
|
}
|
isPrivateName(node) {
|
{
|
if (!this.getPluginOption("estree", "classFeatures")) {
|
return super.isPrivateName(node);
|
}
|
}
|
return node.type === "PrivateIdentifier";
|
}
|
getPrivateNameSV(node) {
|
{
|
if (!this.getPluginOption("estree", "classFeatures")) {
|
return super.getPrivateNameSV(node);
|
}
|
}
|
return node.name;
|
}
|
parseLiteral(value, type) {
|
const node = super.parseLiteral(value, type);
|
node.raw = node.extra.raw;
|
delete node.extra;
|
return node;
|
}
|
parseFunctionBody(node, allowExpression, isMethod = false) {
|
super.parseFunctionBody(node, allowExpression, isMethod);
|
node.expression = node.body.type !== "BlockStatement";
|
}
|
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
|
let funcNode = this.startNode();
|
funcNode.kind = node.kind;
|
funcNode = super.parseMethod(funcNode, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
|
funcNode.type = "FunctionExpression";
|
delete funcNode.kind;
|
node.value = funcNode;
|
if (type === "ClassPrivateMethod") {
|
node.computed = false;
|
}
|
return this.finishNode(node, "MethodDefinition");
|
}
|
parseClassProperty(...args) {
|
const propertyNode = super.parseClassProperty(...args);
|
{
|
if (!this.getPluginOption("estree", "classFeatures")) {
|
return propertyNode;
|
}
|
}
|
propertyNode.type = "PropertyDefinition";
|
return propertyNode;
|
}
|
parseClassPrivateProperty(...args) {
|
const propertyNode = super.parseClassPrivateProperty(...args);
|
{
|
if (!this.getPluginOption("estree", "classFeatures")) {
|
return propertyNode;
|
}
|
}
|
propertyNode.type = "PropertyDefinition";
|
propertyNode.computed = false;
|
return propertyNode;
|
}
|
parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
|
const node = super.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor);
|
if (node) {
|
node.type = "Property";
|
if (node.kind === "method") {
|
node.kind = "init";
|
}
|
node.shorthand = false;
|
}
|
return node;
|
}
|
parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
|
const node = super.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
|
if (node) {
|
node.kind = "init";
|
node.type = "Property";
|
}
|
return node;
|
}
|
isValidLVal(type, isUnparenthesizedInAssign, binding) {
|
return type === "Property" ? "value" : super.isValidLVal(type, isUnparenthesizedInAssign, binding);
|
}
|
isAssignable(node, isBinding) {
|
if (node != null && this.isObjectProperty(node)) {
|
return this.isAssignable(node.value, isBinding);
|
}
|
return super.isAssignable(node, isBinding);
|
}
|
toAssignable(node, isLHS = false) {
|
if (node != null && this.isObjectProperty(node)) {
|
const {
|
key,
|
value
|
} = node;
|
if (this.isPrivateName(key)) {
|
this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
|
}
|
this.toAssignable(value, isLHS);
|
} else {
|
super.toAssignable(node, isLHS);
|
}
|
}
|
toAssignableObjectExpressionProp(prop, isLast, isLHS) {
|
if (prop.kind === "get" || prop.kind === "set") {
|
this.raise(Errors.PatternHasAccessor, {
|
at: prop.key
|
});
|
} else if (prop.method) {
|
this.raise(Errors.PatternHasMethod, {
|
at: prop.key
|
});
|
} else {
|
super.toAssignableObjectExpressionProp(prop, isLast, isLHS);
|
}
|
}
|
finishCallExpression(unfinished, optional) {
|
const node = super.finishCallExpression(unfinished, optional);
|
if (node.callee.type === "Import") {
|
node.type = "ImportExpression";
|
node.source = node.arguments[0];
|
if (this.hasPlugin("importAssertions")) {
|
var _node$arguments$;
|
node.attributes = (_node$arguments$ = node.arguments[1]) != null ? _node$arguments$ : null;
|
}
|
delete node.arguments;
|
delete node.callee;
|
}
|
return node;
|
}
|
toReferencedArguments(node) {
|
if (node.type === "ImportExpression") {
|
return;
|
}
|
super.toReferencedArguments(node);
|
}
|
parseExport(unfinished, decorators) {
|
const exportStartLoc = this.state.lastTokStartLoc;
|
const node = super.parseExport(unfinished, decorators);
|
switch (node.type) {
|
case "ExportAllDeclaration":
|
node.exported = null;
|
break;
|
case "ExportNamedDeclaration":
|
if (node.specifiers.length === 1 && node.specifiers[0].type === "ExportNamespaceSpecifier") {
|
node.type = "ExportAllDeclaration";
|
node.exported = node.specifiers[0].exported;
|
delete node.specifiers;
|
}
|
case "ExportDefaultDeclaration":
|
{
|
var _declaration$decorato;
|
const {
|
declaration
|
} = node;
|
if ((declaration == null ? void 0 : declaration.type) === "ClassDeclaration" && ((_declaration$decorato = declaration.decorators) == null ? void 0 : _declaration$decorato.length) > 0 && declaration.start === node.start) {
|
this.resetStartLocation(node, exportStartLoc);
|
}
|
}
|
break;
|
}
|
return node;
|
}
|
parseSubscript(base, startLoc, noCalls, state) {
|
const node = super.parseSubscript(base, startLoc, noCalls, state);
|
if (state.optionalChainMember) {
|
if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
|
node.type = node.type.substring(8);
|
}
|
if (state.stop) {
|
const chain = this.startNodeAtNode(node);
|
chain.expression = node;
|
return this.finishNode(chain, "ChainExpression");
|
}
|
} else if (node.type === "MemberExpression" || node.type === "CallExpression") {
|
node.optional = false;
|
}
|
return node;
|
}
|
hasPropertyAsPrivateName(node) {
|
if (node.type === "ChainExpression") {
|
node = node.expression;
|
}
|
return super.hasPropertyAsPrivateName(node);
|
}
|
isObjectProperty(node) {
|
return node.type === "Property" && node.kind === "init" && !node.method;
|
}
|
isObjectMethod(node) {
|
return node.method || node.kind === "get" || node.kind === "set";
|
}
|
finishNodeAt(node, type, endLoc) {
|
return toESTreeLocation(super.finishNodeAt(node, type, endLoc));
|
}
|
resetStartLocation(node, startLoc) {
|
super.resetStartLocation(node, startLoc);
|
toESTreeLocation(node);
|
}
|
resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
|
super.resetEndLocation(node, endLoc);
|
toESTreeLocation(node);
|
}
|
};
|
let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
|
let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
|
const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
|
const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
|
nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
|
const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 4026, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 757, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938, 6, 4191];
|
const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 81, 2, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 9, 5351, 0, 7, 14, 13835, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 983, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
|
function isInAstralSet(code, set) {
|
let pos = 0x10000;
|
for (let i = 0, length = set.length; i < length; i += 2) {
|
pos += set[i];
|
if (pos > code) return false;
|
pos += set[i + 1];
|
if (pos >= code) return true;
|
}
|
return false;
|
}
|
function isIdentifierStart(code) {
|
if (code < 65) return code === 36;
|
if (code <= 90) return true;
|
if (code < 97) return code === 95;
|
if (code <= 122) return true;
|
if (code <= 0xffff) {
|
return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
|
}
|
return isInAstralSet(code, astralIdentifierStartCodes);
|
}
|
function isIdentifierChar(code) {
|
if (code < 48) return code === 36;
|
if (code < 58) return true;
|
if (code < 65) return false;
|
if (code <= 90) return true;
|
if (code < 97) return code === 95;
|
if (code <= 122) return true;
|
if (code <= 0xffff) {
|
return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
|
}
|
return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
|
}
|
const reservedWords = {
|
keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
|
strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
|
strictBind: ["eval", "arguments"]
|
};
|
const keywords = new Set(reservedWords.keyword);
|
const reservedWordsStrictSet = new Set(reservedWords.strict);
|
const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
|
function isReservedWord(word, inModule) {
|
return inModule && word === "await" || word === "enum";
|
}
|
function isStrictReservedWord(word, inModule) {
|
return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
|
}
|
function isStrictBindOnlyReservedWord(word) {
|
return reservedWordsStrictBindSet.has(word);
|
}
|
function isStrictBindReservedWord(word, inModule) {
|
return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
|
}
|
function isKeyword(word) {
|
return keywords.has(word);
|
}
|
function isIteratorStart(current, next, next2) {
|
return current === 64 && next === 64 && isIdentifierStart(next2);
|
}
|
const reservedWordLikeSet = new Set(["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield", "eval", "arguments", "enum", "await"]);
|
function canBeReservedWord(word) {
|
return reservedWordLikeSet.has(word);
|
}
|
const SCOPE_OTHER = 0b000000000,
|
SCOPE_PROGRAM = 0b000000001,
|
SCOPE_FUNCTION = 0b000000010,
|
SCOPE_ARROW = 0b000000100,
|
SCOPE_SIMPLE_CATCH = 0b000001000,
|
SCOPE_SUPER = 0b000010000,
|
SCOPE_DIRECT_SUPER = 0b000100000,
|
SCOPE_CLASS = 0b001000000,
|
SCOPE_STATIC_BLOCK = 0b010000000,
|
SCOPE_TS_MODULE = 0b100000000,
|
SCOPE_VAR = SCOPE_PROGRAM | SCOPE_FUNCTION | SCOPE_STATIC_BLOCK | SCOPE_TS_MODULE;
|
const BIND_KIND_VALUE = 0b0000000000001,
|
BIND_KIND_TYPE = 0b0000000000010,
|
BIND_SCOPE_VAR = 0b0000000000100,
|
BIND_SCOPE_LEXICAL = 0b0000000001000,
|
BIND_SCOPE_FUNCTION = 0b0000000010000,
|
BIND_FLAGS_NONE = 0b00000001000000,
|
BIND_FLAGS_CLASS = 0b00000010000000,
|
BIND_FLAGS_TS_ENUM = 0b00000100000000,
|
BIND_FLAGS_TS_CONST_ENUM = 0b00001000000000,
|
BIND_FLAGS_TS_EXPORT_ONLY = 0b00010000000000,
|
BIND_FLAGS_FLOW_DECLARE_FN = 0b00100000000000,
|
BIND_FLAGS_TS_IMPORT = 0b01000000000000,
|
BIND_FLAGS_NO_LET_IN_LEXICAL = 0b10000000000000;
|
const BIND_CLASS = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_CLASS | BIND_FLAGS_NO_LET_IN_LEXICAL,
|
BIND_LEXICAL = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | BIND_FLAGS_NO_LET_IN_LEXICAL,
|
BIND_CATCH_PARAM = BIND_KIND_VALUE | 0 | BIND_SCOPE_LEXICAL | 0,
|
BIND_VAR = BIND_KIND_VALUE | 0 | BIND_SCOPE_VAR | 0,
|
BIND_FUNCTION = BIND_KIND_VALUE | 0 | BIND_SCOPE_FUNCTION | 0,
|
BIND_TS_INTERFACE = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_CLASS,
|
BIND_TS_TYPE = 0 | BIND_KIND_TYPE | 0 | 0,
|
BIND_TS_ENUM = BIND_KIND_VALUE | BIND_KIND_TYPE | BIND_SCOPE_LEXICAL | BIND_FLAGS_TS_ENUM | BIND_FLAGS_NO_LET_IN_LEXICAL,
|
BIND_TS_AMBIENT = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,
|
BIND_NONE = 0 | 0 | 0 | BIND_FLAGS_NONE,
|
BIND_OUTSIDE = BIND_KIND_VALUE | 0 | 0 | BIND_FLAGS_NONE,
|
BIND_TS_CONST_ENUM = BIND_TS_ENUM | BIND_FLAGS_TS_CONST_ENUM,
|
BIND_TS_NAMESPACE = 0 | 0 | 0 | BIND_FLAGS_TS_EXPORT_ONLY,
|
BIND_TS_TYPE_IMPORT = 0 | BIND_KIND_TYPE | 0 | BIND_FLAGS_TS_IMPORT,
|
BIND_FLOW_DECLARE_FN = BIND_FLAGS_FLOW_DECLARE_FN;
|
const CLASS_ELEMENT_FLAG_STATIC = 0b100,
|
CLASS_ELEMENT_KIND_GETTER = 0b010,
|
CLASS_ELEMENT_KIND_SETTER = 0b001,
|
CLASS_ELEMENT_KIND_ACCESSOR = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_KIND_SETTER;
|
const CLASS_ELEMENT_STATIC_GETTER = CLASS_ELEMENT_KIND_GETTER | CLASS_ELEMENT_FLAG_STATIC,
|
CLASS_ELEMENT_STATIC_SETTER = CLASS_ELEMENT_KIND_SETTER | CLASS_ELEMENT_FLAG_STATIC,
|
CLASS_ELEMENT_INSTANCE_GETTER = CLASS_ELEMENT_KIND_GETTER,
|
CLASS_ELEMENT_INSTANCE_SETTER = CLASS_ELEMENT_KIND_SETTER,
|
CLASS_ELEMENT_OTHER = 0;
|
class Scope {
|
constructor(flags) {
|
this.var = new Set();
|
this.lexical = new Set();
|
this.functions = new Set();
|
this.flags = flags;
|
}
|
}
|
class ScopeHandler {
|
constructor(parser, inModule) {
|
this.parser = void 0;
|
this.scopeStack = [];
|
this.inModule = void 0;
|
this.undefinedExports = new Map();
|
this.parser = parser;
|
this.inModule = inModule;
|
}
|
get inTopLevel() {
|
return (this.currentScope().flags & SCOPE_PROGRAM) > 0;
|
}
|
get inFunction() {
|
return (this.currentVarScopeFlags() & SCOPE_FUNCTION) > 0;
|
}
|
get allowSuper() {
|
return (this.currentThisScopeFlags() & SCOPE_SUPER) > 0;
|
}
|
get allowDirectSuper() {
|
return (this.currentThisScopeFlags() & SCOPE_DIRECT_SUPER) > 0;
|
}
|
get inClass() {
|
return (this.currentThisScopeFlags() & SCOPE_CLASS) > 0;
|
}
|
get inClassAndNotInNonArrowFunction() {
|
const flags = this.currentThisScopeFlags();
|
return (flags & SCOPE_CLASS) > 0 && (flags & SCOPE_FUNCTION) === 0;
|
}
|
get inStaticBlock() {
|
for (let i = this.scopeStack.length - 1;; i--) {
|
const {
|
flags
|
} = this.scopeStack[i];
|
if (flags & SCOPE_STATIC_BLOCK) {
|
return true;
|
}
|
if (flags & (SCOPE_VAR | SCOPE_CLASS)) {
|
return false;
|
}
|
}
|
}
|
get inNonArrowFunction() {
|
return (this.currentThisScopeFlags() & SCOPE_FUNCTION) > 0;
|
}
|
get treatFunctionsAsVar() {
|
return this.treatFunctionsAsVarInScope(this.currentScope());
|
}
|
createScope(flags) {
|
return new Scope(flags);
|
}
|
enter(flags) {
|
this.scopeStack.push(this.createScope(flags));
|
}
|
exit() {
|
const scope = this.scopeStack.pop();
|
return scope.flags;
|
}
|
treatFunctionsAsVarInScope(scope) {
|
return !!(scope.flags & (SCOPE_FUNCTION | SCOPE_STATIC_BLOCK) || !this.parser.inModule && scope.flags & SCOPE_PROGRAM);
|
}
|
declareName(name, bindingType, loc) {
|
let scope = this.currentScope();
|
if (bindingType & BIND_SCOPE_LEXICAL || bindingType & BIND_SCOPE_FUNCTION) {
|
this.checkRedeclarationInScope(scope, name, bindingType, loc);
|
if (bindingType & BIND_SCOPE_FUNCTION) {
|
scope.functions.add(name);
|
} else {
|
scope.lexical.add(name);
|
}
|
if (bindingType & BIND_SCOPE_LEXICAL) {
|
this.maybeExportDefined(scope, name);
|
}
|
} else if (bindingType & BIND_SCOPE_VAR) {
|
for (let i = this.scopeStack.length - 1; i >= 0; --i) {
|
scope = this.scopeStack[i];
|
this.checkRedeclarationInScope(scope, name, bindingType, loc);
|
scope.var.add(name);
|
this.maybeExportDefined(scope, name);
|
if (scope.flags & SCOPE_VAR) break;
|
}
|
}
|
if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) {
|
this.undefinedExports.delete(name);
|
}
|
}
|
maybeExportDefined(scope, name) {
|
if (this.parser.inModule && scope.flags & SCOPE_PROGRAM) {
|
this.undefinedExports.delete(name);
|
}
|
}
|
checkRedeclarationInScope(scope, name, bindingType, loc) {
|
if (this.isRedeclaredInScope(scope, name, bindingType)) {
|
this.parser.raise(Errors.VarRedeclaration, {
|
at: loc,
|
identifierName: name
|
});
|
}
|
}
|
isRedeclaredInScope(scope, name, bindingType) {
|
if (!(bindingType & BIND_KIND_VALUE)) return false;
|
if (bindingType & BIND_SCOPE_LEXICAL) {
|
return scope.lexical.has(name) || scope.functions.has(name) || scope.var.has(name);
|
}
|
if (bindingType & BIND_SCOPE_FUNCTION) {
|
return scope.lexical.has(name) || !this.treatFunctionsAsVarInScope(scope) && scope.var.has(name);
|
}
|
return scope.lexical.has(name) && !(scope.flags & SCOPE_SIMPLE_CATCH && scope.lexical.values().next().value === name) || !this.treatFunctionsAsVarInScope(scope) && scope.functions.has(name);
|
}
|
checkLocalExport(id) {
|
const {
|
name
|
} = id;
|
const topLevelScope = this.scopeStack[0];
|
if (!topLevelScope.lexical.has(name) && !topLevelScope.var.has(name) && !topLevelScope.functions.has(name)) {
|
this.undefinedExports.set(name, id.loc.start);
|
}
|
}
|
currentScope() {
|
return this.scopeStack[this.scopeStack.length - 1];
|
}
|
currentVarScopeFlags() {
|
for (let i = this.scopeStack.length - 1;; i--) {
|
const {
|
flags
|
} = this.scopeStack[i];
|
if (flags & SCOPE_VAR) {
|
return flags;
|
}
|
}
|
}
|
currentThisScopeFlags() {
|
for (let i = this.scopeStack.length - 1;; i--) {
|
const {
|
flags
|
} = this.scopeStack[i];
|
if (flags & (SCOPE_VAR | SCOPE_CLASS) && !(flags & SCOPE_ARROW)) {
|
return flags;
|
}
|
}
|
}
|
}
|
class FlowScope extends Scope {
|
constructor(...args) {
|
super(...args);
|
this.declareFunctions = new Set();
|
}
|
}
|
class FlowScopeHandler extends ScopeHandler {
|
createScope(flags) {
|
return new FlowScope(flags);
|
}
|
declareName(name, bindingType, loc) {
|
const scope = this.currentScope();
|
if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {
|
this.checkRedeclarationInScope(scope, name, bindingType, loc);
|
this.maybeExportDefined(scope, name);
|
scope.declareFunctions.add(name);
|
return;
|
}
|
super.declareName(name, bindingType, loc);
|
}
|
isRedeclaredInScope(scope, name, bindingType) {
|
if (super.isRedeclaredInScope(scope, name, bindingType)) return true;
|
if (bindingType & BIND_FLAGS_FLOW_DECLARE_FN) {
|
return !scope.declareFunctions.has(name) && (scope.lexical.has(name) || scope.functions.has(name));
|
}
|
return false;
|
}
|
checkLocalExport(id) {
|
if (!this.scopeStack[0].declareFunctions.has(id.name)) {
|
super.checkLocalExport(id);
|
}
|
}
|
}
|
class BaseParser {
|
constructor() {
|
this.sawUnambiguousESM = false;
|
this.ambiguousScriptDifferentAst = false;
|
}
|
hasPlugin(pluginConfig) {
|
if (typeof pluginConfig === "string") {
|
return this.plugins.has(pluginConfig);
|
} else {
|
const [pluginName, pluginOptions] = pluginConfig;
|
if (!this.hasPlugin(pluginName)) {
|
return false;
|
}
|
const actualOptions = this.plugins.get(pluginName);
|
for (const key of Object.keys(pluginOptions)) {
|
if ((actualOptions == null ? void 0 : actualOptions[key]) !== pluginOptions[key]) {
|
return false;
|
}
|
}
|
return true;
|
}
|
}
|
getPluginOption(plugin, name) {
|
var _this$plugins$get;
|
return (_this$plugins$get = this.plugins.get(plugin)) == null ? void 0 : _this$plugins$get[name];
|
}
|
}
|
function setTrailingComments(node, comments) {
|
if (node.trailingComments === undefined) {
|
node.trailingComments = comments;
|
} else {
|
node.trailingComments.unshift(...comments);
|
}
|
}
|
function setLeadingComments(node, comments) {
|
if (node.leadingComments === undefined) {
|
node.leadingComments = comments;
|
} else {
|
node.leadingComments.unshift(...comments);
|
}
|
}
|
function setInnerComments(node, comments) {
|
if (node.innerComments === undefined) {
|
node.innerComments = comments;
|
} else {
|
node.innerComments.unshift(...comments);
|
}
|
}
|
function adjustInnerComments(node, elements, commentWS) {
|
let lastElement = null;
|
let i = elements.length;
|
while (lastElement === null && i > 0) {
|
lastElement = elements[--i];
|
}
|
if (lastElement === null || lastElement.start > commentWS.start) {
|
setInnerComments(node, commentWS.comments);
|
} else {
|
setTrailingComments(lastElement, commentWS.comments);
|
}
|
}
|
class CommentsParser extends BaseParser {
|
addComment(comment) {
|
if (this.filename) comment.loc.filename = this.filename;
|
this.state.comments.push(comment);
|
}
|
processComment(node) {
|
const {
|
commentStack
|
} = this.state;
|
const commentStackLength = commentStack.length;
|
if (commentStackLength === 0) return;
|
let i = commentStackLength - 1;
|
const lastCommentWS = commentStack[i];
|
if (lastCommentWS.start === node.end) {
|
lastCommentWS.leadingNode = node;
|
i--;
|
}
|
const {
|
start: nodeStart
|
} = node;
|
for (; i >= 0; i--) {
|
const commentWS = commentStack[i];
|
const commentEnd = commentWS.end;
|
if (commentEnd > nodeStart) {
|
commentWS.containingNode = node;
|
this.finalizeComment(commentWS);
|
commentStack.splice(i, 1);
|
} else {
|
if (commentEnd === nodeStart) {
|
commentWS.trailingNode = node;
|
}
|
break;
|
}
|
}
|
}
|
finalizeComment(commentWS) {
|
const {
|
comments
|
} = commentWS;
|
if (commentWS.leadingNode !== null || commentWS.trailingNode !== null) {
|
if (commentWS.leadingNode !== null) {
|
setTrailingComments(commentWS.leadingNode, comments);
|
}
|
if (commentWS.trailingNode !== null) {
|
setLeadingComments(commentWS.trailingNode, comments);
|
}
|
} else {
|
const {
|
containingNode: node,
|
start: commentStart
|
} = commentWS;
|
if (this.input.charCodeAt(commentStart - 1) === 44) {
|
switch (node.type) {
|
case "ObjectExpression":
|
case "ObjectPattern":
|
case "RecordExpression":
|
adjustInnerComments(node, node.properties, commentWS);
|
break;
|
case "CallExpression":
|
case "OptionalCallExpression":
|
adjustInnerComments(node, node.arguments, commentWS);
|
break;
|
case "FunctionDeclaration":
|
case "FunctionExpression":
|
case "ArrowFunctionExpression":
|
case "ObjectMethod":
|
case "ClassMethod":
|
case "ClassPrivateMethod":
|
adjustInnerComments(node, node.params, commentWS);
|
break;
|
case "ArrayExpression":
|
case "ArrayPattern":
|
case "TupleExpression":
|
adjustInnerComments(node, node.elements, commentWS);
|
break;
|
case "ExportNamedDeclaration":
|
case "ImportDeclaration":
|
adjustInnerComments(node, node.specifiers, commentWS);
|
break;
|
default:
|
{
|
setInnerComments(node, comments);
|
}
|
}
|
} else {
|
setInnerComments(node, comments);
|
}
|
}
|
}
|
finalizeRemainingComments() {
|
const {
|
commentStack
|
} = this.state;
|
for (let i = commentStack.length - 1; i >= 0; i--) {
|
this.finalizeComment(commentStack[i]);
|
}
|
this.state.commentStack = [];
|
}
|
resetPreviousNodeTrailingComments(node) {
|
const {
|
commentStack
|
} = this.state;
|
const {
|
length
|
} = commentStack;
|
if (length === 0) return;
|
const commentWS = commentStack[length - 1];
|
if (commentWS.leadingNode === node) {
|
commentWS.leadingNode = null;
|
}
|
}
|
takeSurroundingComments(node, start, end) {
|
const {
|
commentStack
|
} = this.state;
|
const commentStackLength = commentStack.length;
|
if (commentStackLength === 0) return;
|
let i = commentStackLength - 1;
|
for (; i >= 0; i--) {
|
const commentWS = commentStack[i];
|
const commentEnd = commentWS.end;
|
const commentStart = commentWS.start;
|
if (commentStart === end) {
|
commentWS.leadingNode = node;
|
} else if (commentEnd === start) {
|
commentWS.trailingNode = node;
|
} else if (commentEnd < start) {
|
break;
|
}
|
}
|
}
|
}
|
const lineBreak = /\r\n?|[\n\u2028\u2029]/;
|
const lineBreakG = new RegExp(lineBreak.source, "g");
|
function isNewLine(code) {
|
switch (code) {
|
case 10:
|
case 13:
|
case 8232:
|
case 8233:
|
return true;
|
default:
|
return false;
|
}
|
}
|
const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
|
const skipWhiteSpaceInLine = /(?:[^\S\n\r\u2028\u2029]|\/\/.*|\/\*.*?\*\/)*/y;
|
const skipWhiteSpaceToLineBreak = new RegExp("(?=(" + skipWhiteSpaceInLine.source + "))\\1" + /(?=[\n\r\u2028\u2029]|\/\*(?!.*?\*\/)|$)/.source, "y");
|
function isWhitespace(code) {
|
switch (code) {
|
case 0x0009:
|
case 0x000b:
|
case 0x000c:
|
case 32:
|
case 160:
|
case 5760:
|
case 0x2000:
|
case 0x2001:
|
case 0x2002:
|
case 0x2003:
|
case 0x2004:
|
case 0x2005:
|
case 0x2006:
|
case 0x2007:
|
case 0x2008:
|
case 0x2009:
|
case 0x200a:
|
case 0x202f:
|
case 0x205f:
|
case 0x3000:
|
case 0xfeff:
|
return true;
|
default:
|
return false;
|
}
|
}
|
class State {
|
constructor() {
|
this.strict = void 0;
|
this.curLine = void 0;
|
this.lineStart = void 0;
|
this.startLoc = void 0;
|
this.endLoc = void 0;
|
this.errors = [];
|
this.potentialArrowAt = -1;
|
this.noArrowAt = [];
|
this.noArrowParamsConversionAt = [];
|
this.maybeInArrowParameters = false;
|
this.inType = false;
|
this.noAnonFunctionType = false;
|
this.hasFlowComment = false;
|
this.isAmbientContext = false;
|
this.inAbstractClass = false;
|
this.inDisallowConditionalTypesContext = false;
|
this.topicContext = {
|
maxNumOfResolvableTopics: 0,
|
maxTopicIndex: null
|
};
|
this.soloAwait = false;
|
this.inFSharpPipelineDirectBody = false;
|
this.labels = [];
|
this.comments = [];
|
this.commentStack = [];
|
this.pos = 0;
|
this.type = 137;
|
this.value = null;
|
this.start = 0;
|
this.end = 0;
|
this.lastTokEndLoc = null;
|
this.lastTokStartLoc = null;
|
this.lastTokStart = 0;
|
this.context = [types$1.brace];
|
this.canStartJSXElement = true;
|
this.containsEsc = false;
|
this.firstInvalidTemplateEscapePos = null;
|
this.strictErrors = new Map();
|
this.tokensLength = 0;
|
}
|
init({
|
strictMode,
|
sourceType,
|
startLine,
|
startColumn
|
}) {
|
this.strict = strictMode === false ? false : strictMode === true ? true : sourceType === "module";
|
this.curLine = startLine;
|
this.lineStart = -startColumn;
|
this.startLoc = this.endLoc = new Position(startLine, startColumn, 0);
|
}
|
curPosition() {
|
return new Position(this.curLine, this.pos - this.lineStart, this.pos);
|
}
|
clone(skipArrays) {
|
const state = new State();
|
const keys = Object.keys(this);
|
for (let i = 0, length = keys.length; i < length; i++) {
|
const key = keys[i];
|
let val = this[key];
|
if (!skipArrays && Array.isArray(val)) {
|
val = val.slice();
|
}
|
state[key] = val;
|
}
|
return state;
|
}
|
}
|
var _isDigit = function isDigit(code) {
|
return code >= 48 && code <= 57;
|
};
|
const forbiddenNumericSeparatorSiblings = {
|
decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
|
hex: new Set([46, 88, 95, 120])
|
};
|
const isAllowedNumericSeparatorSibling = {
|
bin: ch => ch === 48 || ch === 49,
|
oct: ch => ch >= 48 && ch <= 55,
|
dec: ch => ch >= 48 && ch <= 57,
|
hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
|
};
|
function readStringContents(type, input, pos, lineStart, curLine, errors) {
|
const initialPos = pos;
|
const initialLineStart = lineStart;
|
const initialCurLine = curLine;
|
let out = "";
|
let firstInvalidLoc = null;
|
let chunkStart = pos;
|
const {
|
length
|
} = input;
|
for (;;) {
|
if (pos >= length) {
|
errors.unterminated(initialPos, initialLineStart, initialCurLine);
|
out += input.slice(chunkStart, pos);
|
break;
|
}
|
const ch = input.charCodeAt(pos);
|
if (isStringEnd(type, ch, input, pos)) {
|
out += input.slice(chunkStart, pos);
|
break;
|
}
|
if (ch === 92) {
|
out += input.slice(chunkStart, pos);
|
const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
|
if (res.ch === null && !firstInvalidLoc) {
|
firstInvalidLoc = {
|
pos,
|
lineStart,
|
curLine
|
};
|
} else {
|
out += res.ch;
|
}
|
({
|
pos,
|
lineStart,
|
curLine
|
} = res);
|
chunkStart = pos;
|
} else if (ch === 8232 || ch === 8233) {
|
++pos;
|
++curLine;
|
lineStart = pos;
|
} else if (ch === 10 || ch === 13) {
|
if (type === "template") {
|
out += input.slice(chunkStart, pos) + "\n";
|
++pos;
|
if (ch === 13 && input.charCodeAt(pos) === 10) {
|
++pos;
|
}
|
++curLine;
|
chunkStart = lineStart = pos;
|
} else {
|
errors.unterminated(initialPos, initialLineStart, initialCurLine);
|
}
|
} else {
|
++pos;
|
}
|
}
|
return {
|
pos,
|
str: out,
|
firstInvalidLoc,
|
lineStart,
|
curLine,
|
containsInvalid: !!firstInvalidLoc
|
};
|
}
|
function isStringEnd(type, ch, input, pos) {
|
if (type === "template") {
|
return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
|
}
|
return ch === (type === "double" ? 34 : 39);
|
}
|
function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
|
const throwOnInvalid = !inTemplate;
|
pos++;
|
const res = ch => ({
|
pos,
|
ch,
|
lineStart,
|
curLine
|
});
|
const ch = input.charCodeAt(pos++);
|
switch (ch) {
|
case 110:
|
return res("\n");
|
case 114:
|
return res("\r");
|
case 120:
|
{
|
let code;
|
({
|
code,
|
pos
|
} = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
|
return res(code === null ? null : String.fromCharCode(code));
|
}
|
case 117:
|
{
|
let code;
|
({
|
code,
|
pos
|
} = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
|
return res(code === null ? null : String.fromCodePoint(code));
|
}
|
case 116:
|
return res("\t");
|
case 98:
|
return res("\b");
|
case 118:
|
return res("\u000b");
|
case 102:
|
return res("\f");
|
case 13:
|
if (input.charCodeAt(pos) === 10) {
|
++pos;
|
}
|
case 10:
|
lineStart = pos;
|
++curLine;
|
case 8232:
|
case 8233:
|
return res("");
|
case 56:
|
case 57:
|
if (inTemplate) {
|
return res(null);
|
} else {
|
errors.strictNumericEscape(pos - 1, lineStart, curLine);
|
}
|
default:
|
if (ch >= 48 && ch <= 55) {
|
const startPos = pos - 1;
|
const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
|
let octalStr = match[0];
|
let octal = parseInt(octalStr, 8);
|
if (octal > 255) {
|
octalStr = octalStr.slice(0, -1);
|
octal = parseInt(octalStr, 8);
|
}
|
pos += octalStr.length - 1;
|
const next = input.charCodeAt(pos);
|
if (octalStr !== "0" || next === 56 || next === 57) {
|
if (inTemplate) {
|
return res(null);
|
} else {
|
errors.strictNumericEscape(startPos, lineStart, curLine);
|
}
|
}
|
return res(String.fromCharCode(octal));
|
}
|
return res(String.fromCharCode(ch));
|
}
|
}
|
function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
|
const initialPos = pos;
|
let n;
|
({
|
n,
|
pos
|
} = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
|
if (n === null) {
|
if (throwOnInvalid) {
|
errors.invalidEscapeSequence(initialPos, lineStart, curLine);
|
} else {
|
pos = initialPos - 1;
|
}
|
}
|
return {
|
code: n,
|
pos
|
};
|
}
|
function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
|
const start = pos;
|
const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
|
const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
|
let invalid = false;
|
let total = 0;
|
for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
|
const code = input.charCodeAt(pos);
|
let val;
|
if (code === 95 && allowNumSeparator !== "bail") {
|
const prev = input.charCodeAt(pos - 1);
|
const next = input.charCodeAt(pos + 1);
|
if (!allowNumSeparator) {
|
if (bailOnError) return {
|
n: null,
|
pos
|
};
|
errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
|
} else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
|
if (bailOnError) return {
|
n: null,
|
pos
|
};
|
errors.unexpectedNumericSeparator(pos, lineStart, curLine);
|
}
|
++pos;
|
continue;
|
}
|
if (code >= 97) {
|
val = code - 97 + 10;
|
} else if (code >= 65) {
|
val = code - 65 + 10;
|
} else if (_isDigit(code)) {
|
val = code - 48;
|
} else {
|
val = Infinity;
|
}
|
if (val >= radix) {
|
if (val <= 9 && bailOnError) {
|
return {
|
n: null,
|
pos
|
};
|
} else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
|
val = 0;
|
} else if (forceLen) {
|
val = 0;
|
invalid = true;
|
} else {
|
break;
|
}
|
}
|
++pos;
|
total = total * radix + val;
|
}
|
if (pos === start || len != null && pos - start !== len || invalid) {
|
return {
|
n: null,
|
pos
|
};
|
}
|
return {
|
n: total,
|
pos
|
};
|
}
|
function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
|
const ch = input.charCodeAt(pos);
|
let code;
|
if (ch === 123) {
|
++pos;
|
({
|
code,
|
pos
|
} = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
|
++pos;
|
if (code !== null && code > 0x10ffff) {
|
if (throwOnInvalid) {
|
errors.invalidCodePoint(pos, lineStart, curLine);
|
} else {
|
return {
|
code: null,
|
pos
|
};
|
}
|
}
|
} else {
|
({
|
code,
|
pos
|
} = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
|
}
|
return {
|
code,
|
pos
|
};
|
}
|
const _excluded = ["at"],
|
_excluded2 = ["at"];
|
function buildPosition(pos, lineStart, curLine) {
|
return new Position(curLine, pos - lineStart, pos);
|
}
|
const VALID_REGEX_FLAGS = new Set([103, 109, 115, 105, 121, 117, 100, 118]);
|
class Token {
|
constructor(state) {
|
this.type = state.type;
|
this.value = state.value;
|
this.start = state.start;
|
this.end = state.end;
|
this.loc = new SourceLocation(state.startLoc, state.endLoc);
|
}
|
}
|
class Tokenizer extends CommentsParser {
|
constructor(options, input) {
|
super();
|
this.isLookahead = void 0;
|
this.tokens = [];
|
this.errorHandlers_readInt = {
|
invalidDigit: (pos, lineStart, curLine, radix) => {
|
if (!this.options.errorRecovery) return false;
|
this.raise(Errors.InvalidDigit, {
|
at: buildPosition(pos, lineStart, curLine),
|
radix
|
});
|
return true;
|
},
|
numericSeparatorInEscapeSequence: this.errorBuilder(Errors.NumericSeparatorInEscapeSequence),
|
unexpectedNumericSeparator: this.errorBuilder(Errors.UnexpectedNumericSeparator)
|
};
|
this.errorHandlers_readCodePoint = Object.assign({}, this.errorHandlers_readInt, {
|
invalidEscapeSequence: this.errorBuilder(Errors.InvalidEscapeSequence),
|
invalidCodePoint: this.errorBuilder(Errors.InvalidCodePoint)
|
});
|
this.errorHandlers_readStringContents_string = Object.assign({}, this.errorHandlers_readCodePoint, {
|
strictNumericEscape: (pos, lineStart, curLine) => {
|
this.recordStrictModeErrors(Errors.StrictNumericEscape, {
|
at: buildPosition(pos, lineStart, curLine)
|
});
|
},
|
unterminated: (pos, lineStart, curLine) => {
|
throw this.raise(Errors.UnterminatedString, {
|
at: buildPosition(pos - 1, lineStart, curLine)
|
});
|
}
|
});
|
this.errorHandlers_readStringContents_template = Object.assign({}, this.errorHandlers_readCodePoint, {
|
strictNumericEscape: this.errorBuilder(Errors.StrictNumericEscape),
|
unterminated: (pos, lineStart, curLine) => {
|
throw this.raise(Errors.UnterminatedTemplate, {
|
at: buildPosition(pos, lineStart, curLine)
|
});
|
}
|
});
|
this.state = new State();
|
this.state.init(options);
|
this.input = input;
|
this.length = input.length;
|
this.isLookahead = false;
|
}
|
pushToken(token) {
|
this.tokens.length = this.state.tokensLength;
|
this.tokens.push(token);
|
++this.state.tokensLength;
|
}
|
next() {
|
this.checkKeywordEscapes();
|
if (this.options.tokens) {
|
this.pushToken(new Token(this.state));
|
}
|
this.state.lastTokStart = this.state.start;
|
this.state.lastTokEndLoc = this.state.endLoc;
|
this.state.lastTokStartLoc = this.state.startLoc;
|
this.nextToken();
|
}
|
eat(type) {
|
if (this.match(type)) {
|
this.next();
|
return true;
|
} else {
|
return false;
|
}
|
}
|
match(type) {
|
return this.state.type === type;
|
}
|
createLookaheadState(state) {
|
return {
|
pos: state.pos,
|
value: null,
|
type: state.type,
|
start: state.start,
|
end: state.end,
|
context: [this.curContext()],
|
inType: state.inType,
|
startLoc: state.startLoc,
|
lastTokEndLoc: state.lastTokEndLoc,
|
curLine: state.curLine,
|
lineStart: state.lineStart,
|
curPosition: state.curPosition
|
};
|
}
|
lookahead() {
|
const old = this.state;
|
this.state = this.createLookaheadState(old);
|
this.isLookahead = true;
|
this.nextToken();
|
this.isLookahead = false;
|
const curr = this.state;
|
this.state = old;
|
return curr;
|
}
|
nextTokenStart() {
|
return this.nextTokenStartSince(this.state.pos);
|
}
|
nextTokenStartSince(pos) {
|
skipWhiteSpace.lastIndex = pos;
|
return skipWhiteSpace.test(this.input) ? skipWhiteSpace.lastIndex : pos;
|
}
|
lookaheadCharCode() {
|
return this.input.charCodeAt(this.nextTokenStart());
|
}
|
codePointAtPos(pos) {
|
let cp = this.input.charCodeAt(pos);
|
if ((cp & 0xfc00) === 0xd800 && ++pos < this.input.length) {
|
const trail = this.input.charCodeAt(pos);
|
if ((trail & 0xfc00) === 0xdc00) {
|
cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
|
}
|
}
|
return cp;
|
}
|
setStrict(strict) {
|
this.state.strict = strict;
|
if (strict) {
|
this.state.strictErrors.forEach(([toParseError, at]) => this.raise(toParseError, {
|
at
|
}));
|
this.state.strictErrors.clear();
|
}
|
}
|
curContext() {
|
return this.state.context[this.state.context.length - 1];
|
}
|
nextToken() {
|
this.skipSpace();
|
this.state.start = this.state.pos;
|
if (!this.isLookahead) this.state.startLoc = this.state.curPosition();
|
if (this.state.pos >= this.length) {
|
this.finishToken(137);
|
return;
|
}
|
this.getTokenFromCode(this.codePointAtPos(this.state.pos));
|
}
|
skipBlockComment(commentEnd) {
|
let startLoc;
|
if (!this.isLookahead) startLoc = this.state.curPosition();
|
const start = this.state.pos;
|
const end = this.input.indexOf(commentEnd, start + 2);
|
if (end === -1) {
|
throw this.raise(Errors.UnterminatedComment, {
|
at: this.state.curPosition()
|
});
|
}
|
this.state.pos = end + commentEnd.length;
|
lineBreakG.lastIndex = start + 2;
|
while (lineBreakG.test(this.input) && lineBreakG.lastIndex <= end) {
|
++this.state.curLine;
|
this.state.lineStart = lineBreakG.lastIndex;
|
}
|
if (this.isLookahead) return;
|
const comment = {
|
type: "CommentBlock",
|
value: this.input.slice(start + 2, end),
|
start,
|
end: end + commentEnd.length,
|
loc: new SourceLocation(startLoc, this.state.curPosition())
|
};
|
if (this.options.tokens) this.pushToken(comment);
|
return comment;
|
}
|
skipLineComment(startSkip) {
|
const start = this.state.pos;
|
let startLoc;
|
if (!this.isLookahead) startLoc = this.state.curPosition();
|
let ch = this.input.charCodeAt(this.state.pos += startSkip);
|
if (this.state.pos < this.length) {
|
while (!isNewLine(ch) && ++this.state.pos < this.length) {
|
ch = this.input.charCodeAt(this.state.pos);
|
}
|
}
|
if (this.isLookahead) return;
|
const end = this.state.pos;
|
const value = this.input.slice(start + startSkip, end);
|
const comment = {
|
type: "CommentLine",
|
value,
|
start,
|
end,
|
loc: new SourceLocation(startLoc, this.state.curPosition())
|
};
|
if (this.options.tokens) this.pushToken(comment);
|
return comment;
|
}
|
skipSpace() {
|
const spaceStart = this.state.pos;
|
const comments = [];
|
loop: while (this.state.pos < this.length) {
|
const ch = this.input.charCodeAt(this.state.pos);
|
switch (ch) {
|
case 32:
|
case 160:
|
case 9:
|
++this.state.pos;
|
break;
|
case 13:
|
if (this.input.charCodeAt(this.state.pos + 1) === 10) {
|
++this.state.pos;
|
}
|
case 10:
|
case 8232:
|
case 8233:
|
++this.state.pos;
|
++this.state.curLine;
|
this.state.lineStart = this.state.pos;
|
break;
|
case 47:
|
switch (this.input.charCodeAt(this.state.pos + 1)) {
|
case 42:
|
{
|
const comment = this.skipBlockComment("*/");
|
if (comment !== undefined) {
|
this.addComment(comment);
|
if (this.options.attachComment) comments.push(comment);
|
}
|
break;
|
}
|
case 47:
|
{
|
const comment = this.skipLineComment(2);
|
if (comment !== undefined) {
|
this.addComment(comment);
|
if (this.options.attachComment) comments.push(comment);
|
}
|
break;
|
}
|
default:
|
break loop;
|
}
|
break;
|
default:
|
if (isWhitespace(ch)) {
|
++this.state.pos;
|
} else if (ch === 45 && !this.inModule && this.options.annexB) {
|
const pos = this.state.pos;
|
if (this.input.charCodeAt(pos + 1) === 45 && this.input.charCodeAt(pos + 2) === 62 && (spaceStart === 0 || this.state.lineStart > spaceStart)) {
|
const comment = this.skipLineComment(3);
|
if (comment !== undefined) {
|
this.addComment(comment);
|
if (this.options.attachComment) comments.push(comment);
|
}
|
} else {
|
break loop;
|
}
|
} else if (ch === 60 && !this.inModule && this.options.annexB) {
|
const pos = this.state.pos;
|
if (this.input.charCodeAt(pos + 1) === 33 && this.input.charCodeAt(pos + 2) === 45 && this.input.charCodeAt(pos + 3) === 45) {
|
const comment = this.skipLineComment(4);
|
if (comment !== undefined) {
|
this.addComment(comment);
|
if (this.options.attachComment) comments.push(comment);
|
}
|
} else {
|
break loop;
|
}
|
} else {
|
break loop;
|
}
|
}
|
}
|
if (comments.length > 0) {
|
const end = this.state.pos;
|
const commentWhitespace = {
|
start: spaceStart,
|
end,
|
comments,
|
leadingNode: null,
|
trailingNode: null,
|
containingNode: null
|
};
|
this.state.commentStack.push(commentWhitespace);
|
}
|
}
|
finishToken(type, val) {
|
this.state.end = this.state.pos;
|
this.state.endLoc = this.state.curPosition();
|
const prevType = this.state.type;
|
this.state.type = type;
|
this.state.value = val;
|
if (!this.isLookahead) {
|
this.updateContext(prevType);
|
}
|
}
|
replaceToken(type) {
|
this.state.type = type;
|
this.updateContext();
|
}
|
readToken_numberSign() {
|
if (this.state.pos === 0 && this.readToken_interpreter()) {
|
return;
|
}
|
const nextPos = this.state.pos + 1;
|
const next = this.codePointAtPos(nextPos);
|
if (next >= 48 && next <= 57) {
|
throw this.raise(Errors.UnexpectedDigitAfterHash, {
|
at: this.state.curPosition()
|
});
|
}
|
if (next === 123 || next === 91 && this.hasPlugin("recordAndTuple")) {
|
this.expectPlugin("recordAndTuple");
|
if (this.getPluginOption("recordAndTuple", "syntaxType") === "bar") {
|
throw this.raise(next === 123 ? Errors.RecordExpressionHashIncorrectStartSyntaxType : Errors.TupleExpressionHashIncorrectStartSyntaxType, {
|
at: this.state.curPosition()
|
});
|
}
|
this.state.pos += 2;
|
if (next === 123) {
|
this.finishToken(7);
|
} else {
|
this.finishToken(1);
|
}
|
} else if (isIdentifierStart(next)) {
|
++this.state.pos;
|
this.finishToken(136, this.readWord1(next));
|
} else if (next === 92) {
|
++this.state.pos;
|
this.finishToken(136, this.readWord1());
|
} else {
|
this.finishOp(27, 1);
|
}
|
}
|
readToken_dot() {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next >= 48 && next <= 57) {
|
this.readNumber(true);
|
return;
|
}
|
if (next === 46 && this.input.charCodeAt(this.state.pos + 2) === 46) {
|
this.state.pos += 3;
|
this.finishToken(21);
|
} else {
|
++this.state.pos;
|
this.finishToken(16);
|
}
|
}
|
readToken_slash() {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next === 61) {
|
this.finishOp(31, 2);
|
} else {
|
this.finishOp(56, 1);
|
}
|
}
|
readToken_interpreter() {
|
if (this.state.pos !== 0 || this.length < 2) return false;
|
let ch = this.input.charCodeAt(this.state.pos + 1);
|
if (ch !== 33) return false;
|
const start = this.state.pos;
|
this.state.pos += 1;
|
while (!isNewLine(ch) && ++this.state.pos < this.length) {
|
ch = this.input.charCodeAt(this.state.pos);
|
}
|
const value = this.input.slice(start + 2, this.state.pos);
|
this.finishToken(28, value);
|
return true;
|
}
|
readToken_mult_modulo(code) {
|
let type = code === 42 ? 55 : 54;
|
let width = 1;
|
let next = this.input.charCodeAt(this.state.pos + 1);
|
if (code === 42 && next === 42) {
|
width++;
|
next = this.input.charCodeAt(this.state.pos + 2);
|
type = 57;
|
}
|
if (next === 61 && !this.state.inType) {
|
width++;
|
type = code === 37 ? 33 : 30;
|
}
|
this.finishOp(type, width);
|
}
|
readToken_pipe_amp(code) {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next === code) {
|
if (this.input.charCodeAt(this.state.pos + 2) === 61) {
|
this.finishOp(30, 3);
|
} else {
|
this.finishOp(code === 124 ? 41 : 42, 2);
|
}
|
return;
|
}
|
if (code === 124) {
|
if (next === 62) {
|
this.finishOp(39, 2);
|
return;
|
}
|
if (this.hasPlugin("recordAndTuple") && next === 125) {
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
|
throw this.raise(Errors.RecordExpressionBarIncorrectEndSyntaxType, {
|
at: this.state.curPosition()
|
});
|
}
|
this.state.pos += 2;
|
this.finishToken(9);
|
return;
|
}
|
if (this.hasPlugin("recordAndTuple") && next === 93) {
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
|
throw this.raise(Errors.TupleExpressionBarIncorrectEndSyntaxType, {
|
at: this.state.curPosition()
|
});
|
}
|
this.state.pos += 2;
|
this.finishToken(4);
|
return;
|
}
|
}
|
if (next === 61) {
|
this.finishOp(30, 2);
|
return;
|
}
|
this.finishOp(code === 124 ? 43 : 45, 1);
|
}
|
readToken_caret() {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next === 61 && !this.state.inType) {
|
this.finishOp(32, 2);
|
} else if (next === 94 && this.hasPlugin(["pipelineOperator", {
|
proposal: "hack",
|
topicToken: "^^"
|
}])) {
|
this.finishOp(37, 2);
|
const lookaheadCh = this.input.codePointAt(this.state.pos);
|
if (lookaheadCh === 94) {
|
this.unexpected();
|
}
|
} else {
|
this.finishOp(44, 1);
|
}
|
}
|
readToken_atSign() {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next === 64 && this.hasPlugin(["pipelineOperator", {
|
proposal: "hack",
|
topicToken: "@@"
|
}])) {
|
this.finishOp(38, 2);
|
} else {
|
this.finishOp(26, 1);
|
}
|
}
|
readToken_plus_min(code) {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next === code) {
|
this.finishOp(34, 2);
|
return;
|
}
|
if (next === 61) {
|
this.finishOp(30, 2);
|
} else {
|
this.finishOp(53, 1);
|
}
|
}
|
readToken_lt() {
|
const {
|
pos
|
} = this.state;
|
const next = this.input.charCodeAt(pos + 1);
|
if (next === 60) {
|
if (this.input.charCodeAt(pos + 2) === 61) {
|
this.finishOp(30, 3);
|
return;
|
}
|
this.finishOp(51, 2);
|
return;
|
}
|
if (next === 61) {
|
this.finishOp(49, 2);
|
return;
|
}
|
this.finishOp(47, 1);
|
}
|
readToken_gt() {
|
const {
|
pos
|
} = this.state;
|
const next = this.input.charCodeAt(pos + 1);
|
if (next === 62) {
|
const size = this.input.charCodeAt(pos + 2) === 62 ? 3 : 2;
|
if (this.input.charCodeAt(pos + size) === 61) {
|
this.finishOp(30, size + 1);
|
return;
|
}
|
this.finishOp(52, size);
|
return;
|
}
|
if (next === 61) {
|
this.finishOp(49, 2);
|
return;
|
}
|
this.finishOp(48, 1);
|
}
|
readToken_eq_excl(code) {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next === 61) {
|
this.finishOp(46, this.input.charCodeAt(this.state.pos + 2) === 61 ? 3 : 2);
|
return;
|
}
|
if (code === 61 && next === 62) {
|
this.state.pos += 2;
|
this.finishToken(19);
|
return;
|
}
|
this.finishOp(code === 61 ? 29 : 35, 1);
|
}
|
readToken_question() {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
const next2 = this.input.charCodeAt(this.state.pos + 2);
|
if (next === 63) {
|
if (next2 === 61) {
|
this.finishOp(30, 3);
|
} else {
|
this.finishOp(40, 2);
|
}
|
} else if (next === 46 && !(next2 >= 48 && next2 <= 57)) {
|
this.state.pos += 2;
|
this.finishToken(18);
|
} else {
|
++this.state.pos;
|
this.finishToken(17);
|
}
|
}
|
getTokenFromCode(code) {
|
switch (code) {
|
case 46:
|
this.readToken_dot();
|
return;
|
case 40:
|
++this.state.pos;
|
this.finishToken(10);
|
return;
|
case 41:
|
++this.state.pos;
|
this.finishToken(11);
|
return;
|
case 59:
|
++this.state.pos;
|
this.finishToken(13);
|
return;
|
case 44:
|
++this.state.pos;
|
this.finishToken(12);
|
return;
|
case 91:
|
if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
|
throw this.raise(Errors.TupleExpressionBarIncorrectStartSyntaxType, {
|
at: this.state.curPosition()
|
});
|
}
|
this.state.pos += 2;
|
this.finishToken(2);
|
} else {
|
++this.state.pos;
|
this.finishToken(0);
|
}
|
return;
|
case 93:
|
++this.state.pos;
|
this.finishToken(3);
|
return;
|
case 123:
|
if (this.hasPlugin("recordAndTuple") && this.input.charCodeAt(this.state.pos + 1) === 124) {
|
if (this.getPluginOption("recordAndTuple", "syntaxType") !== "bar") {
|
throw this.raise(Errors.RecordExpressionBarIncorrectStartSyntaxType, {
|
at: this.state.curPosition()
|
});
|
}
|
this.state.pos += 2;
|
this.finishToken(6);
|
} else {
|
++this.state.pos;
|
this.finishToken(5);
|
}
|
return;
|
case 125:
|
++this.state.pos;
|
this.finishToken(8);
|
return;
|
case 58:
|
if (this.hasPlugin("functionBind") && this.input.charCodeAt(this.state.pos + 1) === 58) {
|
this.finishOp(15, 2);
|
} else {
|
++this.state.pos;
|
this.finishToken(14);
|
}
|
return;
|
case 63:
|
this.readToken_question();
|
return;
|
case 96:
|
this.readTemplateToken();
|
return;
|
case 48:
|
{
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (next === 120 || next === 88) {
|
this.readRadixNumber(16);
|
return;
|
}
|
if (next === 111 || next === 79) {
|
this.readRadixNumber(8);
|
return;
|
}
|
if (next === 98 || next === 66) {
|
this.readRadixNumber(2);
|
return;
|
}
|
}
|
case 49:
|
case 50:
|
case 51:
|
case 52:
|
case 53:
|
case 54:
|
case 55:
|
case 56:
|
case 57:
|
this.readNumber(false);
|
return;
|
case 34:
|
case 39:
|
this.readString(code);
|
return;
|
case 47:
|
this.readToken_slash();
|
return;
|
case 37:
|
case 42:
|
this.readToken_mult_modulo(code);
|
return;
|
case 124:
|
case 38:
|
this.readToken_pipe_amp(code);
|
return;
|
case 94:
|
this.readToken_caret();
|
return;
|
case 43:
|
case 45:
|
this.readToken_plus_min(code);
|
return;
|
case 60:
|
this.readToken_lt();
|
return;
|
case 62:
|
this.readToken_gt();
|
return;
|
case 61:
|
case 33:
|
this.readToken_eq_excl(code);
|
return;
|
case 126:
|
this.finishOp(36, 1);
|
return;
|
case 64:
|
this.readToken_atSign();
|
return;
|
case 35:
|
this.readToken_numberSign();
|
return;
|
case 92:
|
this.readWord();
|
return;
|
default:
|
if (isIdentifierStart(code)) {
|
this.readWord(code);
|
return;
|
}
|
}
|
throw this.raise(Errors.InvalidOrUnexpectedToken, {
|
at: this.state.curPosition(),
|
unexpected: String.fromCodePoint(code)
|
});
|
}
|
finishOp(type, size) {
|
const str = this.input.slice(this.state.pos, this.state.pos + size);
|
this.state.pos += size;
|
this.finishToken(type, str);
|
}
|
readRegexp() {
|
const startLoc = this.state.startLoc;
|
const start = this.state.start + 1;
|
let escaped, inClass;
|
let {
|
pos
|
} = this.state;
|
for (;; ++pos) {
|
if (pos >= this.length) {
|
throw this.raise(Errors.UnterminatedRegExp, {
|
at: createPositionWithColumnOffset(startLoc, 1)
|
});
|
}
|
const ch = this.input.charCodeAt(pos);
|
if (isNewLine(ch)) {
|
throw this.raise(Errors.UnterminatedRegExp, {
|
at: createPositionWithColumnOffset(startLoc, 1)
|
});
|
}
|
if (escaped) {
|
escaped = false;
|
} else {
|
if (ch === 91) {
|
inClass = true;
|
} else if (ch === 93 && inClass) {
|
inClass = false;
|
} else if (ch === 47 && !inClass) {
|
break;
|
}
|
escaped = ch === 92;
|
}
|
}
|
const content = this.input.slice(start, pos);
|
++pos;
|
let mods = "";
|
const nextPos = () => createPositionWithColumnOffset(startLoc, pos + 2 - start);
|
while (pos < this.length) {
|
const cp = this.codePointAtPos(pos);
|
const char = String.fromCharCode(cp);
|
if (VALID_REGEX_FLAGS.has(cp)) {
|
if (cp === 118) {
|
this.expectPlugin("regexpUnicodeSets", nextPos());
|
if (mods.includes("u")) {
|
this.raise(Errors.IncompatibleRegExpUVFlags, {
|
at: nextPos()
|
});
|
}
|
} else if (cp === 117) {
|
if (mods.includes("v")) {
|
this.raise(Errors.IncompatibleRegExpUVFlags, {
|
at: nextPos()
|
});
|
}
|
}
|
if (mods.includes(char)) {
|
this.raise(Errors.DuplicateRegExpFlags, {
|
at: nextPos()
|
});
|
}
|
} else if (isIdentifierChar(cp) || cp === 92) {
|
this.raise(Errors.MalformedRegExpFlags, {
|
at: nextPos()
|
});
|
} else {
|
break;
|
}
|
++pos;
|
mods += char;
|
}
|
this.state.pos = pos;
|
this.finishToken(135, {
|
pattern: content,
|
flags: mods
|
});
|
}
|
readInt(radix, len, forceLen = false, allowNumSeparator = true) {
|
const {
|
n,
|
pos
|
} = readInt(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
|
this.state.pos = pos;
|
return n;
|
}
|
readRadixNumber(radix) {
|
const startLoc = this.state.curPosition();
|
let isBigInt = false;
|
this.state.pos += 2;
|
const val = this.readInt(radix);
|
if (val == null) {
|
this.raise(Errors.InvalidDigit, {
|
at: createPositionWithColumnOffset(startLoc, 2),
|
radix
|
});
|
}
|
const next = this.input.charCodeAt(this.state.pos);
|
if (next === 110) {
|
++this.state.pos;
|
isBigInt = true;
|
} else if (next === 109) {
|
throw this.raise(Errors.InvalidDecimal, {
|
at: startLoc
|
});
|
}
|
if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
|
throw this.raise(Errors.NumberIdentifier, {
|
at: this.state.curPosition()
|
});
|
}
|
if (isBigInt) {
|
const str = this.input.slice(startLoc.index, this.state.pos).replace(/[_n]/g, "");
|
this.finishToken(133, str);
|
return;
|
}
|
this.finishToken(132, val);
|
}
|
readNumber(startsWithDot) {
|
const start = this.state.pos;
|
const startLoc = this.state.curPosition();
|
let isFloat = false;
|
let isBigInt = false;
|
let isDecimal = false;
|
let hasExponent = false;
|
let isOctal = false;
|
if (!startsWithDot && this.readInt(10) === null) {
|
this.raise(Errors.InvalidNumber, {
|
at: this.state.curPosition()
|
});
|
}
|
const hasLeadingZero = this.state.pos - start >= 2 && this.input.charCodeAt(start) === 48;
|
if (hasLeadingZero) {
|
const integer = this.input.slice(start, this.state.pos);
|
this.recordStrictModeErrors(Errors.StrictOctalLiteral, {
|
at: startLoc
|
});
|
if (!this.state.strict) {
|
const underscorePos = integer.indexOf("_");
|
if (underscorePos > 0) {
|
this.raise(Errors.ZeroDigitNumericSeparator, {
|
at: createPositionWithColumnOffset(startLoc, underscorePos)
|
});
|
}
|
}
|
isOctal = hasLeadingZero && !/[89]/.test(integer);
|
}
|
let next = this.input.charCodeAt(this.state.pos);
|
if (next === 46 && !isOctal) {
|
++this.state.pos;
|
this.readInt(10);
|
isFloat = true;
|
next = this.input.charCodeAt(this.state.pos);
|
}
|
if ((next === 69 || next === 101) && !isOctal) {
|
next = this.input.charCodeAt(++this.state.pos);
|
if (next === 43 || next === 45) {
|
++this.state.pos;
|
}
|
if (this.readInt(10) === null) {
|
this.raise(Errors.InvalidOrMissingExponent, {
|
at: startLoc
|
});
|
}
|
isFloat = true;
|
hasExponent = true;
|
next = this.input.charCodeAt(this.state.pos);
|
}
|
if (next === 110) {
|
if (isFloat || hasLeadingZero) {
|
this.raise(Errors.InvalidBigIntLiteral, {
|
at: startLoc
|
});
|
}
|
++this.state.pos;
|
isBigInt = true;
|
}
|
if (next === 109) {
|
this.expectPlugin("decimal", this.state.curPosition());
|
if (hasExponent || hasLeadingZero) {
|
this.raise(Errors.InvalidDecimal, {
|
at: startLoc
|
});
|
}
|
++this.state.pos;
|
isDecimal = true;
|
}
|
if (isIdentifierStart(this.codePointAtPos(this.state.pos))) {
|
throw this.raise(Errors.NumberIdentifier, {
|
at: this.state.curPosition()
|
});
|
}
|
const str = this.input.slice(start, this.state.pos).replace(/[_mn]/g, "");
|
if (isBigInt) {
|
this.finishToken(133, str);
|
return;
|
}
|
if (isDecimal) {
|
this.finishToken(134, str);
|
return;
|
}
|
const val = isOctal ? parseInt(str, 8) : parseFloat(str);
|
this.finishToken(132, val);
|
}
|
readCodePoint(throwOnInvalid) {
|
const {
|
code,
|
pos
|
} = readCodePoint(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
|
this.state.pos = pos;
|
return code;
|
}
|
readString(quote) {
|
const {
|
str,
|
pos,
|
curLine,
|
lineStart
|
} = readStringContents(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
|
this.state.pos = pos + 1;
|
this.state.lineStart = lineStart;
|
this.state.curLine = curLine;
|
this.finishToken(131, str);
|
}
|
readTemplateContinuation() {
|
if (!this.match(8)) {
|
this.unexpected(null, 8);
|
}
|
this.state.pos--;
|
this.readTemplateToken();
|
}
|
readTemplateToken() {
|
const opening = this.input[this.state.pos];
|
const {
|
str,
|
firstInvalidLoc,
|
pos,
|
curLine,
|
lineStart
|
} = readStringContents("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
|
this.state.pos = pos + 1;
|
this.state.lineStart = lineStart;
|
this.state.curLine = curLine;
|
if (firstInvalidLoc) {
|
this.state.firstInvalidTemplateEscapePos = new Position(firstInvalidLoc.curLine, firstInvalidLoc.pos - firstInvalidLoc.lineStart, firstInvalidLoc.pos);
|
}
|
if (this.input.codePointAt(pos) === 96) {
|
this.finishToken(24, firstInvalidLoc ? null : opening + str + "`");
|
} else {
|
this.state.pos++;
|
this.finishToken(25, firstInvalidLoc ? null : opening + str + "${");
|
}
|
}
|
recordStrictModeErrors(toParseError, {
|
at
|
}) {
|
const index = at.index;
|
if (this.state.strict && !this.state.strictErrors.has(index)) {
|
this.raise(toParseError, {
|
at
|
});
|
} else {
|
this.state.strictErrors.set(index, [toParseError, at]);
|
}
|
}
|
readWord1(firstCode) {
|
this.state.containsEsc = false;
|
let word = "";
|
const start = this.state.pos;
|
let chunkStart = this.state.pos;
|
if (firstCode !== undefined) {
|
this.state.pos += firstCode <= 0xffff ? 1 : 2;
|
}
|
while (this.state.pos < this.length) {
|
const ch = this.codePointAtPos(this.state.pos);
|
if (isIdentifierChar(ch)) {
|
this.state.pos += ch <= 0xffff ? 1 : 2;
|
} else if (ch === 92) {
|
this.state.containsEsc = true;
|
word += this.input.slice(chunkStart, this.state.pos);
|
const escStart = this.state.curPosition();
|
const identifierCheck = this.state.pos === start ? isIdentifierStart : isIdentifierChar;
|
if (this.input.charCodeAt(++this.state.pos) !== 117) {
|
this.raise(Errors.MissingUnicodeEscape, {
|
at: this.state.curPosition()
|
});
|
chunkStart = this.state.pos - 1;
|
continue;
|
}
|
++this.state.pos;
|
const esc = this.readCodePoint(true);
|
if (esc !== null) {
|
if (!identifierCheck(esc)) {
|
this.raise(Errors.EscapedCharNotAnIdentifier, {
|
at: escStart
|
});
|
}
|
word += String.fromCodePoint(esc);
|
}
|
chunkStart = this.state.pos;
|
} else {
|
break;
|
}
|
}
|
return word + this.input.slice(chunkStart, this.state.pos);
|
}
|
readWord(firstCode) {
|
const word = this.readWord1(firstCode);
|
const type = keywords$1.get(word);
|
if (type !== undefined) {
|
this.finishToken(type, tokenLabelName(type));
|
} else {
|
this.finishToken(130, word);
|
}
|
}
|
checkKeywordEscapes() {
|
const {
|
type
|
} = this.state;
|
if (tokenIsKeyword(type) && this.state.containsEsc) {
|
this.raise(Errors.InvalidEscapedReservedWord, {
|
at: this.state.startLoc,
|
reservedWord: tokenLabelName(type)
|
});
|
}
|
}
|
raise(toParseError, raiseProperties) {
|
const {
|
at
|
} = raiseProperties,
|
details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
|
const loc = at instanceof Position ? at : at.loc.start;
|
const error = toParseError({
|
loc,
|
details
|
});
|
if (!this.options.errorRecovery) throw error;
|
if (!this.isLookahead) this.state.errors.push(error);
|
return error;
|
}
|
raiseOverwrite(toParseError, raiseProperties) {
|
const {
|
at
|
} = raiseProperties,
|
details = _objectWithoutPropertiesLoose(raiseProperties, _excluded2);
|
const loc = at instanceof Position ? at : at.loc.start;
|
const pos = loc.index;
|
const errors = this.state.errors;
|
for (let i = errors.length - 1; i >= 0; i--) {
|
const error = errors[i];
|
if (error.loc.index === pos) {
|
return errors[i] = toParseError({
|
loc,
|
details
|
});
|
}
|
if (error.loc.index < pos) break;
|
}
|
return this.raise(toParseError, raiseProperties);
|
}
|
updateContext(prevType) {}
|
unexpected(loc, type) {
|
throw this.raise(Errors.UnexpectedToken, {
|
expected: type ? tokenLabelName(type) : null,
|
at: loc != null ? loc : this.state.startLoc
|
});
|
}
|
expectPlugin(pluginName, loc) {
|
if (this.hasPlugin(pluginName)) {
|
return true;
|
}
|
throw this.raise(Errors.MissingPlugin, {
|
at: loc != null ? loc : this.state.startLoc,
|
missingPlugin: [pluginName]
|
});
|
}
|
expectOnePlugin(pluginNames) {
|
if (!pluginNames.some(name => this.hasPlugin(name))) {
|
throw this.raise(Errors.MissingOneOfPlugins, {
|
at: this.state.startLoc,
|
missingPlugin: pluginNames
|
});
|
}
|
}
|
errorBuilder(error) {
|
return (pos, lineStart, curLine) => {
|
this.raise(error, {
|
at: buildPosition(pos, lineStart, curLine)
|
});
|
};
|
}
|
}
|
class ClassScope {
|
constructor() {
|
this.privateNames = new Set();
|
this.loneAccessors = new Map();
|
this.undefinedPrivateNames = new Map();
|
}
|
}
|
class ClassScopeHandler {
|
constructor(parser) {
|
this.parser = void 0;
|
this.stack = [];
|
this.undefinedPrivateNames = new Map();
|
this.parser = parser;
|
}
|
current() {
|
return this.stack[this.stack.length - 1];
|
}
|
enter() {
|
this.stack.push(new ClassScope());
|
}
|
exit() {
|
const oldClassScope = this.stack.pop();
|
const current = this.current();
|
for (const [name, loc] of Array.from(oldClassScope.undefinedPrivateNames)) {
|
if (current) {
|
if (!current.undefinedPrivateNames.has(name)) {
|
current.undefinedPrivateNames.set(name, loc);
|
}
|
} else {
|
this.parser.raise(Errors.InvalidPrivateFieldResolution, {
|
at: loc,
|
identifierName: name
|
});
|
}
|
}
|
}
|
declarePrivateName(name, elementType, loc) {
|
const {
|
privateNames,
|
loneAccessors,
|
undefinedPrivateNames
|
} = this.current();
|
let redefined = privateNames.has(name);
|
if (elementType & CLASS_ELEMENT_KIND_ACCESSOR) {
|
const accessor = redefined && loneAccessors.get(name);
|
if (accessor) {
|
const oldStatic = accessor & CLASS_ELEMENT_FLAG_STATIC;
|
const newStatic = elementType & CLASS_ELEMENT_FLAG_STATIC;
|
const oldKind = accessor & CLASS_ELEMENT_KIND_ACCESSOR;
|
const newKind = elementType & CLASS_ELEMENT_KIND_ACCESSOR;
|
redefined = oldKind === newKind || oldStatic !== newStatic;
|
if (!redefined) loneAccessors.delete(name);
|
} else if (!redefined) {
|
loneAccessors.set(name, elementType);
|
}
|
}
|
if (redefined) {
|
this.parser.raise(Errors.PrivateNameRedeclaration, {
|
at: loc,
|
identifierName: name
|
});
|
}
|
privateNames.add(name);
|
undefinedPrivateNames.delete(name);
|
}
|
usePrivateName(name, loc) {
|
let classScope;
|
for (classScope of this.stack) {
|
if (classScope.privateNames.has(name)) return;
|
}
|
if (classScope) {
|
classScope.undefinedPrivateNames.set(name, loc);
|
} else {
|
this.parser.raise(Errors.InvalidPrivateFieldResolution, {
|
at: loc,
|
identifierName: name
|
});
|
}
|
}
|
}
|
const kExpression = 0,
|
kMaybeArrowParameterDeclaration = 1,
|
kMaybeAsyncArrowParameterDeclaration = 2,
|
kParameterDeclaration = 3;
|
class ExpressionScope {
|
constructor(type = kExpression) {
|
this.type = void 0;
|
this.type = type;
|
}
|
canBeArrowParameterDeclaration() {
|
return this.type === kMaybeAsyncArrowParameterDeclaration || this.type === kMaybeArrowParameterDeclaration;
|
}
|
isCertainlyParameterDeclaration() {
|
return this.type === kParameterDeclaration;
|
}
|
}
|
class ArrowHeadParsingScope extends ExpressionScope {
|
constructor(type) {
|
super(type);
|
this.declarationErrors = new Map();
|
}
|
recordDeclarationError(ParsingErrorClass, {
|
at
|
}) {
|
const index = at.index;
|
this.declarationErrors.set(index, [ParsingErrorClass, at]);
|
}
|
clearDeclarationError(index) {
|
this.declarationErrors.delete(index);
|
}
|
iterateErrors(iterator) {
|
this.declarationErrors.forEach(iterator);
|
}
|
}
|
class ExpressionScopeHandler {
|
constructor(parser) {
|
this.parser = void 0;
|
this.stack = [new ExpressionScope()];
|
this.parser = parser;
|
}
|
enter(scope) {
|
this.stack.push(scope);
|
}
|
exit() {
|
this.stack.pop();
|
}
|
recordParameterInitializerError(toParseError, {
|
at: node
|
}) {
|
const origin = {
|
at: node.loc.start
|
};
|
const {
|
stack
|
} = this;
|
let i = stack.length - 1;
|
let scope = stack[i];
|
while (!scope.isCertainlyParameterDeclaration()) {
|
if (scope.canBeArrowParameterDeclaration()) {
|
scope.recordDeclarationError(toParseError, origin);
|
} else {
|
return;
|
}
|
scope = stack[--i];
|
}
|
this.parser.raise(toParseError, origin);
|
}
|
recordArrowParameterBindingError(error, {
|
at: node
|
}) {
|
const {
|
stack
|
} = this;
|
const scope = stack[stack.length - 1];
|
const origin = {
|
at: node.loc.start
|
};
|
if (scope.isCertainlyParameterDeclaration()) {
|
this.parser.raise(error, origin);
|
} else if (scope.canBeArrowParameterDeclaration()) {
|
scope.recordDeclarationError(error, origin);
|
} else {
|
return;
|
}
|
}
|
recordAsyncArrowParametersError({
|
at
|
}) {
|
const {
|
stack
|
} = this;
|
let i = stack.length - 1;
|
let scope = stack[i];
|
while (scope.canBeArrowParameterDeclaration()) {
|
if (scope.type === kMaybeAsyncArrowParameterDeclaration) {
|
scope.recordDeclarationError(Errors.AwaitBindingIdentifier, {
|
at
|
});
|
}
|
scope = stack[--i];
|
}
|
}
|
validateAsPattern() {
|
const {
|
stack
|
} = this;
|
const currentScope = stack[stack.length - 1];
|
if (!currentScope.canBeArrowParameterDeclaration()) return;
|
currentScope.iterateErrors(([toParseError, loc]) => {
|
this.parser.raise(toParseError, {
|
at: loc
|
});
|
let i = stack.length - 2;
|
let scope = stack[i];
|
while (scope.canBeArrowParameterDeclaration()) {
|
scope.clearDeclarationError(loc.index);
|
scope = stack[--i];
|
}
|
});
|
}
|
}
|
function newParameterDeclarationScope() {
|
return new ExpressionScope(kParameterDeclaration);
|
}
|
function newArrowHeadScope() {
|
return new ArrowHeadParsingScope(kMaybeArrowParameterDeclaration);
|
}
|
function newAsyncArrowScope() {
|
return new ArrowHeadParsingScope(kMaybeAsyncArrowParameterDeclaration);
|
}
|
function newExpressionScope() {
|
return new ExpressionScope();
|
}
|
const PARAM = 0b0000,
|
PARAM_YIELD = 0b0001,
|
PARAM_AWAIT = 0b0010,
|
PARAM_RETURN = 0b0100,
|
PARAM_IN = 0b1000;
|
class ProductionParameterHandler {
|
constructor() {
|
this.stacks = [];
|
}
|
enter(flags) {
|
this.stacks.push(flags);
|
}
|
exit() {
|
this.stacks.pop();
|
}
|
currentFlags() {
|
return this.stacks[this.stacks.length - 1];
|
}
|
get hasAwait() {
|
return (this.currentFlags() & PARAM_AWAIT) > 0;
|
}
|
get hasYield() {
|
return (this.currentFlags() & PARAM_YIELD) > 0;
|
}
|
get hasReturn() {
|
return (this.currentFlags() & PARAM_RETURN) > 0;
|
}
|
get hasIn() {
|
return (this.currentFlags() & PARAM_IN) > 0;
|
}
|
}
|
function functionFlags(isAsync, isGenerator) {
|
return (isAsync ? PARAM_AWAIT : 0) | (isGenerator ? PARAM_YIELD : 0);
|
}
|
class UtilParser extends Tokenizer {
|
addExtra(node, key, value, enumerable = true) {
|
if (!node) return;
|
const extra = node.extra = node.extra || {};
|
if (enumerable) {
|
extra[key] = value;
|
} else {
|
Object.defineProperty(extra, key, {
|
enumerable,
|
value
|
});
|
}
|
}
|
isContextual(token) {
|
return this.state.type === token && !this.state.containsEsc;
|
}
|
isUnparsedContextual(nameStart, name) {
|
const nameEnd = nameStart + name.length;
|
if (this.input.slice(nameStart, nameEnd) === name) {
|
const nextCh = this.input.charCodeAt(nameEnd);
|
return !(isIdentifierChar(nextCh) || (nextCh & 0xfc00) === 0xd800);
|
}
|
return false;
|
}
|
isLookaheadContextual(name) {
|
const next = this.nextTokenStart();
|
return this.isUnparsedContextual(next, name);
|
}
|
eatContextual(token) {
|
if (this.isContextual(token)) {
|
this.next();
|
return true;
|
}
|
return false;
|
}
|
expectContextual(token, toParseError) {
|
if (!this.eatContextual(token)) {
|
if (toParseError != null) {
|
throw this.raise(toParseError, {
|
at: this.state.startLoc
|
});
|
}
|
this.unexpected(null, token);
|
}
|
}
|
canInsertSemicolon() {
|
return this.match(137) || this.match(8) || this.hasPrecedingLineBreak();
|
}
|
hasPrecedingLineBreak() {
|
return lineBreak.test(this.input.slice(this.state.lastTokEndLoc.index, this.state.start));
|
}
|
hasFollowingLineBreak() {
|
skipWhiteSpaceToLineBreak.lastIndex = this.state.end;
|
return skipWhiteSpaceToLineBreak.test(this.input);
|
}
|
isLineTerminator() {
|
return this.eat(13) || this.canInsertSemicolon();
|
}
|
semicolon(allowAsi = true) {
|
if (allowAsi ? this.isLineTerminator() : this.eat(13)) return;
|
this.raise(Errors.MissingSemicolon, {
|
at: this.state.lastTokEndLoc
|
});
|
}
|
expect(type, loc) {
|
this.eat(type) || this.unexpected(loc, type);
|
}
|
tryParse(fn, oldState = this.state.clone()) {
|
const abortSignal = {
|
node: null
|
};
|
try {
|
const node = fn((node = null) => {
|
abortSignal.node = node;
|
throw abortSignal;
|
});
|
if (this.state.errors.length > oldState.errors.length) {
|
const failState = this.state;
|
this.state = oldState;
|
this.state.tokensLength = failState.tokensLength;
|
return {
|
node,
|
error: failState.errors[oldState.errors.length],
|
thrown: false,
|
aborted: false,
|
failState
|
};
|
}
|
return {
|
node,
|
error: null,
|
thrown: false,
|
aborted: false,
|
failState: null
|
};
|
} catch (error) {
|
const failState = this.state;
|
this.state = oldState;
|
if (error instanceof SyntaxError) {
|
return {
|
node: null,
|
error,
|
thrown: true,
|
aborted: false,
|
failState
|
};
|
}
|
if (error === abortSignal) {
|
return {
|
node: abortSignal.node,
|
error: null,
|
thrown: false,
|
aborted: true,
|
failState
|
};
|
}
|
throw error;
|
}
|
}
|
checkExpressionErrors(refExpressionErrors, andThrow) {
|
if (!refExpressionErrors) return false;
|
const {
|
shorthandAssignLoc,
|
doubleProtoLoc,
|
privateKeyLoc,
|
optionalParametersLoc
|
} = refExpressionErrors;
|
const hasErrors = !!shorthandAssignLoc || !!doubleProtoLoc || !!optionalParametersLoc || !!privateKeyLoc;
|
if (!andThrow) {
|
return hasErrors;
|
}
|
if (shorthandAssignLoc != null) {
|
this.raise(Errors.InvalidCoverInitializedName, {
|
at: shorthandAssignLoc
|
});
|
}
|
if (doubleProtoLoc != null) {
|
this.raise(Errors.DuplicateProto, {
|
at: doubleProtoLoc
|
});
|
}
|
if (privateKeyLoc != null) {
|
this.raise(Errors.UnexpectedPrivateField, {
|
at: privateKeyLoc
|
});
|
}
|
if (optionalParametersLoc != null) {
|
this.unexpected(optionalParametersLoc);
|
}
|
}
|
isLiteralPropertyName() {
|
return tokenIsLiteralPropertyName(this.state.type);
|
}
|
isPrivateName(node) {
|
return node.type === "PrivateName";
|
}
|
getPrivateNameSV(node) {
|
return node.id.name;
|
}
|
hasPropertyAsPrivateName(node) {
|
return (node.type === "MemberExpression" || node.type === "OptionalMemberExpression") && this.isPrivateName(node.property);
|
}
|
isObjectProperty(node) {
|
return node.type === "ObjectProperty";
|
}
|
isObjectMethod(node) {
|
return node.type === "ObjectMethod";
|
}
|
initializeScopes(inModule = this.options.sourceType === "module") {
|
const oldLabels = this.state.labels;
|
this.state.labels = [];
|
const oldExportedIdentifiers = this.exportedIdentifiers;
|
this.exportedIdentifiers = new Set();
|
const oldInModule = this.inModule;
|
this.inModule = inModule;
|
const oldScope = this.scope;
|
const ScopeHandler = this.getScopeHandler();
|
this.scope = new ScopeHandler(this, inModule);
|
const oldProdParam = this.prodParam;
|
this.prodParam = new ProductionParameterHandler();
|
const oldClassScope = this.classScope;
|
this.classScope = new ClassScopeHandler(this);
|
const oldExpressionScope = this.expressionScope;
|
this.expressionScope = new ExpressionScopeHandler(this);
|
return () => {
|
this.state.labels = oldLabels;
|
this.exportedIdentifiers = oldExportedIdentifiers;
|
this.inModule = oldInModule;
|
this.scope = oldScope;
|
this.prodParam = oldProdParam;
|
this.classScope = oldClassScope;
|
this.expressionScope = oldExpressionScope;
|
};
|
}
|
enterInitialScopes() {
|
let paramFlags = PARAM;
|
if (this.inModule) {
|
paramFlags |= PARAM_AWAIT;
|
}
|
this.scope.enter(SCOPE_PROGRAM);
|
this.prodParam.enter(paramFlags);
|
}
|
checkDestructuringPrivate(refExpressionErrors) {
|
const {
|
privateKeyLoc
|
} = refExpressionErrors;
|
if (privateKeyLoc !== null) {
|
this.expectPlugin("destructuringPrivate", privateKeyLoc);
|
}
|
}
|
}
|
class ExpressionErrors {
|
constructor() {
|
this.shorthandAssignLoc = null;
|
this.doubleProtoLoc = null;
|
this.privateKeyLoc = null;
|
this.optionalParametersLoc = null;
|
}
|
}
|
let Node$5 = class Node {
|
constructor(parser, pos, loc) {
|
this.type = "";
|
this.start = pos;
|
this.end = 0;
|
this.loc = new SourceLocation(loc);
|
if (parser != null && parser.options.ranges) this.range = [pos, 0];
|
if (parser != null && parser.filename) this.loc.filename = parser.filename;
|
}
|
};
|
const NodePrototype = Node$5.prototype;
|
{
|
NodePrototype.__clone = function () {
|
const newNode = new Node$5(undefined, this.start, this.loc.start);
|
const keys = Object.keys(this);
|
for (let i = 0, length = keys.length; i < length; i++) {
|
const key = keys[i];
|
if (key !== "leadingComments" && key !== "trailingComments" && key !== "innerComments") {
|
newNode[key] = this[key];
|
}
|
}
|
return newNode;
|
};
|
}
|
function clonePlaceholder(node) {
|
return cloneIdentifier(node);
|
}
|
function cloneIdentifier(node) {
|
const {
|
type,
|
start,
|
end,
|
loc,
|
range,
|
extra,
|
name
|
} = node;
|
const cloned = Object.create(NodePrototype);
|
cloned.type = type;
|
cloned.start = start;
|
cloned.end = end;
|
cloned.loc = loc;
|
cloned.range = range;
|
cloned.extra = extra;
|
cloned.name = name;
|
if (type === "Placeholder") {
|
cloned.expectedNode = node.expectedNode;
|
}
|
return cloned;
|
}
|
function cloneStringLiteral(node) {
|
const {
|
type,
|
start,
|
end,
|
loc,
|
range,
|
extra
|
} = node;
|
if (type === "Placeholder") {
|
return clonePlaceholder(node);
|
}
|
const cloned = Object.create(NodePrototype);
|
cloned.type = type;
|
cloned.start = start;
|
cloned.end = end;
|
cloned.loc = loc;
|
cloned.range = range;
|
if (node.raw !== undefined) {
|
cloned.raw = node.raw;
|
} else {
|
cloned.extra = extra;
|
}
|
cloned.value = node.value;
|
return cloned;
|
}
|
class NodeUtils extends UtilParser {
|
startNode() {
|
return new Node$5(this, this.state.start, this.state.startLoc);
|
}
|
startNodeAt(loc) {
|
return new Node$5(this, loc.index, loc);
|
}
|
startNodeAtNode(type) {
|
return this.startNodeAt(type.loc.start);
|
}
|
finishNode(node, type) {
|
return this.finishNodeAt(node, type, this.state.lastTokEndLoc);
|
}
|
finishNodeAt(node, type, endLoc) {
|
node.type = type;
|
node.end = endLoc.index;
|
node.loc.end = endLoc;
|
if (this.options.ranges) node.range[1] = endLoc.index;
|
if (this.options.attachComment) this.processComment(node);
|
return node;
|
}
|
resetStartLocation(node, startLoc) {
|
node.start = startLoc.index;
|
node.loc.start = startLoc;
|
if (this.options.ranges) node.range[0] = startLoc.index;
|
}
|
resetEndLocation(node, endLoc = this.state.lastTokEndLoc) {
|
node.end = endLoc.index;
|
node.loc.end = endLoc;
|
if (this.options.ranges) node.range[1] = endLoc.index;
|
}
|
resetStartLocationFromNode(node, locationNode) {
|
this.resetStartLocation(node, locationNode.loc.start);
|
}
|
}
|
const reservedTypes = new Set(["_", "any", "bool", "boolean", "empty", "extends", "false", "interface", "mixed", "null", "number", "static", "string", "true", "typeof", "void"]);
|
const FlowErrors = ParseErrorEnum`flow`({
|
AmbiguousConditionalArrow: "Ambiguous expression: wrap the arrow functions in parentheses to disambiguate.",
|
AmbiguousDeclareModuleKind: "Found both `declare module.exports` and `declare export` in the same module. Modules can only have 1 since they are either an ES module or they are a CommonJS module.",
|
AssignReservedType: ({
|
reservedType
|
}) => `Cannot overwrite reserved type ${reservedType}.`,
|
DeclareClassElement: "The `declare` modifier can only appear on class fields.",
|
DeclareClassFieldInitializer: "Initializers are not allowed in fields with the `declare` modifier.",
|
DuplicateDeclareModuleExports: "Duplicate `declare module.exports` statement.",
|
EnumBooleanMemberNotInitialized: ({
|
memberName,
|
enumName
|
}) => `Boolean enum members need to be initialized. Use either \`${memberName} = true,\` or \`${memberName} = false,\` in enum \`${enumName}\`.`,
|
EnumDuplicateMemberName: ({
|
memberName,
|
enumName
|
}) => `Enum member names need to be unique, but the name \`${memberName}\` has already been used before in enum \`${enumName}\`.`,
|
EnumInconsistentMemberValues: ({
|
enumName
|
}) => `Enum \`${enumName}\` has inconsistent member initializers. Either use no initializers, or consistently use literals (either booleans, numbers, or strings) for all member initializers.`,
|
EnumInvalidExplicitType: ({
|
invalidEnumType,
|
enumName
|
}) => `Enum type \`${invalidEnumType}\` is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
|
EnumInvalidExplicitTypeUnknownSupplied: ({
|
enumName
|
}) => `Supplied enum type is not valid. Use one of \`boolean\`, \`number\`, \`string\`, or \`symbol\` in enum \`${enumName}\`.`,
|
EnumInvalidMemberInitializerPrimaryType: ({
|
enumName,
|
memberName,
|
explicitType
|
}) => `Enum \`${enumName}\` has type \`${explicitType}\`, so the initializer of \`${memberName}\` needs to be a ${explicitType} literal.`,
|
EnumInvalidMemberInitializerSymbolType: ({
|
enumName,
|
memberName
|
}) => `Symbol enum members cannot be initialized. Use \`${memberName},\` in enum \`${enumName}\`.`,
|
EnumInvalidMemberInitializerUnknownType: ({
|
enumName,
|
memberName
|
}) => `The enum member initializer for \`${memberName}\` needs to be a literal (either a boolean, number, or string) in enum \`${enumName}\`.`,
|
EnumInvalidMemberName: ({
|
enumName,
|
memberName,
|
suggestion
|
}) => `Enum member names cannot start with lowercase 'a' through 'z'. Instead of using \`${memberName}\`, consider using \`${suggestion}\`, in enum \`${enumName}\`.`,
|
EnumNumberMemberNotInitialized: ({
|
enumName,
|
memberName
|
}) => `Number enum members need to be initialized, e.g. \`${memberName} = 1\` in enum \`${enumName}\`.`,
|
EnumStringMemberInconsistentlyInitailized: ({
|
enumName
|
}) => `String enum members need to consistently either all use initializers, or use no initializers, in enum \`${enumName}\`.`,
|
GetterMayNotHaveThisParam: "A getter cannot have a `this` parameter.",
|
ImportReflectionHasImportType: "An `import module` declaration can not use `type` or `typeof` keyword.",
|
ImportTypeShorthandOnlyInPureImport: "The `type` and `typeof` keywords on named imports can only be used on regular `import` statements. It cannot be used with `import type` or `import typeof` statements.",
|
InexactInsideExact: "Explicit inexact syntax cannot appear inside an explicit exact object type.",
|
InexactInsideNonObject: "Explicit inexact syntax cannot appear in class or interface definitions.",
|
InexactVariance: "Explicit inexact syntax cannot have variance.",
|
InvalidNonTypeImportInDeclareModule: "Imports within a `declare module` body must always be `import type` or `import typeof`.",
|
MissingTypeParamDefault: "Type parameter declaration needs a default, since a preceding type parameter declaration has a default.",
|
NestedDeclareModule: "`declare module` cannot be used inside another `declare module`.",
|
NestedFlowComment: "Cannot have a flow comment inside another flow comment.",
|
PatternIsOptional: Object.assign({
|
message: "A binding pattern parameter cannot be optional in an implementation signature."
|
}, {
|
reasonCode: "OptionalBindingPattern"
|
}),
|
SetterMayNotHaveThisParam: "A setter cannot have a `this` parameter.",
|
SpreadVariance: "Spread properties cannot have variance.",
|
ThisParamAnnotationRequired: "A type annotation is required for the `this` parameter.",
|
ThisParamBannedInConstructor: "Constructors cannot have a `this` parameter; constructors don't bind `this` like other functions.",
|
ThisParamMayNotBeOptional: "The `this` parameter cannot be optional.",
|
ThisParamMustBeFirst: "The `this` parameter must be the first function parameter.",
|
ThisParamNoDefault: "The `this` parameter may not have a default value.",
|
TypeBeforeInitializer: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
|
TypeCastInPattern: "The type cast expression is expected to be wrapped with parenthesis.",
|
UnexpectedExplicitInexactInObject: "Explicit inexact syntax must appear at the end of an inexact object.",
|
UnexpectedReservedType: ({
|
reservedType
|
}) => `Unexpected reserved type ${reservedType}.`,
|
UnexpectedReservedUnderscore: "`_` is only allowed as a type argument to call or new.",
|
UnexpectedSpaceBetweenModuloChecks: "Spaces between `%` and `checks` are not allowed here.",
|
UnexpectedSpreadType: "Spread operator cannot appear in class or interface definitions.",
|
UnexpectedSubtractionOperand: 'Unexpected token, expected "number" or "bigint".',
|
UnexpectedTokenAfterTypeParameter: "Expected an arrow function after this type parameter declaration.",
|
UnexpectedTypeParameterBeforeAsyncArrowFunction: "Type parameters must come after the async keyword, e.g. instead of `<T> async () => {}`, use `async <T>() => {}`.",
|
UnsupportedDeclareExportKind: ({
|
unsupportedExportKind,
|
suggestion
|
}) => `\`declare export ${unsupportedExportKind}\` is not supported. Use \`${suggestion}\` instead.`,
|
UnsupportedStatementInDeclareModule: "Only declares and type imports are allowed inside declare module.",
|
UnterminatedFlowComment: "Unterminated flow-comment."
|
});
|
function isEsModuleType(bodyElement) {
|
return bodyElement.type === "DeclareExportAllDeclaration" || bodyElement.type === "DeclareExportDeclaration" && (!bodyElement.declaration || bodyElement.declaration.type !== "TypeAlias" && bodyElement.declaration.type !== "InterfaceDeclaration");
|
}
|
function hasTypeImportKind(node) {
|
return node.importKind === "type" || node.importKind === "typeof";
|
}
|
function isMaybeDefaultImport(type) {
|
return tokenIsKeywordOrIdentifier(type) && type !== 97;
|
}
|
const exportSuggestions = {
|
const: "declare export var",
|
let: "declare export var",
|
type: "export type",
|
interface: "export interface"
|
};
|
function partition(list, test) {
|
const list1 = [];
|
const list2 = [];
|
for (let i = 0; i < list.length; i++) {
|
(test(list[i], i, list) ? list1 : list2).push(list[i]);
|
}
|
return [list1, list2];
|
}
|
const FLOW_PRAGMA_REGEX = /\*?\s*@((?:no)?flow)\b/;
|
var flow = superClass => class FlowParserMixin extends superClass {
|
constructor(...args) {
|
super(...args);
|
this.flowPragma = undefined;
|
}
|
getScopeHandler() {
|
return FlowScopeHandler;
|
}
|
shouldParseTypes() {
|
return this.getPluginOption("flow", "all") || this.flowPragma === "flow";
|
}
|
shouldParseEnums() {
|
return !!this.getPluginOption("flow", "enums");
|
}
|
finishToken(type, val) {
|
if (type !== 131 && type !== 13 && type !== 28) {
|
if (this.flowPragma === undefined) {
|
this.flowPragma = null;
|
}
|
}
|
super.finishToken(type, val);
|
}
|
addComment(comment) {
|
if (this.flowPragma === undefined) {
|
const matches = FLOW_PRAGMA_REGEX.exec(comment.value);
|
if (!matches) ;else if (matches[1] === "flow") {
|
this.flowPragma = "flow";
|
} else if (matches[1] === "noflow") {
|
this.flowPragma = "noflow";
|
} else {
|
throw new Error("Unexpected flow pragma");
|
}
|
}
|
super.addComment(comment);
|
}
|
flowParseTypeInitialiser(tok) {
|
const oldInType = this.state.inType;
|
this.state.inType = true;
|
this.expect(tok || 14);
|
const type = this.flowParseType();
|
this.state.inType = oldInType;
|
return type;
|
}
|
flowParsePredicate() {
|
const node = this.startNode();
|
const moduloLoc = this.state.startLoc;
|
this.next();
|
this.expectContextual(108);
|
if (this.state.lastTokStart > moduloLoc.index + 1) {
|
this.raise(FlowErrors.UnexpectedSpaceBetweenModuloChecks, {
|
at: moduloLoc
|
});
|
}
|
if (this.eat(10)) {
|
node.value = super.parseExpression();
|
this.expect(11);
|
return this.finishNode(node, "DeclaredPredicate");
|
} else {
|
return this.finishNode(node, "InferredPredicate");
|
}
|
}
|
flowParseTypeAndPredicateInitialiser() {
|
const oldInType = this.state.inType;
|
this.state.inType = true;
|
this.expect(14);
|
let type = null;
|
let predicate = null;
|
if (this.match(54)) {
|
this.state.inType = oldInType;
|
predicate = this.flowParsePredicate();
|
} else {
|
type = this.flowParseType();
|
this.state.inType = oldInType;
|
if (this.match(54)) {
|
predicate = this.flowParsePredicate();
|
}
|
}
|
return [type, predicate];
|
}
|
flowParseDeclareClass(node) {
|
this.next();
|
this.flowParseInterfaceish(node, true);
|
return this.finishNode(node, "DeclareClass");
|
}
|
flowParseDeclareFunction(node) {
|
this.next();
|
const id = node.id = this.parseIdentifier();
|
const typeNode = this.startNode();
|
const typeContainer = this.startNode();
|
if (this.match(47)) {
|
typeNode.typeParameters = this.flowParseTypeParameterDeclaration();
|
} else {
|
typeNode.typeParameters = null;
|
}
|
this.expect(10);
|
const tmp = this.flowParseFunctionTypeParams();
|
typeNode.params = tmp.params;
|
typeNode.rest = tmp.rest;
|
typeNode.this = tmp._this;
|
this.expect(11);
|
[typeNode.returnType, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
|
typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation");
|
id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation");
|
this.resetEndLocation(id);
|
this.semicolon();
|
this.scope.declareName(node.id.name, BIND_FLOW_DECLARE_FN, node.id.loc.start);
|
return this.finishNode(node, "DeclareFunction");
|
}
|
flowParseDeclare(node, insideModule) {
|
if (this.match(80)) {
|
return this.flowParseDeclareClass(node);
|
} else if (this.match(68)) {
|
return this.flowParseDeclareFunction(node);
|
} else if (this.match(74)) {
|
return this.flowParseDeclareVariable(node);
|
} else if (this.eatContextual(125)) {
|
if (this.match(16)) {
|
return this.flowParseDeclareModuleExports(node);
|
} else {
|
if (insideModule) {
|
this.raise(FlowErrors.NestedDeclareModule, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
return this.flowParseDeclareModule(node);
|
}
|
} else if (this.isContextual(128)) {
|
return this.flowParseDeclareTypeAlias(node);
|
} else if (this.isContextual(129)) {
|
return this.flowParseDeclareOpaqueType(node);
|
} else if (this.isContextual(127)) {
|
return this.flowParseDeclareInterface(node);
|
} else if (this.match(82)) {
|
return this.flowParseDeclareExportDeclaration(node, insideModule);
|
} else {
|
this.unexpected();
|
}
|
}
|
flowParseDeclareVariable(node) {
|
this.next();
|
node.id = this.flowParseTypeAnnotatableIdentifier(true);
|
this.scope.declareName(node.id.name, BIND_VAR, node.id.loc.start);
|
this.semicolon();
|
return this.finishNode(node, "DeclareVariable");
|
}
|
flowParseDeclareModule(node) {
|
this.scope.enter(SCOPE_OTHER);
|
if (this.match(131)) {
|
node.id = super.parseExprAtom();
|
} else {
|
node.id = this.parseIdentifier();
|
}
|
const bodyNode = node.body = this.startNode();
|
const body = bodyNode.body = [];
|
this.expect(5);
|
while (!this.match(8)) {
|
let bodyNode = this.startNode();
|
if (this.match(83)) {
|
this.next();
|
if (!this.isContextual(128) && !this.match(87)) {
|
this.raise(FlowErrors.InvalidNonTypeImportInDeclareModule, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
super.parseImport(bodyNode);
|
} else {
|
this.expectContextual(123, FlowErrors.UnsupportedStatementInDeclareModule);
|
bodyNode = this.flowParseDeclare(bodyNode, true);
|
}
|
body.push(bodyNode);
|
}
|
this.scope.exit();
|
this.expect(8);
|
this.finishNode(bodyNode, "BlockStatement");
|
let kind = null;
|
let hasModuleExport = false;
|
body.forEach(bodyElement => {
|
if (isEsModuleType(bodyElement)) {
|
if (kind === "CommonJS") {
|
this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
|
at: bodyElement
|
});
|
}
|
kind = "ES";
|
} else if (bodyElement.type === "DeclareModuleExports") {
|
if (hasModuleExport) {
|
this.raise(FlowErrors.DuplicateDeclareModuleExports, {
|
at: bodyElement
|
});
|
}
|
if (kind === "ES") {
|
this.raise(FlowErrors.AmbiguousDeclareModuleKind, {
|
at: bodyElement
|
});
|
}
|
kind = "CommonJS";
|
hasModuleExport = true;
|
}
|
});
|
node.kind = kind || "CommonJS";
|
return this.finishNode(node, "DeclareModule");
|
}
|
flowParseDeclareExportDeclaration(node, insideModule) {
|
this.expect(82);
|
if (this.eat(65)) {
|
if (this.match(68) || this.match(80)) {
|
node.declaration = this.flowParseDeclare(this.startNode());
|
} else {
|
node.declaration = this.flowParseType();
|
this.semicolon();
|
}
|
node.default = true;
|
return this.finishNode(node, "DeclareExportDeclaration");
|
} else {
|
if (this.match(75) || this.isLet() || (this.isContextual(128) || this.isContextual(127)) && !insideModule) {
|
const label = this.state.value;
|
throw this.raise(FlowErrors.UnsupportedDeclareExportKind, {
|
at: this.state.startLoc,
|
unsupportedExportKind: label,
|
suggestion: exportSuggestions[label]
|
});
|
}
|
if (this.match(74) || this.match(68) || this.match(80) || this.isContextual(129)) {
|
node.declaration = this.flowParseDeclare(this.startNode());
|
node.default = false;
|
return this.finishNode(node, "DeclareExportDeclaration");
|
} else if (this.match(55) || this.match(5) || this.isContextual(127) || this.isContextual(128) || this.isContextual(129)) {
|
node = this.parseExport(node, null);
|
if (node.type === "ExportNamedDeclaration") {
|
node.type = "ExportDeclaration";
|
node.default = false;
|
delete node.exportKind;
|
}
|
node.type = "Declare" + node.type;
|
return node;
|
}
|
}
|
this.unexpected();
|
}
|
flowParseDeclareModuleExports(node) {
|
this.next();
|
this.expectContextual(109);
|
node.typeAnnotation = this.flowParseTypeAnnotation();
|
this.semicolon();
|
return this.finishNode(node, "DeclareModuleExports");
|
}
|
flowParseDeclareTypeAlias(node) {
|
this.next();
|
const finished = this.flowParseTypeAlias(node);
|
finished.type = "DeclareTypeAlias";
|
return finished;
|
}
|
flowParseDeclareOpaqueType(node) {
|
this.next();
|
const finished = this.flowParseOpaqueType(node, true);
|
finished.type = "DeclareOpaqueType";
|
return finished;
|
}
|
flowParseDeclareInterface(node) {
|
this.next();
|
this.flowParseInterfaceish(node, false);
|
return this.finishNode(node, "DeclareInterface");
|
}
|
flowParseInterfaceish(node, isClass) {
|
node.id = this.flowParseRestrictedIdentifier(!isClass, true);
|
this.scope.declareName(node.id.name, isClass ? BIND_FUNCTION : BIND_LEXICAL, node.id.loc.start);
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterDeclaration();
|
} else {
|
node.typeParameters = null;
|
}
|
node.extends = [];
|
node.implements = [];
|
node.mixins = [];
|
if (this.eat(81)) {
|
do {
|
node.extends.push(this.flowParseInterfaceExtends());
|
} while (!isClass && this.eat(12));
|
}
|
if (isClass) {
|
if (this.eatContextual(115)) {
|
do {
|
node.mixins.push(this.flowParseInterfaceExtends());
|
} while (this.eat(12));
|
}
|
if (this.eatContextual(111)) {
|
do {
|
node.implements.push(this.flowParseInterfaceExtends());
|
} while (this.eat(12));
|
}
|
}
|
node.body = this.flowParseObjectType({
|
allowStatic: isClass,
|
allowExact: false,
|
allowSpread: false,
|
allowProto: isClass,
|
allowInexact: false
|
});
|
}
|
flowParseInterfaceExtends() {
|
const node = this.startNode();
|
node.id = this.flowParseQualifiedTypeIdentifier();
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterInstantiation();
|
} else {
|
node.typeParameters = null;
|
}
|
return this.finishNode(node, "InterfaceExtends");
|
}
|
flowParseInterface(node) {
|
this.flowParseInterfaceish(node, false);
|
return this.finishNode(node, "InterfaceDeclaration");
|
}
|
checkNotUnderscore(word) {
|
if (word === "_") {
|
this.raise(FlowErrors.UnexpectedReservedUnderscore, {
|
at: this.state.startLoc
|
});
|
}
|
}
|
checkReservedType(word, startLoc, declaration) {
|
if (!reservedTypes.has(word)) return;
|
this.raise(declaration ? FlowErrors.AssignReservedType : FlowErrors.UnexpectedReservedType, {
|
at: startLoc,
|
reservedType: word
|
});
|
}
|
flowParseRestrictedIdentifier(liberal, declaration) {
|
this.checkReservedType(this.state.value, this.state.startLoc, declaration);
|
return this.parseIdentifier(liberal);
|
}
|
flowParseTypeAlias(node) {
|
node.id = this.flowParseRestrictedIdentifier(false, true);
|
this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterDeclaration();
|
} else {
|
node.typeParameters = null;
|
}
|
node.right = this.flowParseTypeInitialiser(29);
|
this.semicolon();
|
return this.finishNode(node, "TypeAlias");
|
}
|
flowParseOpaqueType(node, declare) {
|
this.expectContextual(128);
|
node.id = this.flowParseRestrictedIdentifier(true, true);
|
this.scope.declareName(node.id.name, BIND_LEXICAL, node.id.loc.start);
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterDeclaration();
|
} else {
|
node.typeParameters = null;
|
}
|
node.supertype = null;
|
if (this.match(14)) {
|
node.supertype = this.flowParseTypeInitialiser(14);
|
}
|
node.impltype = null;
|
if (!declare) {
|
node.impltype = this.flowParseTypeInitialiser(29);
|
}
|
this.semicolon();
|
return this.finishNode(node, "OpaqueType");
|
}
|
flowParseTypeParameter(requireDefault = false) {
|
const nodeStartLoc = this.state.startLoc;
|
const node = this.startNode();
|
const variance = this.flowParseVariance();
|
const ident = this.flowParseTypeAnnotatableIdentifier();
|
node.name = ident.name;
|
node.variance = variance;
|
node.bound = ident.typeAnnotation;
|
if (this.match(29)) {
|
this.eat(29);
|
node.default = this.flowParseType();
|
} else {
|
if (requireDefault) {
|
this.raise(FlowErrors.MissingTypeParamDefault, {
|
at: nodeStartLoc
|
});
|
}
|
}
|
return this.finishNode(node, "TypeParameter");
|
}
|
flowParseTypeParameterDeclaration() {
|
const oldInType = this.state.inType;
|
const node = this.startNode();
|
node.params = [];
|
this.state.inType = true;
|
if (this.match(47) || this.match(140)) {
|
this.next();
|
} else {
|
this.unexpected();
|
}
|
let defaultRequired = false;
|
do {
|
const typeParameter = this.flowParseTypeParameter(defaultRequired);
|
node.params.push(typeParameter);
|
if (typeParameter.default) {
|
defaultRequired = true;
|
}
|
if (!this.match(48)) {
|
this.expect(12);
|
}
|
} while (!this.match(48));
|
this.expect(48);
|
this.state.inType = oldInType;
|
return this.finishNode(node, "TypeParameterDeclaration");
|
}
|
flowParseTypeParameterInstantiation() {
|
const node = this.startNode();
|
const oldInType = this.state.inType;
|
node.params = [];
|
this.state.inType = true;
|
this.expect(47);
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
|
this.state.noAnonFunctionType = false;
|
while (!this.match(48)) {
|
node.params.push(this.flowParseType());
|
if (!this.match(48)) {
|
this.expect(12);
|
}
|
}
|
this.state.noAnonFunctionType = oldNoAnonFunctionType;
|
this.expect(48);
|
this.state.inType = oldInType;
|
return this.finishNode(node, "TypeParameterInstantiation");
|
}
|
flowParseTypeParameterInstantiationCallOrNew() {
|
const node = this.startNode();
|
const oldInType = this.state.inType;
|
node.params = [];
|
this.state.inType = true;
|
this.expect(47);
|
while (!this.match(48)) {
|
node.params.push(this.flowParseTypeOrImplicitInstantiation());
|
if (!this.match(48)) {
|
this.expect(12);
|
}
|
}
|
this.expect(48);
|
this.state.inType = oldInType;
|
return this.finishNode(node, "TypeParameterInstantiation");
|
}
|
flowParseInterfaceType() {
|
const node = this.startNode();
|
this.expectContextual(127);
|
node.extends = [];
|
if (this.eat(81)) {
|
do {
|
node.extends.push(this.flowParseInterfaceExtends());
|
} while (this.eat(12));
|
}
|
node.body = this.flowParseObjectType({
|
allowStatic: false,
|
allowExact: false,
|
allowSpread: false,
|
allowProto: false,
|
allowInexact: false
|
});
|
return this.finishNode(node, "InterfaceTypeAnnotation");
|
}
|
flowParseObjectPropertyKey() {
|
return this.match(132) || this.match(131) ? super.parseExprAtom() : this.parseIdentifier(true);
|
}
|
flowParseObjectTypeIndexer(node, isStatic, variance) {
|
node.static = isStatic;
|
if (this.lookahead().type === 14) {
|
node.id = this.flowParseObjectPropertyKey();
|
node.key = this.flowParseTypeInitialiser();
|
} else {
|
node.id = null;
|
node.key = this.flowParseType();
|
}
|
this.expect(3);
|
node.value = this.flowParseTypeInitialiser();
|
node.variance = variance;
|
return this.finishNode(node, "ObjectTypeIndexer");
|
}
|
flowParseObjectTypeInternalSlot(node, isStatic) {
|
node.static = isStatic;
|
node.id = this.flowParseObjectPropertyKey();
|
this.expect(3);
|
this.expect(3);
|
if (this.match(47) || this.match(10)) {
|
node.method = true;
|
node.optional = false;
|
node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
|
} else {
|
node.method = false;
|
if (this.eat(17)) {
|
node.optional = true;
|
}
|
node.value = this.flowParseTypeInitialiser();
|
}
|
return this.finishNode(node, "ObjectTypeInternalSlot");
|
}
|
flowParseObjectTypeMethodish(node) {
|
node.params = [];
|
node.rest = null;
|
node.typeParameters = null;
|
node.this = null;
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterDeclaration();
|
}
|
this.expect(10);
|
if (this.match(78)) {
|
node.this = this.flowParseFunctionTypeParam(true);
|
node.this.name = null;
|
if (!this.match(11)) {
|
this.expect(12);
|
}
|
}
|
while (!this.match(11) && !this.match(21)) {
|
node.params.push(this.flowParseFunctionTypeParam(false));
|
if (!this.match(11)) {
|
this.expect(12);
|
}
|
}
|
if (this.eat(21)) {
|
node.rest = this.flowParseFunctionTypeParam(false);
|
}
|
this.expect(11);
|
node.returnType = this.flowParseTypeInitialiser();
|
return this.finishNode(node, "FunctionTypeAnnotation");
|
}
|
flowParseObjectTypeCallProperty(node, isStatic) {
|
const valueNode = this.startNode();
|
node.static = isStatic;
|
node.value = this.flowParseObjectTypeMethodish(valueNode);
|
return this.finishNode(node, "ObjectTypeCallProperty");
|
}
|
flowParseObjectType({
|
allowStatic,
|
allowExact,
|
allowSpread,
|
allowProto,
|
allowInexact
|
}) {
|
const oldInType = this.state.inType;
|
this.state.inType = true;
|
const nodeStart = this.startNode();
|
nodeStart.callProperties = [];
|
nodeStart.properties = [];
|
nodeStart.indexers = [];
|
nodeStart.internalSlots = [];
|
let endDelim;
|
let exact;
|
let inexact = false;
|
if (allowExact && this.match(6)) {
|
this.expect(6);
|
endDelim = 9;
|
exact = true;
|
} else {
|
this.expect(5);
|
endDelim = 8;
|
exact = false;
|
}
|
nodeStart.exact = exact;
|
while (!this.match(endDelim)) {
|
let isStatic = false;
|
let protoStartLoc = null;
|
let inexactStartLoc = null;
|
const node = this.startNode();
|
if (allowProto && this.isContextual(116)) {
|
const lookahead = this.lookahead();
|
if (lookahead.type !== 14 && lookahead.type !== 17) {
|
this.next();
|
protoStartLoc = this.state.startLoc;
|
allowStatic = false;
|
}
|
}
|
if (allowStatic && this.isContextual(104)) {
|
const lookahead = this.lookahead();
|
if (lookahead.type !== 14 && lookahead.type !== 17) {
|
this.next();
|
isStatic = true;
|
}
|
}
|
const variance = this.flowParseVariance();
|
if (this.eat(0)) {
|
if (protoStartLoc != null) {
|
this.unexpected(protoStartLoc);
|
}
|
if (this.eat(0)) {
|
if (variance) {
|
this.unexpected(variance.loc.start);
|
}
|
nodeStart.internalSlots.push(this.flowParseObjectTypeInternalSlot(node, isStatic));
|
} else {
|
nodeStart.indexers.push(this.flowParseObjectTypeIndexer(node, isStatic, variance));
|
}
|
} else if (this.match(10) || this.match(47)) {
|
if (protoStartLoc != null) {
|
this.unexpected(protoStartLoc);
|
}
|
if (variance) {
|
this.unexpected(variance.loc.start);
|
}
|
nodeStart.callProperties.push(this.flowParseObjectTypeCallProperty(node, isStatic));
|
} else {
|
let kind = "init";
|
if (this.isContextual(98) || this.isContextual(103)) {
|
const lookahead = this.lookahead();
|
if (tokenIsLiteralPropertyName(lookahead.type)) {
|
kind = this.state.value;
|
this.next();
|
}
|
}
|
const propOrInexact = this.flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact != null ? allowInexact : !exact);
|
if (propOrInexact === null) {
|
inexact = true;
|
inexactStartLoc = this.state.lastTokStartLoc;
|
} else {
|
nodeStart.properties.push(propOrInexact);
|
}
|
}
|
this.flowObjectTypeSemicolon();
|
if (inexactStartLoc && !this.match(8) && !this.match(9)) {
|
this.raise(FlowErrors.UnexpectedExplicitInexactInObject, {
|
at: inexactStartLoc
|
});
|
}
|
}
|
this.expect(endDelim);
|
if (allowSpread) {
|
nodeStart.inexact = inexact;
|
}
|
const out = this.finishNode(nodeStart, "ObjectTypeAnnotation");
|
this.state.inType = oldInType;
|
return out;
|
}
|
flowParseObjectTypeProperty(node, isStatic, protoStartLoc, variance, kind, allowSpread, allowInexact) {
|
if (this.eat(21)) {
|
const isInexactToken = this.match(12) || this.match(13) || this.match(8) || this.match(9);
|
if (isInexactToken) {
|
if (!allowSpread) {
|
this.raise(FlowErrors.InexactInsideNonObject, {
|
at: this.state.lastTokStartLoc
|
});
|
} else if (!allowInexact) {
|
this.raise(FlowErrors.InexactInsideExact, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
if (variance) {
|
this.raise(FlowErrors.InexactVariance, {
|
at: variance
|
});
|
}
|
return null;
|
}
|
if (!allowSpread) {
|
this.raise(FlowErrors.UnexpectedSpreadType, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
if (protoStartLoc != null) {
|
this.unexpected(protoStartLoc);
|
}
|
if (variance) {
|
this.raise(FlowErrors.SpreadVariance, {
|
at: variance
|
});
|
}
|
node.argument = this.flowParseType();
|
return this.finishNode(node, "ObjectTypeSpreadProperty");
|
} else {
|
node.key = this.flowParseObjectPropertyKey();
|
node.static = isStatic;
|
node.proto = protoStartLoc != null;
|
node.kind = kind;
|
let optional = false;
|
if (this.match(47) || this.match(10)) {
|
node.method = true;
|
if (protoStartLoc != null) {
|
this.unexpected(protoStartLoc);
|
}
|
if (variance) {
|
this.unexpected(variance.loc.start);
|
}
|
node.value = this.flowParseObjectTypeMethodish(this.startNodeAt(node.loc.start));
|
if (kind === "get" || kind === "set") {
|
this.flowCheckGetterSetterParams(node);
|
}
|
if (!allowSpread && node.key.name === "constructor" && node.value.this) {
|
this.raise(FlowErrors.ThisParamBannedInConstructor, {
|
at: node.value.this
|
});
|
}
|
} else {
|
if (kind !== "init") this.unexpected();
|
node.method = false;
|
if (this.eat(17)) {
|
optional = true;
|
}
|
node.value = this.flowParseTypeInitialiser();
|
node.variance = variance;
|
}
|
node.optional = optional;
|
return this.finishNode(node, "ObjectTypeProperty");
|
}
|
}
|
flowCheckGetterSetterParams(property) {
|
const paramCount = property.kind === "get" ? 0 : 1;
|
const length = property.value.params.length + (property.value.rest ? 1 : 0);
|
if (property.value.this) {
|
this.raise(property.kind === "get" ? FlowErrors.GetterMayNotHaveThisParam : FlowErrors.SetterMayNotHaveThisParam, {
|
at: property.value.this
|
});
|
}
|
if (length !== paramCount) {
|
this.raise(property.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
|
at: property
|
});
|
}
|
if (property.kind === "set" && property.value.rest) {
|
this.raise(Errors.BadSetterRestParameter, {
|
at: property
|
});
|
}
|
}
|
flowObjectTypeSemicolon() {
|
if (!this.eat(13) && !this.eat(12) && !this.match(8) && !this.match(9)) {
|
this.unexpected();
|
}
|
}
|
flowParseQualifiedTypeIdentifier(startLoc, id) {
|
var _startLoc;
|
(_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
|
let node = id || this.flowParseRestrictedIdentifier(true);
|
while (this.eat(16)) {
|
const node2 = this.startNodeAt(startLoc);
|
node2.qualification = node;
|
node2.id = this.flowParseRestrictedIdentifier(true);
|
node = this.finishNode(node2, "QualifiedTypeIdentifier");
|
}
|
return node;
|
}
|
flowParseGenericType(startLoc, id) {
|
const node = this.startNodeAt(startLoc);
|
node.typeParameters = null;
|
node.id = this.flowParseQualifiedTypeIdentifier(startLoc, id);
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterInstantiation();
|
}
|
return this.finishNode(node, "GenericTypeAnnotation");
|
}
|
flowParseTypeofType() {
|
const node = this.startNode();
|
this.expect(87);
|
node.argument = this.flowParsePrimaryType();
|
return this.finishNode(node, "TypeofTypeAnnotation");
|
}
|
flowParseTupleType() {
|
const node = this.startNode();
|
node.types = [];
|
this.expect(0);
|
while (this.state.pos < this.length && !this.match(3)) {
|
node.types.push(this.flowParseType());
|
if (this.match(3)) break;
|
this.expect(12);
|
}
|
this.expect(3);
|
return this.finishNode(node, "TupleTypeAnnotation");
|
}
|
flowParseFunctionTypeParam(first) {
|
let name = null;
|
let optional = false;
|
let typeAnnotation = null;
|
const node = this.startNode();
|
const lh = this.lookahead();
|
const isThis = this.state.type === 78;
|
if (lh.type === 14 || lh.type === 17) {
|
if (isThis && !first) {
|
this.raise(FlowErrors.ThisParamMustBeFirst, {
|
at: node
|
});
|
}
|
name = this.parseIdentifier(isThis);
|
if (this.eat(17)) {
|
optional = true;
|
if (isThis) {
|
this.raise(FlowErrors.ThisParamMayNotBeOptional, {
|
at: node
|
});
|
}
|
}
|
typeAnnotation = this.flowParseTypeInitialiser();
|
} else {
|
typeAnnotation = this.flowParseType();
|
}
|
node.name = name;
|
node.optional = optional;
|
node.typeAnnotation = typeAnnotation;
|
return this.finishNode(node, "FunctionTypeParam");
|
}
|
reinterpretTypeAsFunctionTypeParam(type) {
|
const node = this.startNodeAt(type.loc.start);
|
node.name = null;
|
node.optional = false;
|
node.typeAnnotation = type;
|
return this.finishNode(node, "FunctionTypeParam");
|
}
|
flowParseFunctionTypeParams(params = []) {
|
let rest = null;
|
let _this = null;
|
if (this.match(78)) {
|
_this = this.flowParseFunctionTypeParam(true);
|
_this.name = null;
|
if (!this.match(11)) {
|
this.expect(12);
|
}
|
}
|
while (!this.match(11) && !this.match(21)) {
|
params.push(this.flowParseFunctionTypeParam(false));
|
if (!this.match(11)) {
|
this.expect(12);
|
}
|
}
|
if (this.eat(21)) {
|
rest = this.flowParseFunctionTypeParam(false);
|
}
|
return {
|
params,
|
rest,
|
_this
|
};
|
}
|
flowIdentToTypeAnnotation(startLoc, node, id) {
|
switch (id.name) {
|
case "any":
|
return this.finishNode(node, "AnyTypeAnnotation");
|
case "bool":
|
case "boolean":
|
return this.finishNode(node, "BooleanTypeAnnotation");
|
case "mixed":
|
return this.finishNode(node, "MixedTypeAnnotation");
|
case "empty":
|
return this.finishNode(node, "EmptyTypeAnnotation");
|
case "number":
|
return this.finishNode(node, "NumberTypeAnnotation");
|
case "string":
|
return this.finishNode(node, "StringTypeAnnotation");
|
case "symbol":
|
return this.finishNode(node, "SymbolTypeAnnotation");
|
default:
|
this.checkNotUnderscore(id.name);
|
return this.flowParseGenericType(startLoc, id);
|
}
|
}
|
flowParsePrimaryType() {
|
const startLoc = this.state.startLoc;
|
const node = this.startNode();
|
let tmp;
|
let type;
|
let isGroupedType = false;
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
|
switch (this.state.type) {
|
case 5:
|
return this.flowParseObjectType({
|
allowStatic: false,
|
allowExact: false,
|
allowSpread: true,
|
allowProto: false,
|
allowInexact: true
|
});
|
case 6:
|
return this.flowParseObjectType({
|
allowStatic: false,
|
allowExact: true,
|
allowSpread: true,
|
allowProto: false,
|
allowInexact: false
|
});
|
case 0:
|
this.state.noAnonFunctionType = false;
|
type = this.flowParseTupleType();
|
this.state.noAnonFunctionType = oldNoAnonFunctionType;
|
return type;
|
case 47:
|
node.typeParameters = this.flowParseTypeParameterDeclaration();
|
this.expect(10);
|
tmp = this.flowParseFunctionTypeParams();
|
node.params = tmp.params;
|
node.rest = tmp.rest;
|
node.this = tmp._this;
|
this.expect(11);
|
this.expect(19);
|
node.returnType = this.flowParseType();
|
return this.finishNode(node, "FunctionTypeAnnotation");
|
case 10:
|
this.next();
|
if (!this.match(11) && !this.match(21)) {
|
if (tokenIsIdentifier(this.state.type) || this.match(78)) {
|
const token = this.lookahead().type;
|
isGroupedType = token !== 17 && token !== 14;
|
} else {
|
isGroupedType = true;
|
}
|
}
|
if (isGroupedType) {
|
this.state.noAnonFunctionType = false;
|
type = this.flowParseType();
|
this.state.noAnonFunctionType = oldNoAnonFunctionType;
|
if (this.state.noAnonFunctionType || !(this.match(12) || this.match(11) && this.lookahead().type === 19)) {
|
this.expect(11);
|
return type;
|
} else {
|
this.eat(12);
|
}
|
}
|
if (type) {
|
tmp = this.flowParseFunctionTypeParams([this.reinterpretTypeAsFunctionTypeParam(type)]);
|
} else {
|
tmp = this.flowParseFunctionTypeParams();
|
}
|
node.params = tmp.params;
|
node.rest = tmp.rest;
|
node.this = tmp._this;
|
this.expect(11);
|
this.expect(19);
|
node.returnType = this.flowParseType();
|
node.typeParameters = null;
|
return this.finishNode(node, "FunctionTypeAnnotation");
|
case 131:
|
return this.parseLiteral(this.state.value, "StringLiteralTypeAnnotation");
|
case 85:
|
case 86:
|
node.value = this.match(85);
|
this.next();
|
return this.finishNode(node, "BooleanLiteralTypeAnnotation");
|
case 53:
|
if (this.state.value === "-") {
|
this.next();
|
if (this.match(132)) {
|
return this.parseLiteralAtNode(-this.state.value, "NumberLiteralTypeAnnotation", node);
|
}
|
if (this.match(133)) {
|
return this.parseLiteralAtNode(-this.state.value, "BigIntLiteralTypeAnnotation", node);
|
}
|
throw this.raise(FlowErrors.UnexpectedSubtractionOperand, {
|
at: this.state.startLoc
|
});
|
}
|
this.unexpected();
|
return;
|
case 132:
|
return this.parseLiteral(this.state.value, "NumberLiteralTypeAnnotation");
|
case 133:
|
return this.parseLiteral(this.state.value, "BigIntLiteralTypeAnnotation");
|
case 88:
|
this.next();
|
return this.finishNode(node, "VoidTypeAnnotation");
|
case 84:
|
this.next();
|
return this.finishNode(node, "NullLiteralTypeAnnotation");
|
case 78:
|
this.next();
|
return this.finishNode(node, "ThisTypeAnnotation");
|
case 55:
|
this.next();
|
return this.finishNode(node, "ExistsTypeAnnotation");
|
case 87:
|
return this.flowParseTypeofType();
|
default:
|
if (tokenIsKeyword(this.state.type)) {
|
const label = tokenLabelName(this.state.type);
|
this.next();
|
return super.createIdentifier(node, label);
|
} else if (tokenIsIdentifier(this.state.type)) {
|
if (this.isContextual(127)) {
|
return this.flowParseInterfaceType();
|
}
|
return this.flowIdentToTypeAnnotation(startLoc, node, this.parseIdentifier());
|
}
|
}
|
this.unexpected();
|
}
|
flowParsePostfixType() {
|
const startLoc = this.state.startLoc;
|
let type = this.flowParsePrimaryType();
|
let seenOptionalIndexedAccess = false;
|
while ((this.match(0) || this.match(18)) && !this.canInsertSemicolon()) {
|
const node = this.startNodeAt(startLoc);
|
const optional = this.eat(18);
|
seenOptionalIndexedAccess = seenOptionalIndexedAccess || optional;
|
this.expect(0);
|
if (!optional && this.match(3)) {
|
node.elementType = type;
|
this.next();
|
type = this.finishNode(node, "ArrayTypeAnnotation");
|
} else {
|
node.objectType = type;
|
node.indexType = this.flowParseType();
|
this.expect(3);
|
if (seenOptionalIndexedAccess) {
|
node.optional = optional;
|
type = this.finishNode(node, "OptionalIndexedAccessType");
|
} else {
|
type = this.finishNode(node, "IndexedAccessType");
|
}
|
}
|
}
|
return type;
|
}
|
flowParsePrefixType() {
|
const node = this.startNode();
|
if (this.eat(17)) {
|
node.typeAnnotation = this.flowParsePrefixType();
|
return this.finishNode(node, "NullableTypeAnnotation");
|
} else {
|
return this.flowParsePostfixType();
|
}
|
}
|
flowParseAnonFunctionWithoutParens() {
|
const param = this.flowParsePrefixType();
|
if (!this.state.noAnonFunctionType && this.eat(19)) {
|
const node = this.startNodeAt(param.loc.start);
|
node.params = [this.reinterpretTypeAsFunctionTypeParam(param)];
|
node.rest = null;
|
node.this = null;
|
node.returnType = this.flowParseType();
|
node.typeParameters = null;
|
return this.finishNode(node, "FunctionTypeAnnotation");
|
}
|
return param;
|
}
|
flowParseIntersectionType() {
|
const node = this.startNode();
|
this.eat(45);
|
const type = this.flowParseAnonFunctionWithoutParens();
|
node.types = [type];
|
while (this.eat(45)) {
|
node.types.push(this.flowParseAnonFunctionWithoutParens());
|
}
|
return node.types.length === 1 ? type : this.finishNode(node, "IntersectionTypeAnnotation");
|
}
|
flowParseUnionType() {
|
const node = this.startNode();
|
this.eat(43);
|
const type = this.flowParseIntersectionType();
|
node.types = [type];
|
while (this.eat(43)) {
|
node.types.push(this.flowParseIntersectionType());
|
}
|
return node.types.length === 1 ? type : this.finishNode(node, "UnionTypeAnnotation");
|
}
|
flowParseType() {
|
const oldInType = this.state.inType;
|
this.state.inType = true;
|
const type = this.flowParseUnionType();
|
this.state.inType = oldInType;
|
return type;
|
}
|
flowParseTypeOrImplicitInstantiation() {
|
if (this.state.type === 130 && this.state.value === "_") {
|
const startLoc = this.state.startLoc;
|
const node = this.parseIdentifier();
|
return this.flowParseGenericType(startLoc, node);
|
} else {
|
return this.flowParseType();
|
}
|
}
|
flowParseTypeAnnotation() {
|
const node = this.startNode();
|
node.typeAnnotation = this.flowParseTypeInitialiser();
|
return this.finishNode(node, "TypeAnnotation");
|
}
|
flowParseTypeAnnotatableIdentifier(allowPrimitiveOverride) {
|
const ident = allowPrimitiveOverride ? this.parseIdentifier() : this.flowParseRestrictedIdentifier();
|
if (this.match(14)) {
|
ident.typeAnnotation = this.flowParseTypeAnnotation();
|
this.resetEndLocation(ident);
|
}
|
return ident;
|
}
|
typeCastToParameter(node) {
|
node.expression.typeAnnotation = node.typeAnnotation;
|
this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
|
return node.expression;
|
}
|
flowParseVariance() {
|
let variance = null;
|
if (this.match(53)) {
|
variance = this.startNode();
|
if (this.state.value === "+") {
|
variance.kind = "plus";
|
} else {
|
variance.kind = "minus";
|
}
|
this.next();
|
return this.finishNode(variance, "Variance");
|
}
|
return variance;
|
}
|
parseFunctionBody(node, allowExpressionBody, isMethod = false) {
|
if (allowExpressionBody) {
|
this.forwardNoArrowParamsConversionAt(node, () => super.parseFunctionBody(node, true, isMethod));
|
return;
|
}
|
super.parseFunctionBody(node, false, isMethod);
|
}
|
parseFunctionBodyAndFinish(node, type, isMethod = false) {
|
if (this.match(14)) {
|
const typeNode = this.startNode();
|
[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
|
node.returnType = typeNode.typeAnnotation ? this.finishNode(typeNode, "TypeAnnotation") : null;
|
}
|
return super.parseFunctionBodyAndFinish(node, type, isMethod);
|
}
|
parseStatementLike(flags) {
|
if (this.state.strict && this.isContextual(127)) {
|
const lookahead = this.lookahead();
|
if (tokenIsKeywordOrIdentifier(lookahead.type)) {
|
const node = this.startNode();
|
this.next();
|
return this.flowParseInterface(node);
|
}
|
} else if (this.shouldParseEnums() && this.isContextual(124)) {
|
const node = this.startNode();
|
this.next();
|
return this.flowParseEnumDeclaration(node);
|
}
|
const stmt = super.parseStatementLike(flags);
|
if (this.flowPragma === undefined && !this.isValidDirective(stmt)) {
|
this.flowPragma = null;
|
}
|
return stmt;
|
}
|
parseExpressionStatement(node, expr, decorators) {
|
if (expr.type === "Identifier") {
|
if (expr.name === "declare") {
|
if (this.match(80) || tokenIsIdentifier(this.state.type) || this.match(68) || this.match(74) || this.match(82)) {
|
return this.flowParseDeclare(node);
|
}
|
} else if (tokenIsIdentifier(this.state.type)) {
|
if (expr.name === "interface") {
|
return this.flowParseInterface(node);
|
} else if (expr.name === "type") {
|
return this.flowParseTypeAlias(node);
|
} else if (expr.name === "opaque") {
|
return this.flowParseOpaqueType(node, false);
|
}
|
}
|
}
|
return super.parseExpressionStatement(node, expr, decorators);
|
}
|
shouldParseExportDeclaration() {
|
const {
|
type
|
} = this.state;
|
if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 124) {
|
return !this.state.containsEsc;
|
}
|
return super.shouldParseExportDeclaration();
|
}
|
isExportDefaultSpecifier() {
|
const {
|
type
|
} = this.state;
|
if (tokenIsFlowInterfaceOrTypeOrOpaque(type) || this.shouldParseEnums() && type === 124) {
|
return this.state.containsEsc;
|
}
|
return super.isExportDefaultSpecifier();
|
}
|
parseExportDefaultExpression() {
|
if (this.shouldParseEnums() && this.isContextual(124)) {
|
const node = this.startNode();
|
this.next();
|
return this.flowParseEnumDeclaration(node);
|
}
|
return super.parseExportDefaultExpression();
|
}
|
parseConditional(expr, startLoc, refExpressionErrors) {
|
if (!this.match(17)) return expr;
|
if (this.state.maybeInArrowParameters) {
|
const nextCh = this.lookaheadCharCode();
|
if (nextCh === 44 || nextCh === 61 || nextCh === 58 || nextCh === 41) {
|
this.setOptionalParametersError(refExpressionErrors);
|
return expr;
|
}
|
}
|
this.expect(17);
|
const state = this.state.clone();
|
const originalNoArrowAt = this.state.noArrowAt;
|
const node = this.startNodeAt(startLoc);
|
let {
|
consequent,
|
failed
|
} = this.tryParseConditionalConsequent();
|
let [valid, invalid] = this.getArrowLikeExpressions(consequent);
|
if (failed || invalid.length > 0) {
|
const noArrowAt = [...originalNoArrowAt];
|
if (invalid.length > 0) {
|
this.state = state;
|
this.state.noArrowAt = noArrowAt;
|
for (let i = 0; i < invalid.length; i++) {
|
noArrowAt.push(invalid[i].start);
|
}
|
({
|
consequent,
|
failed
|
} = this.tryParseConditionalConsequent());
|
[valid, invalid] = this.getArrowLikeExpressions(consequent);
|
}
|
if (failed && valid.length > 1) {
|
this.raise(FlowErrors.AmbiguousConditionalArrow, {
|
at: state.startLoc
|
});
|
}
|
if (failed && valid.length === 1) {
|
this.state = state;
|
noArrowAt.push(valid[0].start);
|
this.state.noArrowAt = noArrowAt;
|
({
|
consequent,
|
failed
|
} = this.tryParseConditionalConsequent());
|
}
|
}
|
this.getArrowLikeExpressions(consequent, true);
|
this.state.noArrowAt = originalNoArrowAt;
|
this.expect(14);
|
node.test = expr;
|
node.consequent = consequent;
|
node.alternate = this.forwardNoArrowParamsConversionAt(node, () => this.parseMaybeAssign(undefined, undefined));
|
return this.finishNode(node, "ConditionalExpression");
|
}
|
tryParseConditionalConsequent() {
|
this.state.noArrowParamsConversionAt.push(this.state.start);
|
const consequent = this.parseMaybeAssignAllowIn();
|
const failed = !this.match(14);
|
this.state.noArrowParamsConversionAt.pop();
|
return {
|
consequent,
|
failed
|
};
|
}
|
getArrowLikeExpressions(node, disallowInvalid) {
|
const stack = [node];
|
const arrows = [];
|
while (stack.length !== 0) {
|
const node = stack.pop();
|
if (node.type === "ArrowFunctionExpression") {
|
if (node.typeParameters || !node.returnType) {
|
this.finishArrowValidation(node);
|
} else {
|
arrows.push(node);
|
}
|
stack.push(node.body);
|
} else if (node.type === "ConditionalExpression") {
|
stack.push(node.consequent);
|
stack.push(node.alternate);
|
}
|
}
|
if (disallowInvalid) {
|
arrows.forEach(node => this.finishArrowValidation(node));
|
return [arrows, []];
|
}
|
return partition(arrows, node => node.params.every(param => this.isAssignable(param, true)));
|
}
|
finishArrowValidation(node) {
|
var _node$extra;
|
this.toAssignableList(node.params, (_node$extra = node.extra) == null ? void 0 : _node$extra.trailingCommaLoc, false);
|
this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);
|
super.checkParams(node, false, true);
|
this.scope.exit();
|
}
|
forwardNoArrowParamsConversionAt(node, parse) {
|
let result;
|
if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
|
this.state.noArrowParamsConversionAt.push(this.state.start);
|
result = parse();
|
this.state.noArrowParamsConversionAt.pop();
|
} else {
|
result = parse();
|
}
|
return result;
|
}
|
parseParenItem(node, startLoc) {
|
node = super.parseParenItem(node, startLoc);
|
if (this.eat(17)) {
|
node.optional = true;
|
this.resetEndLocation(node);
|
}
|
if (this.match(14)) {
|
const typeCastNode = this.startNodeAt(startLoc);
|
typeCastNode.expression = node;
|
typeCastNode.typeAnnotation = this.flowParseTypeAnnotation();
|
return this.finishNode(typeCastNode, "TypeCastExpression");
|
}
|
return node;
|
}
|
assertModuleNodeAllowed(node) {
|
if (node.type === "ImportDeclaration" && (node.importKind === "type" || node.importKind === "typeof") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "ExportAllDeclaration" && node.exportKind === "type") {
|
return;
|
}
|
super.assertModuleNodeAllowed(node);
|
}
|
parseExport(node, decorators) {
|
const decl = super.parseExport(node, decorators);
|
if (decl.type === "ExportNamedDeclaration" || decl.type === "ExportAllDeclaration") {
|
decl.exportKind = decl.exportKind || "value";
|
}
|
return decl;
|
}
|
parseExportDeclaration(node) {
|
if (this.isContextual(128)) {
|
node.exportKind = "type";
|
const declarationNode = this.startNode();
|
this.next();
|
if (this.match(5)) {
|
node.specifiers = this.parseExportSpecifiers(true);
|
super.parseExportFrom(node);
|
return null;
|
} else {
|
return this.flowParseTypeAlias(declarationNode);
|
}
|
} else if (this.isContextual(129)) {
|
node.exportKind = "type";
|
const declarationNode = this.startNode();
|
this.next();
|
return this.flowParseOpaqueType(declarationNode, false);
|
} else if (this.isContextual(127)) {
|
node.exportKind = "type";
|
const declarationNode = this.startNode();
|
this.next();
|
return this.flowParseInterface(declarationNode);
|
} else if (this.shouldParseEnums() && this.isContextual(124)) {
|
node.exportKind = "value";
|
const declarationNode = this.startNode();
|
this.next();
|
return this.flowParseEnumDeclaration(declarationNode);
|
} else {
|
return super.parseExportDeclaration(node);
|
}
|
}
|
eatExportStar(node) {
|
if (super.eatExportStar(node)) return true;
|
if (this.isContextual(128) && this.lookahead().type === 55) {
|
node.exportKind = "type";
|
this.next();
|
this.next();
|
return true;
|
}
|
return false;
|
}
|
maybeParseExportNamespaceSpecifier(node) {
|
const {
|
startLoc
|
} = this.state;
|
const hasNamespace = super.maybeParseExportNamespaceSpecifier(node);
|
if (hasNamespace && node.exportKind === "type") {
|
this.unexpected(startLoc);
|
}
|
return hasNamespace;
|
}
|
parseClassId(node, isStatement, optionalId) {
|
super.parseClassId(node, isStatement, optionalId);
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterDeclaration();
|
}
|
}
|
parseClassMember(classBody, member, state) {
|
const {
|
startLoc
|
} = this.state;
|
if (this.isContextual(123)) {
|
if (super.parseClassMemberFromModifier(classBody, member)) {
|
return;
|
}
|
member.declare = true;
|
}
|
super.parseClassMember(classBody, member, state);
|
if (member.declare) {
|
if (member.type !== "ClassProperty" && member.type !== "ClassPrivateProperty" && member.type !== "PropertyDefinition") {
|
this.raise(FlowErrors.DeclareClassElement, {
|
at: startLoc
|
});
|
} else if (member.value) {
|
this.raise(FlowErrors.DeclareClassFieldInitializer, {
|
at: member.value
|
});
|
}
|
}
|
}
|
isIterator(word) {
|
return word === "iterator" || word === "asyncIterator";
|
}
|
readIterator() {
|
const word = super.readWord1();
|
const fullWord = "@@" + word;
|
if (!this.isIterator(word) || !this.state.inType) {
|
this.raise(Errors.InvalidIdentifier, {
|
at: this.state.curPosition(),
|
identifierName: fullWord
|
});
|
}
|
this.finishToken(130, fullWord);
|
}
|
getTokenFromCode(code) {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (code === 123 && next === 124) {
|
this.finishOp(6, 2);
|
} else if (this.state.inType && (code === 62 || code === 60)) {
|
this.finishOp(code === 62 ? 48 : 47, 1);
|
} else if (this.state.inType && code === 63) {
|
if (next === 46) {
|
this.finishOp(18, 2);
|
} else {
|
this.finishOp(17, 1);
|
}
|
} else if (isIteratorStart(code, next, this.input.charCodeAt(this.state.pos + 2))) {
|
this.state.pos += 2;
|
this.readIterator();
|
} else {
|
super.getTokenFromCode(code);
|
}
|
}
|
isAssignable(node, isBinding) {
|
if (node.type === "TypeCastExpression") {
|
return this.isAssignable(node.expression, isBinding);
|
} else {
|
return super.isAssignable(node, isBinding);
|
}
|
}
|
toAssignable(node, isLHS = false) {
|
if (!isLHS && node.type === "AssignmentExpression" && node.left.type === "TypeCastExpression") {
|
node.left = this.typeCastToParameter(node.left);
|
}
|
super.toAssignable(node, isLHS);
|
}
|
toAssignableList(exprList, trailingCommaLoc, isLHS) {
|
for (let i = 0; i < exprList.length; i++) {
|
const expr = exprList[i];
|
if ((expr == null ? void 0 : expr.type) === "TypeCastExpression") {
|
exprList[i] = this.typeCastToParameter(expr);
|
}
|
}
|
super.toAssignableList(exprList, trailingCommaLoc, isLHS);
|
}
|
toReferencedList(exprList, isParenthesizedExpr) {
|
for (let i = 0; i < exprList.length; i++) {
|
var _expr$extra;
|
const expr = exprList[i];
|
if (expr && expr.type === "TypeCastExpression" && !((_expr$extra = expr.extra) != null && _expr$extra.parenthesized) && (exprList.length > 1 || !isParenthesizedExpr)) {
|
this.raise(FlowErrors.TypeCastInPattern, {
|
at: expr.typeAnnotation
|
});
|
}
|
}
|
return exprList;
|
}
|
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
|
const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
|
if (canBePattern && !this.state.maybeInArrowParameters) {
|
this.toReferencedList(node.elements);
|
}
|
return node;
|
}
|
isValidLVal(type, isParenthesized, binding) {
|
return type === "TypeCastExpression" || super.isValidLVal(type, isParenthesized, binding);
|
}
|
parseClassProperty(node) {
|
if (this.match(14)) {
|
node.typeAnnotation = this.flowParseTypeAnnotation();
|
}
|
return super.parseClassProperty(node);
|
}
|
parseClassPrivateProperty(node) {
|
if (this.match(14)) {
|
node.typeAnnotation = this.flowParseTypeAnnotation();
|
}
|
return super.parseClassPrivateProperty(node);
|
}
|
isClassMethod() {
|
return this.match(47) || super.isClassMethod();
|
}
|
isClassProperty() {
|
return this.match(14) || super.isClassProperty();
|
}
|
isNonstaticConstructor(method) {
|
return !this.match(14) && super.isNonstaticConstructor(method);
|
}
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
|
if (method.variance) {
|
this.unexpected(method.variance.loc.start);
|
}
|
delete method.variance;
|
if (this.match(47)) {
|
method.typeParameters = this.flowParseTypeParameterDeclaration();
|
}
|
super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
|
if (method.params && isConstructor) {
|
const params = method.params;
|
if (params.length > 0 && this.isThisParam(params[0])) {
|
this.raise(FlowErrors.ThisParamBannedInConstructor, {
|
at: method
|
});
|
}
|
} else if (method.type === "MethodDefinition" && isConstructor && method.value.params) {
|
const params = method.value.params;
|
if (params.length > 0 && this.isThisParam(params[0])) {
|
this.raise(FlowErrors.ThisParamBannedInConstructor, {
|
at: method
|
});
|
}
|
}
|
}
|
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
|
if (method.variance) {
|
this.unexpected(method.variance.loc.start);
|
}
|
delete method.variance;
|
if (this.match(47)) {
|
method.typeParameters = this.flowParseTypeParameterDeclaration();
|
}
|
super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
|
}
|
parseClassSuper(node) {
|
super.parseClassSuper(node);
|
if (node.superClass && this.match(47)) {
|
node.superTypeParameters = this.flowParseTypeParameterInstantiation();
|
}
|
if (this.isContextual(111)) {
|
this.next();
|
const implemented = node.implements = [];
|
do {
|
const node = this.startNode();
|
node.id = this.flowParseRestrictedIdentifier(true);
|
if (this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterInstantiation();
|
} else {
|
node.typeParameters = null;
|
}
|
implemented.push(this.finishNode(node, "ClassImplements"));
|
} while (this.eat(12));
|
}
|
}
|
checkGetterSetterParams(method) {
|
super.checkGetterSetterParams(method);
|
const params = this.getObjectOrClassMethodParams(method);
|
if (params.length > 0) {
|
const param = params[0];
|
if (this.isThisParam(param) && method.kind === "get") {
|
this.raise(FlowErrors.GetterMayNotHaveThisParam, {
|
at: param
|
});
|
} else if (this.isThisParam(param)) {
|
this.raise(FlowErrors.SetterMayNotHaveThisParam, {
|
at: param
|
});
|
}
|
}
|
}
|
parsePropertyNamePrefixOperator(node) {
|
node.variance = this.flowParseVariance();
|
}
|
parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
|
if (prop.variance) {
|
this.unexpected(prop.variance.loc.start);
|
}
|
delete prop.variance;
|
let typeParameters;
|
if (this.match(47) && !isAccessor) {
|
typeParameters = this.flowParseTypeParameterDeclaration();
|
if (!this.match(10)) this.unexpected();
|
}
|
const result = super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
|
if (typeParameters) {
|
(result.value || result).typeParameters = typeParameters;
|
}
|
return result;
|
}
|
parseAssignableListItemTypes(param) {
|
if (this.eat(17)) {
|
if (param.type !== "Identifier") {
|
this.raise(FlowErrors.PatternIsOptional, {
|
at: param
|
});
|
}
|
if (this.isThisParam(param)) {
|
this.raise(FlowErrors.ThisParamMayNotBeOptional, {
|
at: param
|
});
|
}
|
param.optional = true;
|
}
|
if (this.match(14)) {
|
param.typeAnnotation = this.flowParseTypeAnnotation();
|
} else if (this.isThisParam(param)) {
|
this.raise(FlowErrors.ThisParamAnnotationRequired, {
|
at: param
|
});
|
}
|
if (this.match(29) && this.isThisParam(param)) {
|
this.raise(FlowErrors.ThisParamNoDefault, {
|
at: param
|
});
|
}
|
this.resetEndLocation(param);
|
return param;
|
}
|
parseMaybeDefault(startLoc, left) {
|
const node = super.parseMaybeDefault(startLoc, left);
|
if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
|
this.raise(FlowErrors.TypeBeforeInitializer, {
|
at: node.typeAnnotation
|
});
|
}
|
return node;
|
}
|
shouldParseDefaultImport(node) {
|
if (!hasTypeImportKind(node)) {
|
return super.shouldParseDefaultImport(node);
|
}
|
return isMaybeDefaultImport(this.state.type);
|
}
|
checkImportReflection(node) {
|
super.checkImportReflection(node);
|
if (node.module && node.importKind !== "value") {
|
this.raise(FlowErrors.ImportReflectionHasImportType, {
|
at: node.specifiers[0].loc.start
|
});
|
}
|
}
|
parseImportSpecifierLocal(node, specifier, type) {
|
specifier.local = hasTypeImportKind(node) ? this.flowParseRestrictedIdentifier(true, true) : this.parseIdentifier();
|
node.specifiers.push(this.finishImportSpecifier(specifier, type));
|
}
|
maybeParseDefaultImportSpecifier(node) {
|
node.importKind = "value";
|
let kind = null;
|
if (this.match(87)) {
|
kind = "typeof";
|
} else if (this.isContextual(128)) {
|
kind = "type";
|
}
|
if (kind) {
|
const lh = this.lookahead();
|
const {
|
type
|
} = lh;
|
if (kind === "type" && type === 55) {
|
this.unexpected(null, lh.type);
|
}
|
if (isMaybeDefaultImport(type) || type === 5 || type === 55) {
|
this.next();
|
node.importKind = kind;
|
}
|
}
|
return super.maybeParseDefaultImportSpecifier(node);
|
}
|
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
|
const firstIdent = specifier.imported;
|
let specifierTypeKind = null;
|
if (firstIdent.type === "Identifier") {
|
if (firstIdent.name === "type") {
|
specifierTypeKind = "type";
|
} else if (firstIdent.name === "typeof") {
|
specifierTypeKind = "typeof";
|
}
|
}
|
let isBinding = false;
|
if (this.isContextual(93) && !this.isLookaheadContextual("as")) {
|
const as_ident = this.parseIdentifier(true);
|
if (specifierTypeKind !== null && !tokenIsKeywordOrIdentifier(this.state.type)) {
|
specifier.imported = as_ident;
|
specifier.importKind = specifierTypeKind;
|
specifier.local = cloneIdentifier(as_ident);
|
} else {
|
specifier.imported = firstIdent;
|
specifier.importKind = null;
|
specifier.local = this.parseIdentifier();
|
}
|
} else {
|
if (specifierTypeKind !== null && tokenIsKeywordOrIdentifier(this.state.type)) {
|
specifier.imported = this.parseIdentifier(true);
|
specifier.importKind = specifierTypeKind;
|
} else {
|
if (importedIsString) {
|
throw this.raise(Errors.ImportBindingIsString, {
|
at: specifier,
|
importName: firstIdent.value
|
});
|
}
|
specifier.imported = firstIdent;
|
specifier.importKind = null;
|
}
|
if (this.eatContextual(93)) {
|
specifier.local = this.parseIdentifier();
|
} else {
|
isBinding = true;
|
specifier.local = cloneIdentifier(specifier.imported);
|
}
|
}
|
const specifierIsTypeImport = hasTypeImportKind(specifier);
|
if (isInTypeOnlyImport && specifierIsTypeImport) {
|
this.raise(FlowErrors.ImportTypeShorthandOnlyInPureImport, {
|
at: specifier
|
});
|
}
|
if (isInTypeOnlyImport || specifierIsTypeImport) {
|
this.checkReservedType(specifier.local.name, specifier.local.loc.start, true);
|
}
|
if (isBinding && !isInTypeOnlyImport && !specifierIsTypeImport) {
|
this.checkReservedWord(specifier.local.name, specifier.loc.start, true, true);
|
}
|
return this.finishImportSpecifier(specifier, "ImportSpecifier");
|
}
|
parseBindingAtom() {
|
switch (this.state.type) {
|
case 78:
|
return this.parseIdentifier(true);
|
default:
|
return super.parseBindingAtom();
|
}
|
}
|
parseFunctionParams(node, isConstructor) {
|
const kind = node.kind;
|
if (kind !== "get" && kind !== "set" && this.match(47)) {
|
node.typeParameters = this.flowParseTypeParameterDeclaration();
|
}
|
super.parseFunctionParams(node, isConstructor);
|
}
|
parseVarId(decl, kind) {
|
super.parseVarId(decl, kind);
|
if (this.match(14)) {
|
decl.id.typeAnnotation = this.flowParseTypeAnnotation();
|
this.resetEndLocation(decl.id);
|
}
|
}
|
parseAsyncArrowFromCallExpression(node, call) {
|
if (this.match(14)) {
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
|
this.state.noAnonFunctionType = true;
|
node.returnType = this.flowParseTypeAnnotation();
|
this.state.noAnonFunctionType = oldNoAnonFunctionType;
|
}
|
return super.parseAsyncArrowFromCallExpression(node, call);
|
}
|
shouldParseAsyncArrow() {
|
return this.match(14) || super.shouldParseAsyncArrow();
|
}
|
parseMaybeAssign(refExpressionErrors, afterLeftParse) {
|
var _jsx;
|
let state = null;
|
let jsx;
|
if (this.hasPlugin("jsx") && (this.match(140) || this.match(47))) {
|
state = this.state.clone();
|
jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
|
if (!jsx.error) return jsx.node;
|
const {
|
context
|
} = this.state;
|
const currentContext = context[context.length - 1];
|
if (currentContext === types$1.j_oTag || currentContext === types$1.j_expr) {
|
context.pop();
|
}
|
}
|
if ((_jsx = jsx) != null && _jsx.error || this.match(47)) {
|
var _jsx2, _jsx3;
|
state = state || this.state.clone();
|
let typeParameters;
|
const arrow = this.tryParse(abort => {
|
var _arrowExpression$extr;
|
typeParameters = this.flowParseTypeParameterDeclaration();
|
const arrowExpression = this.forwardNoArrowParamsConversionAt(typeParameters, () => {
|
const result = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
|
this.resetStartLocationFromNode(result, typeParameters);
|
return result;
|
});
|
if ((_arrowExpression$extr = arrowExpression.extra) != null && _arrowExpression$extr.parenthesized) abort();
|
const expr = this.maybeUnwrapTypeCastExpression(arrowExpression);
|
if (expr.type !== "ArrowFunctionExpression") abort();
|
expr.typeParameters = typeParameters;
|
this.resetStartLocationFromNode(expr, typeParameters);
|
return arrowExpression;
|
}, state);
|
let arrowExpression = null;
|
if (arrow.node && this.maybeUnwrapTypeCastExpression(arrow.node).type === "ArrowFunctionExpression") {
|
if (!arrow.error && !arrow.aborted) {
|
if (arrow.node.async) {
|
this.raise(FlowErrors.UnexpectedTypeParameterBeforeAsyncArrowFunction, {
|
at: typeParameters
|
});
|
}
|
return arrow.node;
|
}
|
arrowExpression = arrow.node;
|
}
|
if ((_jsx2 = jsx) != null && _jsx2.node) {
|
this.state = jsx.failState;
|
return jsx.node;
|
}
|
if (arrowExpression) {
|
this.state = arrow.failState;
|
return arrowExpression;
|
}
|
if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
|
if (arrow.thrown) throw arrow.error;
|
throw this.raise(FlowErrors.UnexpectedTokenAfterTypeParameter, {
|
at: typeParameters
|
});
|
}
|
return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
|
}
|
parseArrow(node) {
|
if (this.match(14)) {
|
const result = this.tryParse(() => {
|
const oldNoAnonFunctionType = this.state.noAnonFunctionType;
|
this.state.noAnonFunctionType = true;
|
const typeNode = this.startNode();
|
[typeNode.typeAnnotation, node.predicate] = this.flowParseTypeAndPredicateInitialiser();
|
this.state.noAnonFunctionType = oldNoAnonFunctionType;
|
if (this.canInsertSemicolon()) this.unexpected();
|
if (!this.match(19)) this.unexpected();
|
return typeNode;
|
});
|
if (result.thrown) return null;
|
if (result.error) this.state = result.failState;
|
node.returnType = result.node.typeAnnotation ? this.finishNode(result.node, "TypeAnnotation") : null;
|
}
|
return super.parseArrow(node);
|
}
|
shouldParseArrow(params) {
|
return this.match(14) || super.shouldParseArrow(params);
|
}
|
setArrowFunctionParameters(node, params) {
|
if (this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
|
node.params = params;
|
} else {
|
super.setArrowFunctionParameters(node, params);
|
}
|
}
|
checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
|
if (isArrowFunction && this.state.noArrowParamsConversionAt.indexOf(node.start) !== -1) {
|
return;
|
}
|
for (let i = 0; i < node.params.length; i++) {
|
if (this.isThisParam(node.params[i]) && i > 0) {
|
this.raise(FlowErrors.ThisParamMustBeFirst, {
|
at: node.params[i]
|
});
|
}
|
}
|
super.checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged);
|
}
|
parseParenAndDistinguishExpression(canBeArrow) {
|
return super.parseParenAndDistinguishExpression(canBeArrow && this.state.noArrowAt.indexOf(this.state.start) === -1);
|
}
|
parseSubscripts(base, startLoc, noCalls) {
|
if (base.type === "Identifier" && base.name === "async" && this.state.noArrowAt.indexOf(startLoc.index) !== -1) {
|
this.next();
|
const node = this.startNodeAt(startLoc);
|
node.callee = base;
|
node.arguments = super.parseCallExpressionArguments(11, false);
|
base = this.finishNode(node, "CallExpression");
|
} else if (base.type === "Identifier" && base.name === "async" && this.match(47)) {
|
const state = this.state.clone();
|
const arrow = this.tryParse(abort => this.parseAsyncArrowWithTypeParameters(startLoc) || abort(), state);
|
if (!arrow.error && !arrow.aborted) return arrow.node;
|
const result = this.tryParse(() => super.parseSubscripts(base, startLoc, noCalls), state);
|
if (result.node && !result.error) return result.node;
|
if (arrow.node) {
|
this.state = arrow.failState;
|
return arrow.node;
|
}
|
if (result.node) {
|
this.state = result.failState;
|
return result.node;
|
}
|
throw arrow.error || result.error;
|
}
|
return super.parseSubscripts(base, startLoc, noCalls);
|
}
|
parseSubscript(base, startLoc, noCalls, subscriptState) {
|
if (this.match(18) && this.isLookaheadToken_lt()) {
|
subscriptState.optionalChainMember = true;
|
if (noCalls) {
|
subscriptState.stop = true;
|
return base;
|
}
|
this.next();
|
const node = this.startNodeAt(startLoc);
|
node.callee = base;
|
node.typeArguments = this.flowParseTypeParameterInstantiation();
|
this.expect(10);
|
node.arguments = this.parseCallExpressionArguments(11, false);
|
node.optional = true;
|
return this.finishCallExpression(node, true);
|
} else if (!noCalls && this.shouldParseTypes() && this.match(47)) {
|
const node = this.startNodeAt(startLoc);
|
node.callee = base;
|
const result = this.tryParse(() => {
|
node.typeArguments = this.flowParseTypeParameterInstantiationCallOrNew();
|
this.expect(10);
|
node.arguments = super.parseCallExpressionArguments(11, false);
|
if (subscriptState.optionalChainMember) {
|
node.optional = false;
|
}
|
return this.finishCallExpression(node, subscriptState.optionalChainMember);
|
});
|
if (result.node) {
|
if (result.error) this.state = result.failState;
|
return result.node;
|
}
|
}
|
return super.parseSubscript(base, startLoc, noCalls, subscriptState);
|
}
|
parseNewCallee(node) {
|
super.parseNewCallee(node);
|
let targs = null;
|
if (this.shouldParseTypes() && this.match(47)) {
|
targs = this.tryParse(() => this.flowParseTypeParameterInstantiationCallOrNew()).node;
|
}
|
node.typeArguments = targs;
|
}
|
parseAsyncArrowWithTypeParameters(startLoc) {
|
const node = this.startNodeAt(startLoc);
|
this.parseFunctionParams(node, false);
|
if (!this.parseArrow(node)) return;
|
return super.parseArrowExpression(node, undefined, true);
|
}
|
readToken_mult_modulo(code) {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (code === 42 && next === 47 && this.state.hasFlowComment) {
|
this.state.hasFlowComment = false;
|
this.state.pos += 2;
|
this.nextToken();
|
return;
|
}
|
super.readToken_mult_modulo(code);
|
}
|
readToken_pipe_amp(code) {
|
const next = this.input.charCodeAt(this.state.pos + 1);
|
if (code === 124 && next === 125) {
|
this.finishOp(9, 2);
|
return;
|
}
|
super.readToken_pipe_amp(code);
|
}
|
parseTopLevel(file, program) {
|
const fileNode = super.parseTopLevel(file, program);
|
if (this.state.hasFlowComment) {
|
this.raise(FlowErrors.UnterminatedFlowComment, {
|
at: this.state.curPosition()
|
});
|
}
|
return fileNode;
|
}
|
skipBlockComment() {
|
if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
|
if (this.state.hasFlowComment) {
|
throw this.raise(FlowErrors.NestedFlowComment, {
|
at: this.state.startLoc
|
});
|
}
|
this.hasFlowCommentCompletion();
|
const commentSkip = this.skipFlowComment();
|
if (commentSkip) {
|
this.state.pos += commentSkip;
|
this.state.hasFlowComment = true;
|
}
|
return;
|
}
|
return super.skipBlockComment(this.state.hasFlowComment ? "*-/" : "*/");
|
}
|
skipFlowComment() {
|
const {
|
pos
|
} = this.state;
|
let shiftToFirstNonWhiteSpace = 2;
|
while ([32, 9].includes(this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace))) {
|
shiftToFirstNonWhiteSpace++;
|
}
|
const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
|
const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
|
if (ch2 === 58 && ch3 === 58) {
|
return shiftToFirstNonWhiteSpace + 2;
|
}
|
if (this.input.slice(shiftToFirstNonWhiteSpace + pos, shiftToFirstNonWhiteSpace + pos + 12) === "flow-include") {
|
return shiftToFirstNonWhiteSpace + 12;
|
}
|
if (ch2 === 58 && ch3 !== 58) {
|
return shiftToFirstNonWhiteSpace;
|
}
|
return false;
|
}
|
hasFlowCommentCompletion() {
|
const end = this.input.indexOf("*/", this.state.pos);
|
if (end === -1) {
|
throw this.raise(Errors.UnterminatedComment, {
|
at: this.state.curPosition()
|
});
|
}
|
}
|
flowEnumErrorBooleanMemberNotInitialized(loc, {
|
enumName,
|
memberName
|
}) {
|
this.raise(FlowErrors.EnumBooleanMemberNotInitialized, {
|
at: loc,
|
memberName,
|
enumName
|
});
|
}
|
flowEnumErrorInvalidMemberInitializer(loc, enumContext) {
|
return this.raise(!enumContext.explicitType ? FlowErrors.EnumInvalidMemberInitializerUnknownType : enumContext.explicitType === "symbol" ? FlowErrors.EnumInvalidMemberInitializerSymbolType : FlowErrors.EnumInvalidMemberInitializerPrimaryType, Object.assign({
|
at: loc
|
}, enumContext));
|
}
|
flowEnumErrorNumberMemberNotInitialized(loc, {
|
enumName,
|
memberName
|
}) {
|
this.raise(FlowErrors.EnumNumberMemberNotInitialized, {
|
at: loc,
|
enumName,
|
memberName
|
});
|
}
|
flowEnumErrorStringMemberInconsistentlyInitailized(node, {
|
enumName
|
}) {
|
this.raise(FlowErrors.EnumStringMemberInconsistentlyInitailized, {
|
at: node,
|
enumName
|
});
|
}
|
flowEnumMemberInit() {
|
const startLoc = this.state.startLoc;
|
const endOfInit = () => this.match(12) || this.match(8);
|
switch (this.state.type) {
|
case 132:
|
{
|
const literal = this.parseNumericLiteral(this.state.value);
|
if (endOfInit()) {
|
return {
|
type: "number",
|
loc: literal.loc.start,
|
value: literal
|
};
|
}
|
return {
|
type: "invalid",
|
loc: startLoc
|
};
|
}
|
case 131:
|
{
|
const literal = this.parseStringLiteral(this.state.value);
|
if (endOfInit()) {
|
return {
|
type: "string",
|
loc: literal.loc.start,
|
value: literal
|
};
|
}
|
return {
|
type: "invalid",
|
loc: startLoc
|
};
|
}
|
case 85:
|
case 86:
|
{
|
const literal = this.parseBooleanLiteral(this.match(85));
|
if (endOfInit()) {
|
return {
|
type: "boolean",
|
loc: literal.loc.start,
|
value: literal
|
};
|
}
|
return {
|
type: "invalid",
|
loc: startLoc
|
};
|
}
|
default:
|
return {
|
type: "invalid",
|
loc: startLoc
|
};
|
}
|
}
|
flowEnumMemberRaw() {
|
const loc = this.state.startLoc;
|
const id = this.parseIdentifier(true);
|
const init = this.eat(29) ? this.flowEnumMemberInit() : {
|
type: "none",
|
loc
|
};
|
return {
|
id,
|
init
|
};
|
}
|
flowEnumCheckExplicitTypeMismatch(loc, context, expectedType) {
|
const {
|
explicitType
|
} = context;
|
if (explicitType === null) {
|
return;
|
}
|
if (explicitType !== expectedType) {
|
this.flowEnumErrorInvalidMemberInitializer(loc, context);
|
}
|
}
|
flowEnumMembers({
|
enumName,
|
explicitType
|
}) {
|
const seenNames = new Set();
|
const members = {
|
booleanMembers: [],
|
numberMembers: [],
|
stringMembers: [],
|
defaultedMembers: []
|
};
|
let hasUnknownMembers = false;
|
while (!this.match(8)) {
|
if (this.eat(21)) {
|
hasUnknownMembers = true;
|
break;
|
}
|
const memberNode = this.startNode();
|
const {
|
id,
|
init
|
} = this.flowEnumMemberRaw();
|
const memberName = id.name;
|
if (memberName === "") {
|
continue;
|
}
|
if (/^[a-z]/.test(memberName)) {
|
this.raise(FlowErrors.EnumInvalidMemberName, {
|
at: id,
|
memberName,
|
suggestion: memberName[0].toUpperCase() + memberName.slice(1),
|
enumName
|
});
|
}
|
if (seenNames.has(memberName)) {
|
this.raise(FlowErrors.EnumDuplicateMemberName, {
|
at: id,
|
memberName,
|
enumName
|
});
|
}
|
seenNames.add(memberName);
|
const context = {
|
enumName,
|
explicitType,
|
memberName
|
};
|
memberNode.id = id;
|
switch (init.type) {
|
case "boolean":
|
{
|
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "boolean");
|
memberNode.init = init.value;
|
members.booleanMembers.push(this.finishNode(memberNode, "EnumBooleanMember"));
|
break;
|
}
|
case "number":
|
{
|
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "number");
|
memberNode.init = init.value;
|
members.numberMembers.push(this.finishNode(memberNode, "EnumNumberMember"));
|
break;
|
}
|
case "string":
|
{
|
this.flowEnumCheckExplicitTypeMismatch(init.loc, context, "string");
|
memberNode.init = init.value;
|
members.stringMembers.push(this.finishNode(memberNode, "EnumStringMember"));
|
break;
|
}
|
case "invalid":
|
{
|
throw this.flowEnumErrorInvalidMemberInitializer(init.loc, context);
|
}
|
case "none":
|
{
|
switch (explicitType) {
|
case "boolean":
|
this.flowEnumErrorBooleanMemberNotInitialized(init.loc, context);
|
break;
|
case "number":
|
this.flowEnumErrorNumberMemberNotInitialized(init.loc, context);
|
break;
|
default:
|
members.defaultedMembers.push(this.finishNode(memberNode, "EnumDefaultedMember"));
|
}
|
}
|
}
|
if (!this.match(8)) {
|
this.expect(12);
|
}
|
}
|
return {
|
members,
|
hasUnknownMembers
|
};
|
}
|
flowEnumStringMembers(initializedMembers, defaultedMembers, {
|
enumName
|
}) {
|
if (initializedMembers.length === 0) {
|
return defaultedMembers;
|
} else if (defaultedMembers.length === 0) {
|
return initializedMembers;
|
} else if (defaultedMembers.length > initializedMembers.length) {
|
for (const member of initializedMembers) {
|
this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
|
enumName
|
});
|
}
|
return defaultedMembers;
|
} else {
|
for (const member of defaultedMembers) {
|
this.flowEnumErrorStringMemberInconsistentlyInitailized(member, {
|
enumName
|
});
|
}
|
return initializedMembers;
|
}
|
}
|
flowEnumParseExplicitType({
|
enumName
|
}) {
|
if (!this.eatContextual(101)) return null;
|
if (!tokenIsIdentifier(this.state.type)) {
|
throw this.raise(FlowErrors.EnumInvalidExplicitTypeUnknownSupplied, {
|
at: this.state.startLoc,
|
enumName
|
});
|
}
|
const {
|
value
|
} = this.state;
|
this.next();
|
if (value !== "boolean" && value !== "number" && value !== "string" && value !== "symbol") {
|
this.raise(FlowErrors.EnumInvalidExplicitType, {
|
at: this.state.startLoc,
|
enumName,
|
invalidEnumType: value
|
});
|
}
|
return value;
|
}
|
flowEnumBody(node, id) {
|
const enumName = id.name;
|
const nameLoc = id.loc.start;
|
const explicitType = this.flowEnumParseExplicitType({
|
enumName
|
});
|
this.expect(5);
|
const {
|
members,
|
hasUnknownMembers
|
} = this.flowEnumMembers({
|
enumName,
|
explicitType
|
});
|
node.hasUnknownMembers = hasUnknownMembers;
|
switch (explicitType) {
|
case "boolean":
|
node.explicitType = true;
|
node.members = members.booleanMembers;
|
this.expect(8);
|
return this.finishNode(node, "EnumBooleanBody");
|
case "number":
|
node.explicitType = true;
|
node.members = members.numberMembers;
|
this.expect(8);
|
return this.finishNode(node, "EnumNumberBody");
|
case "string":
|
node.explicitType = true;
|
node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
|
enumName
|
});
|
this.expect(8);
|
return this.finishNode(node, "EnumStringBody");
|
case "symbol":
|
node.members = members.defaultedMembers;
|
this.expect(8);
|
return this.finishNode(node, "EnumSymbolBody");
|
default:
|
{
|
const empty = () => {
|
node.members = [];
|
this.expect(8);
|
return this.finishNode(node, "EnumStringBody");
|
};
|
node.explicitType = false;
|
const boolsLen = members.booleanMembers.length;
|
const numsLen = members.numberMembers.length;
|
const strsLen = members.stringMembers.length;
|
const defaultedLen = members.defaultedMembers.length;
|
if (!boolsLen && !numsLen && !strsLen && !defaultedLen) {
|
return empty();
|
} else if (!boolsLen && !numsLen) {
|
node.members = this.flowEnumStringMembers(members.stringMembers, members.defaultedMembers, {
|
enumName
|
});
|
this.expect(8);
|
return this.finishNode(node, "EnumStringBody");
|
} else if (!numsLen && !strsLen && boolsLen >= defaultedLen) {
|
for (const member of members.defaultedMembers) {
|
this.flowEnumErrorBooleanMemberNotInitialized(member.loc.start, {
|
enumName,
|
memberName: member.id.name
|
});
|
}
|
node.members = members.booleanMembers;
|
this.expect(8);
|
return this.finishNode(node, "EnumBooleanBody");
|
} else if (!boolsLen && !strsLen && numsLen >= defaultedLen) {
|
for (const member of members.defaultedMembers) {
|
this.flowEnumErrorNumberMemberNotInitialized(member.loc.start, {
|
enumName,
|
memberName: member.id.name
|
});
|
}
|
node.members = members.numberMembers;
|
this.expect(8);
|
return this.finishNode(node, "EnumNumberBody");
|
} else {
|
this.raise(FlowErrors.EnumInconsistentMemberValues, {
|
at: nameLoc,
|
enumName
|
});
|
return empty();
|
}
|
}
|
}
|
}
|
flowParseEnumDeclaration(node) {
|
const id = this.parseIdentifier();
|
node.id = id;
|
node.body = this.flowEnumBody(this.startNode(), id);
|
return this.finishNode(node, "EnumDeclaration");
|
}
|
isLookaheadToken_lt() {
|
const next = this.nextTokenStart();
|
if (this.input.charCodeAt(next) === 60) {
|
const afterNext = this.input.charCodeAt(next + 1);
|
return afterNext !== 60 && afterNext !== 61;
|
}
|
return false;
|
}
|
maybeUnwrapTypeCastExpression(node) {
|
return node.type === "TypeCastExpression" ? node.expression : node;
|
}
|
};
|
const entities = {
|
__proto__: null,
|
quot: "\u0022",
|
amp: "&",
|
apos: "\u0027",
|
lt: "<",
|
gt: ">",
|
nbsp: "\u00A0",
|
iexcl: "\u00A1",
|
cent: "\u00A2",
|
pound: "\u00A3",
|
curren: "\u00A4",
|
yen: "\u00A5",
|
brvbar: "\u00A6",
|
sect: "\u00A7",
|
uml: "\u00A8",
|
copy: "\u00A9",
|
ordf: "\u00AA",
|
laquo: "\u00AB",
|
not: "\u00AC",
|
shy: "\u00AD",
|
reg: "\u00AE",
|
macr: "\u00AF",
|
deg: "\u00B0",
|
plusmn: "\u00B1",
|
sup2: "\u00B2",
|
sup3: "\u00B3",
|
acute: "\u00B4",
|
micro: "\u00B5",
|
para: "\u00B6",
|
middot: "\u00B7",
|
cedil: "\u00B8",
|
sup1: "\u00B9",
|
ordm: "\u00BA",
|
raquo: "\u00BB",
|
frac14: "\u00BC",
|
frac12: "\u00BD",
|
frac34: "\u00BE",
|
iquest: "\u00BF",
|
Agrave: "\u00C0",
|
Aacute: "\u00C1",
|
Acirc: "\u00C2",
|
Atilde: "\u00C3",
|
Auml: "\u00C4",
|
Aring: "\u00C5",
|
AElig: "\u00C6",
|
Ccedil: "\u00C7",
|
Egrave: "\u00C8",
|
Eacute: "\u00C9",
|
Ecirc: "\u00CA",
|
Euml: "\u00CB",
|
Igrave: "\u00CC",
|
Iacute: "\u00CD",
|
Icirc: "\u00CE",
|
Iuml: "\u00CF",
|
ETH: "\u00D0",
|
Ntilde: "\u00D1",
|
Ograve: "\u00D2",
|
Oacute: "\u00D3",
|
Ocirc: "\u00D4",
|
Otilde: "\u00D5",
|
Ouml: "\u00D6",
|
times: "\u00D7",
|
Oslash: "\u00D8",
|
Ugrave: "\u00D9",
|
Uacute: "\u00DA",
|
Ucirc: "\u00DB",
|
Uuml: "\u00DC",
|
Yacute: "\u00DD",
|
THORN: "\u00DE",
|
szlig: "\u00DF",
|
agrave: "\u00E0",
|
aacute: "\u00E1",
|
acirc: "\u00E2",
|
atilde: "\u00E3",
|
auml: "\u00E4",
|
aring: "\u00E5",
|
aelig: "\u00E6",
|
ccedil: "\u00E7",
|
egrave: "\u00E8",
|
eacute: "\u00E9",
|
ecirc: "\u00EA",
|
euml: "\u00EB",
|
igrave: "\u00EC",
|
iacute: "\u00ED",
|
icirc: "\u00EE",
|
iuml: "\u00EF",
|
eth: "\u00F0",
|
ntilde: "\u00F1",
|
ograve: "\u00F2",
|
oacute: "\u00F3",
|
ocirc: "\u00F4",
|
otilde: "\u00F5",
|
ouml: "\u00F6",
|
divide: "\u00F7",
|
oslash: "\u00F8",
|
ugrave: "\u00F9",
|
uacute: "\u00FA",
|
ucirc: "\u00FB",
|
uuml: "\u00FC",
|
yacute: "\u00FD",
|
thorn: "\u00FE",
|
yuml: "\u00FF",
|
OElig: "\u0152",
|
oelig: "\u0153",
|
Scaron: "\u0160",
|
scaron: "\u0161",
|
Yuml: "\u0178",
|
fnof: "\u0192",
|
circ: "\u02C6",
|
tilde: "\u02DC",
|
Alpha: "\u0391",
|
Beta: "\u0392",
|
Gamma: "\u0393",
|
Delta: "\u0394",
|
Epsilon: "\u0395",
|
Zeta: "\u0396",
|
Eta: "\u0397",
|
Theta: "\u0398",
|
Iota: "\u0399",
|
Kappa: "\u039A",
|
Lambda: "\u039B",
|
Mu: "\u039C",
|
Nu: "\u039D",
|
Xi: "\u039E",
|
Omicron: "\u039F",
|
Pi: "\u03A0",
|
Rho: "\u03A1",
|
Sigma: "\u03A3",
|
Tau: "\u03A4",
|
Upsilon: "\u03A5",
|
Phi: "\u03A6",
|
Chi: "\u03A7",
|
Psi: "\u03A8",
|
Omega: "\u03A9",
|
alpha: "\u03B1",
|
beta: "\u03B2",
|
gamma: "\u03B3",
|
delta: "\u03B4",
|
epsilon: "\u03B5",
|
zeta: "\u03B6",
|
eta: "\u03B7",
|
theta: "\u03B8",
|
iota: "\u03B9",
|
kappa: "\u03BA",
|
lambda: "\u03BB",
|
mu: "\u03BC",
|
nu: "\u03BD",
|
xi: "\u03BE",
|
omicron: "\u03BF",
|
pi: "\u03C0",
|
rho: "\u03C1",
|
sigmaf: "\u03C2",
|
sigma: "\u03C3",
|
tau: "\u03C4",
|
upsilon: "\u03C5",
|
phi: "\u03C6",
|
chi: "\u03C7",
|
psi: "\u03C8",
|
omega: "\u03C9",
|
thetasym: "\u03D1",
|
upsih: "\u03D2",
|
piv: "\u03D6",
|
ensp: "\u2002",
|
emsp: "\u2003",
|
thinsp: "\u2009",
|
zwnj: "\u200C",
|
zwj: "\u200D",
|
lrm: "\u200E",
|
rlm: "\u200F",
|
ndash: "\u2013",
|
mdash: "\u2014",
|
lsquo: "\u2018",
|
rsquo: "\u2019",
|
sbquo: "\u201A",
|
ldquo: "\u201C",
|
rdquo: "\u201D",
|
bdquo: "\u201E",
|
dagger: "\u2020",
|
Dagger: "\u2021",
|
bull: "\u2022",
|
hellip: "\u2026",
|
permil: "\u2030",
|
prime: "\u2032",
|
Prime: "\u2033",
|
lsaquo: "\u2039",
|
rsaquo: "\u203A",
|
oline: "\u203E",
|
frasl: "\u2044",
|
euro: "\u20AC",
|
image: "\u2111",
|
weierp: "\u2118",
|
real: "\u211C",
|
trade: "\u2122",
|
alefsym: "\u2135",
|
larr: "\u2190",
|
uarr: "\u2191",
|
rarr: "\u2192",
|
darr: "\u2193",
|
harr: "\u2194",
|
crarr: "\u21B5",
|
lArr: "\u21D0",
|
uArr: "\u21D1",
|
rArr: "\u21D2",
|
dArr: "\u21D3",
|
hArr: "\u21D4",
|
forall: "\u2200",
|
part: "\u2202",
|
exist: "\u2203",
|
empty: "\u2205",
|
nabla: "\u2207",
|
isin: "\u2208",
|
notin: "\u2209",
|
ni: "\u220B",
|
prod: "\u220F",
|
sum: "\u2211",
|
minus: "\u2212",
|
lowast: "\u2217",
|
radic: "\u221A",
|
prop: "\u221D",
|
infin: "\u221E",
|
ang: "\u2220",
|
and: "\u2227",
|
or: "\u2228",
|
cap: "\u2229",
|
cup: "\u222A",
|
int: "\u222B",
|
there4: "\u2234",
|
sim: "\u223C",
|
cong: "\u2245",
|
asymp: "\u2248",
|
ne: "\u2260",
|
equiv: "\u2261",
|
le: "\u2264",
|
ge: "\u2265",
|
sub: "\u2282",
|
sup: "\u2283",
|
nsub: "\u2284",
|
sube: "\u2286",
|
supe: "\u2287",
|
oplus: "\u2295",
|
otimes: "\u2297",
|
perp: "\u22A5",
|
sdot: "\u22C5",
|
lceil: "\u2308",
|
rceil: "\u2309",
|
lfloor: "\u230A",
|
rfloor: "\u230B",
|
lang: "\u2329",
|
rang: "\u232A",
|
loz: "\u25CA",
|
spades: "\u2660",
|
clubs: "\u2663",
|
hearts: "\u2665",
|
diams: "\u2666"
|
};
|
const JsxErrors = ParseErrorEnum`jsx`({
|
AttributeIsEmpty: "JSX attributes must only be assigned a non-empty expression.",
|
MissingClosingTagElement: ({
|
openingTagName
|
}) => `Expected corresponding JSX closing tag for <${openingTagName}>.`,
|
MissingClosingTagFragment: "Expected corresponding JSX closing tag for <>.",
|
UnexpectedSequenceExpression: "Sequence expressions cannot be directly nested inside JSX. Did you mean to wrap it in parentheses (...)?",
|
UnexpectedToken: ({
|
unexpected,
|
HTMLEntity
|
}) => `Unexpected token \`${unexpected}\`. Did you mean \`${HTMLEntity}\` or \`{'${unexpected}'}\`?`,
|
UnsupportedJsxValue: "JSX value should be either an expression or a quoted JSX text.",
|
UnterminatedJsxContent: "Unterminated JSX contents.",
|
UnwrappedAdjacentJSXElements: "Adjacent JSX elements must be wrapped in an enclosing tag. Did you want a JSX fragment <>...</>?"
|
});
|
function isFragment(object) {
|
return object ? object.type === "JSXOpeningFragment" || object.type === "JSXClosingFragment" : false;
|
}
|
function getQualifiedJSXName(object) {
|
if (object.type === "JSXIdentifier") {
|
return object.name;
|
}
|
if (object.type === "JSXNamespacedName") {
|
return object.namespace.name + ":" + object.name.name;
|
}
|
if (object.type === "JSXMemberExpression") {
|
return getQualifiedJSXName(object.object) + "." + getQualifiedJSXName(object.property);
|
}
|
throw new Error("Node had unexpected type: " + object.type);
|
}
|
var jsx = superClass => class JSXParserMixin extends superClass {
|
jsxReadToken() {
|
let out = "";
|
let chunkStart = this.state.pos;
|
for (;;) {
|
if (this.state.pos >= this.length) {
|
throw this.raise(JsxErrors.UnterminatedJsxContent, {
|
at: this.state.startLoc
|
});
|
}
|
const ch = this.input.charCodeAt(this.state.pos);
|
switch (ch) {
|
case 60:
|
case 123:
|
if (this.state.pos === this.state.start) {
|
if (ch === 60 && this.state.canStartJSXElement) {
|
++this.state.pos;
|
this.finishToken(140);
|
} else {
|
super.getTokenFromCode(ch);
|
}
|
return;
|
}
|
out += this.input.slice(chunkStart, this.state.pos);
|
this.finishToken(139, out);
|
return;
|
case 38:
|
out += this.input.slice(chunkStart, this.state.pos);
|
out += this.jsxReadEntity();
|
chunkStart = this.state.pos;
|
break;
|
case 62:
|
case 125:
|
default:
|
if (isNewLine(ch)) {
|
out += this.input.slice(chunkStart, this.state.pos);
|
out += this.jsxReadNewLine(true);
|
chunkStart = this.state.pos;
|
} else {
|
++this.state.pos;
|
}
|
}
|
}
|
}
|
jsxReadNewLine(normalizeCRLF) {
|
const ch = this.input.charCodeAt(this.state.pos);
|
let out;
|
++this.state.pos;
|
if (ch === 13 && this.input.charCodeAt(this.state.pos) === 10) {
|
++this.state.pos;
|
out = normalizeCRLF ? "\n" : "\r\n";
|
} else {
|
out = String.fromCharCode(ch);
|
}
|
++this.state.curLine;
|
this.state.lineStart = this.state.pos;
|
return out;
|
}
|
jsxReadString(quote) {
|
let out = "";
|
let chunkStart = ++this.state.pos;
|
for (;;) {
|
if (this.state.pos >= this.length) {
|
throw this.raise(Errors.UnterminatedString, {
|
at: this.state.startLoc
|
});
|
}
|
const ch = this.input.charCodeAt(this.state.pos);
|
if (ch === quote) break;
|
if (ch === 38) {
|
out += this.input.slice(chunkStart, this.state.pos);
|
out += this.jsxReadEntity();
|
chunkStart = this.state.pos;
|
} else if (isNewLine(ch)) {
|
out += this.input.slice(chunkStart, this.state.pos);
|
out += this.jsxReadNewLine(false);
|
chunkStart = this.state.pos;
|
} else {
|
++this.state.pos;
|
}
|
}
|
out += this.input.slice(chunkStart, this.state.pos++);
|
this.finishToken(131, out);
|
}
|
jsxReadEntity() {
|
const startPos = ++this.state.pos;
|
if (this.codePointAtPos(this.state.pos) === 35) {
|
++this.state.pos;
|
let radix = 10;
|
if (this.codePointAtPos(this.state.pos) === 120) {
|
radix = 16;
|
++this.state.pos;
|
}
|
const codePoint = this.readInt(radix, undefined, false, "bail");
|
if (codePoint !== null && this.codePointAtPos(this.state.pos) === 59) {
|
++this.state.pos;
|
return String.fromCodePoint(codePoint);
|
}
|
} else {
|
let count = 0;
|
let semi = false;
|
while (count++ < 10 && this.state.pos < this.length && !(semi = this.codePointAtPos(this.state.pos) == 59)) {
|
++this.state.pos;
|
}
|
if (semi) {
|
const desc = this.input.slice(startPos, this.state.pos);
|
const entity = entities[desc];
|
++this.state.pos;
|
if (entity) {
|
return entity;
|
}
|
}
|
}
|
this.state.pos = startPos;
|
return "&";
|
}
|
jsxReadWord() {
|
let ch;
|
const start = this.state.pos;
|
do {
|
ch = this.input.charCodeAt(++this.state.pos);
|
} while (isIdentifierChar(ch) || ch === 45);
|
this.finishToken(138, this.input.slice(start, this.state.pos));
|
}
|
jsxParseIdentifier() {
|
const node = this.startNode();
|
if (this.match(138)) {
|
node.name = this.state.value;
|
} else if (tokenIsKeyword(this.state.type)) {
|
node.name = tokenLabelName(this.state.type);
|
} else {
|
this.unexpected();
|
}
|
this.next();
|
return this.finishNode(node, "JSXIdentifier");
|
}
|
jsxParseNamespacedName() {
|
const startLoc = this.state.startLoc;
|
const name = this.jsxParseIdentifier();
|
if (!this.eat(14)) return name;
|
const node = this.startNodeAt(startLoc);
|
node.namespace = name;
|
node.name = this.jsxParseIdentifier();
|
return this.finishNode(node, "JSXNamespacedName");
|
}
|
jsxParseElementName() {
|
const startLoc = this.state.startLoc;
|
let node = this.jsxParseNamespacedName();
|
if (node.type === "JSXNamespacedName") {
|
return node;
|
}
|
while (this.eat(16)) {
|
const newNode = this.startNodeAt(startLoc);
|
newNode.object = node;
|
newNode.property = this.jsxParseIdentifier();
|
node = this.finishNode(newNode, "JSXMemberExpression");
|
}
|
return node;
|
}
|
jsxParseAttributeValue() {
|
let node;
|
switch (this.state.type) {
|
case 5:
|
node = this.startNode();
|
this.setContext(types$1.brace);
|
this.next();
|
node = this.jsxParseExpressionContainer(node, types$1.j_oTag);
|
if (node.expression.type === "JSXEmptyExpression") {
|
this.raise(JsxErrors.AttributeIsEmpty, {
|
at: node
|
});
|
}
|
return node;
|
case 140:
|
case 131:
|
return this.parseExprAtom();
|
default:
|
throw this.raise(JsxErrors.UnsupportedJsxValue, {
|
at: this.state.startLoc
|
});
|
}
|
}
|
jsxParseEmptyExpression() {
|
const node = this.startNodeAt(this.state.lastTokEndLoc);
|
return this.finishNodeAt(node, "JSXEmptyExpression", this.state.startLoc);
|
}
|
jsxParseSpreadChild(node) {
|
this.next();
|
node.expression = this.parseExpression();
|
this.setContext(types$1.j_expr);
|
this.state.canStartJSXElement = true;
|
this.expect(8);
|
return this.finishNode(node, "JSXSpreadChild");
|
}
|
jsxParseExpressionContainer(node, previousContext) {
|
if (this.match(8)) {
|
node.expression = this.jsxParseEmptyExpression();
|
} else {
|
const expression = this.parseExpression();
|
node.expression = expression;
|
}
|
this.setContext(previousContext);
|
this.state.canStartJSXElement = true;
|
this.expect(8);
|
return this.finishNode(node, "JSXExpressionContainer");
|
}
|
jsxParseAttribute() {
|
const node = this.startNode();
|
if (this.match(5)) {
|
this.setContext(types$1.brace);
|
this.next();
|
this.expect(21);
|
node.argument = this.parseMaybeAssignAllowIn();
|
this.setContext(types$1.j_oTag);
|
this.state.canStartJSXElement = true;
|
this.expect(8);
|
return this.finishNode(node, "JSXSpreadAttribute");
|
}
|
node.name = this.jsxParseNamespacedName();
|
node.value = this.eat(29) ? this.jsxParseAttributeValue() : null;
|
return this.finishNode(node, "JSXAttribute");
|
}
|
jsxParseOpeningElementAt(startLoc) {
|
const node = this.startNodeAt(startLoc);
|
if (this.eat(141)) {
|
return this.finishNode(node, "JSXOpeningFragment");
|
}
|
node.name = this.jsxParseElementName();
|
return this.jsxParseOpeningElementAfterName(node);
|
}
|
jsxParseOpeningElementAfterName(node) {
|
const attributes = [];
|
while (!this.match(56) && !this.match(141)) {
|
attributes.push(this.jsxParseAttribute());
|
}
|
node.attributes = attributes;
|
node.selfClosing = this.eat(56);
|
this.expect(141);
|
return this.finishNode(node, "JSXOpeningElement");
|
}
|
jsxParseClosingElementAt(startLoc) {
|
const node = this.startNodeAt(startLoc);
|
if (this.eat(141)) {
|
return this.finishNode(node, "JSXClosingFragment");
|
}
|
node.name = this.jsxParseElementName();
|
this.expect(141);
|
return this.finishNode(node, "JSXClosingElement");
|
}
|
jsxParseElementAt(startLoc) {
|
const node = this.startNodeAt(startLoc);
|
const children = [];
|
const openingElement = this.jsxParseOpeningElementAt(startLoc);
|
let closingElement = null;
|
if (!openingElement.selfClosing) {
|
contents: for (;;) {
|
switch (this.state.type) {
|
case 140:
|
startLoc = this.state.startLoc;
|
this.next();
|
if (this.eat(56)) {
|
closingElement = this.jsxParseClosingElementAt(startLoc);
|
break contents;
|
}
|
children.push(this.jsxParseElementAt(startLoc));
|
break;
|
case 139:
|
children.push(this.parseExprAtom());
|
break;
|
case 5:
|
{
|
const node = this.startNode();
|
this.setContext(types$1.brace);
|
this.next();
|
if (this.match(21)) {
|
children.push(this.jsxParseSpreadChild(node));
|
} else {
|
children.push(this.jsxParseExpressionContainer(node, types$1.j_expr));
|
}
|
break;
|
}
|
default:
|
this.unexpected();
|
}
|
}
|
if (isFragment(openingElement) && !isFragment(closingElement) && closingElement !== null) {
|
this.raise(JsxErrors.MissingClosingTagFragment, {
|
at: closingElement
|
});
|
} else if (!isFragment(openingElement) && isFragment(closingElement)) {
|
this.raise(JsxErrors.MissingClosingTagElement, {
|
at: closingElement,
|
openingTagName: getQualifiedJSXName(openingElement.name)
|
});
|
} else if (!isFragment(openingElement) && !isFragment(closingElement)) {
|
if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name)) {
|
this.raise(JsxErrors.MissingClosingTagElement, {
|
at: closingElement,
|
openingTagName: getQualifiedJSXName(openingElement.name)
|
});
|
}
|
}
|
}
|
if (isFragment(openingElement)) {
|
node.openingFragment = openingElement;
|
node.closingFragment = closingElement;
|
} else {
|
node.openingElement = openingElement;
|
node.closingElement = closingElement;
|
}
|
node.children = children;
|
if (this.match(47)) {
|
throw this.raise(JsxErrors.UnwrappedAdjacentJSXElements, {
|
at: this.state.startLoc
|
});
|
}
|
return isFragment(openingElement) ? this.finishNode(node, "JSXFragment") : this.finishNode(node, "JSXElement");
|
}
|
jsxParseElement() {
|
const startLoc = this.state.startLoc;
|
this.next();
|
return this.jsxParseElementAt(startLoc);
|
}
|
setContext(newContext) {
|
const {
|
context
|
} = this.state;
|
context[context.length - 1] = newContext;
|
}
|
parseExprAtom(refExpressionErrors) {
|
if (this.match(139)) {
|
return this.parseLiteral(this.state.value, "JSXText");
|
} else if (this.match(140)) {
|
return this.jsxParseElement();
|
} else if (this.match(47) && this.input.charCodeAt(this.state.pos) !== 33) {
|
this.replaceToken(140);
|
return this.jsxParseElement();
|
} else {
|
return super.parseExprAtom(refExpressionErrors);
|
}
|
}
|
skipSpace() {
|
const curContext = this.curContext();
|
if (!curContext.preserveSpace) super.skipSpace();
|
}
|
getTokenFromCode(code) {
|
const context = this.curContext();
|
if (context === types$1.j_expr) {
|
this.jsxReadToken();
|
return;
|
}
|
if (context === types$1.j_oTag || context === types$1.j_cTag) {
|
if (isIdentifierStart(code)) {
|
this.jsxReadWord();
|
return;
|
}
|
if (code === 62) {
|
++this.state.pos;
|
this.finishToken(141);
|
return;
|
}
|
if ((code === 34 || code === 39) && context === types$1.j_oTag) {
|
this.jsxReadString(code);
|
return;
|
}
|
}
|
if (code === 60 && this.state.canStartJSXElement && this.input.charCodeAt(this.state.pos + 1) !== 33) {
|
++this.state.pos;
|
this.finishToken(140);
|
return;
|
}
|
super.getTokenFromCode(code);
|
}
|
updateContext(prevType) {
|
const {
|
context,
|
type
|
} = this.state;
|
if (type === 56 && prevType === 140) {
|
context.splice(-2, 2, types$1.j_cTag);
|
this.state.canStartJSXElement = false;
|
} else if (type === 140) {
|
context.push(types$1.j_oTag);
|
} else if (type === 141) {
|
const out = context[context.length - 1];
|
if (out === types$1.j_oTag && prevType === 56 || out === types$1.j_cTag) {
|
context.pop();
|
this.state.canStartJSXElement = context[context.length - 1] === types$1.j_expr;
|
} else {
|
this.setContext(types$1.j_expr);
|
this.state.canStartJSXElement = true;
|
}
|
} else {
|
this.state.canStartJSXElement = tokenComesBeforeExpression(type);
|
}
|
}
|
};
|
class TypeScriptScope extends Scope {
|
constructor(...args) {
|
super(...args);
|
this.types = new Set();
|
this.enums = new Set();
|
this.constEnums = new Set();
|
this.classes = new Set();
|
this.exportOnlyBindings = new Set();
|
}
|
}
|
class TypeScriptScopeHandler extends ScopeHandler {
|
constructor(...args) {
|
super(...args);
|
this.importsStack = [];
|
}
|
createScope(flags) {
|
this.importsStack.push(new Set());
|
return new TypeScriptScope(flags);
|
}
|
enter(flags) {
|
if (flags == SCOPE_TS_MODULE) {
|
this.importsStack.push(new Set());
|
}
|
super.enter(flags);
|
}
|
exit() {
|
const flags = super.exit();
|
if (flags == SCOPE_TS_MODULE) {
|
this.importsStack.pop();
|
}
|
return flags;
|
}
|
hasImport(name, allowShadow) {
|
const len = this.importsStack.length;
|
if (this.importsStack[len - 1].has(name)) {
|
return true;
|
}
|
if (!allowShadow && len > 1) {
|
for (let i = 0; i < len - 1; i++) {
|
if (this.importsStack[i].has(name)) return true;
|
}
|
}
|
return false;
|
}
|
declareName(name, bindingType, loc) {
|
if (bindingType & BIND_FLAGS_TS_IMPORT) {
|
if (this.hasImport(name, true)) {
|
this.parser.raise(Errors.VarRedeclaration, {
|
at: loc,
|
identifierName: name
|
});
|
}
|
this.importsStack[this.importsStack.length - 1].add(name);
|
return;
|
}
|
const scope = this.currentScope();
|
if (bindingType & BIND_FLAGS_TS_EXPORT_ONLY) {
|
this.maybeExportDefined(scope, name);
|
scope.exportOnlyBindings.add(name);
|
return;
|
}
|
super.declareName(name, bindingType, loc);
|
if (bindingType & BIND_KIND_TYPE) {
|
if (!(bindingType & BIND_KIND_VALUE)) {
|
this.checkRedeclarationInScope(scope, name, bindingType, loc);
|
this.maybeExportDefined(scope, name);
|
}
|
scope.types.add(name);
|
}
|
if (bindingType & BIND_FLAGS_TS_ENUM) scope.enums.add(name);
|
if (bindingType & BIND_FLAGS_TS_CONST_ENUM) scope.constEnums.add(name);
|
if (bindingType & BIND_FLAGS_CLASS) scope.classes.add(name);
|
}
|
isRedeclaredInScope(scope, name, bindingType) {
|
if (scope.enums.has(name)) {
|
if (bindingType & BIND_FLAGS_TS_ENUM) {
|
const isConst = !!(bindingType & BIND_FLAGS_TS_CONST_ENUM);
|
const wasConst = scope.constEnums.has(name);
|
return isConst !== wasConst;
|
}
|
return true;
|
}
|
if (bindingType & BIND_FLAGS_CLASS && scope.classes.has(name)) {
|
if (scope.lexical.has(name)) {
|
return !!(bindingType & BIND_KIND_VALUE);
|
} else {
|
return false;
|
}
|
}
|
if (bindingType & BIND_KIND_TYPE && scope.types.has(name)) {
|
return true;
|
}
|
return super.isRedeclaredInScope(scope, name, bindingType);
|
}
|
checkLocalExport(id) {
|
const {
|
name
|
} = id;
|
if (this.hasImport(name)) return;
|
const len = this.scopeStack.length;
|
for (let i = len - 1; i >= 0; i--) {
|
const scope = this.scopeStack[i];
|
if (scope.types.has(name) || scope.exportOnlyBindings.has(name)) return;
|
}
|
super.checkLocalExport(id);
|
}
|
}
|
const getOwn$1 = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
|
const unwrapParenthesizedExpression = node => {
|
return node.type === "ParenthesizedExpression" ? unwrapParenthesizedExpression(node.expression) : node;
|
};
|
class LValParser extends NodeUtils {
|
toAssignable(node, isLHS = false) {
|
var _node$extra, _node$extra3;
|
let parenthesized = undefined;
|
if (node.type === "ParenthesizedExpression" || (_node$extra = node.extra) != null && _node$extra.parenthesized) {
|
parenthesized = unwrapParenthesizedExpression(node);
|
if (isLHS) {
|
if (parenthesized.type === "Identifier") {
|
this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
|
at: node
|
});
|
} else if (parenthesized.type !== "MemberExpression") {
|
this.raise(Errors.InvalidParenthesizedAssignment, {
|
at: node
|
});
|
}
|
} else {
|
this.raise(Errors.InvalidParenthesizedAssignment, {
|
at: node
|
});
|
}
|
}
|
switch (node.type) {
|
case "Identifier":
|
case "ObjectPattern":
|
case "ArrayPattern":
|
case "AssignmentPattern":
|
case "RestElement":
|
break;
|
case "ObjectExpression":
|
node.type = "ObjectPattern";
|
for (let i = 0, length = node.properties.length, last = length - 1; i < length; i++) {
|
var _node$extra2;
|
const prop = node.properties[i];
|
const isLast = i === last;
|
this.toAssignableObjectExpressionProp(prop, isLast, isLHS);
|
if (isLast && prop.type === "RestElement" && (_node$extra2 = node.extra) != null && _node$extra2.trailingCommaLoc) {
|
this.raise(Errors.RestTrailingComma, {
|
at: node.extra.trailingCommaLoc
|
});
|
}
|
}
|
break;
|
case "ObjectProperty":
|
{
|
const {
|
key,
|
value
|
} = node;
|
if (this.isPrivateName(key)) {
|
this.classScope.usePrivateName(this.getPrivateNameSV(key), key.loc.start);
|
}
|
this.toAssignable(value, isLHS);
|
break;
|
}
|
case "SpreadElement":
|
{
|
throw new Error("Internal @babel/parser error (this is a bug, please report it)." + " SpreadElement should be converted by .toAssignable's caller.");
|
}
|
case "ArrayExpression":
|
node.type = "ArrayPattern";
|
this.toAssignableList(node.elements, (_node$extra3 = node.extra) == null ? void 0 : _node$extra3.trailingCommaLoc, isLHS);
|
break;
|
case "AssignmentExpression":
|
if (node.operator !== "=") {
|
this.raise(Errors.MissingEqInAssignment, {
|
at: node.left.loc.end
|
});
|
}
|
node.type = "AssignmentPattern";
|
delete node.operator;
|
this.toAssignable(node.left, isLHS);
|
break;
|
case "ParenthesizedExpression":
|
this.toAssignable(parenthesized, isLHS);
|
break;
|
}
|
}
|
toAssignableObjectExpressionProp(prop, isLast, isLHS) {
|
if (prop.type === "ObjectMethod") {
|
this.raise(prop.kind === "get" || prop.kind === "set" ? Errors.PatternHasAccessor : Errors.PatternHasMethod, {
|
at: prop.key
|
});
|
} else if (prop.type === "SpreadElement") {
|
prop.type = "RestElement";
|
const arg = prop.argument;
|
this.checkToRestConversion(arg, false);
|
this.toAssignable(arg, isLHS);
|
if (!isLast) {
|
this.raise(Errors.RestTrailingComma, {
|
at: prop
|
});
|
}
|
} else {
|
this.toAssignable(prop, isLHS);
|
}
|
}
|
toAssignableList(exprList, trailingCommaLoc, isLHS) {
|
const end = exprList.length - 1;
|
for (let i = 0; i <= end; i++) {
|
const elt = exprList[i];
|
if (!elt) continue;
|
if (elt.type === "SpreadElement") {
|
elt.type = "RestElement";
|
const arg = elt.argument;
|
this.checkToRestConversion(arg, true);
|
this.toAssignable(arg, isLHS);
|
} else {
|
this.toAssignable(elt, isLHS);
|
}
|
if (elt.type === "RestElement") {
|
if (i < end) {
|
this.raise(Errors.RestTrailingComma, {
|
at: elt
|
});
|
} else if (trailingCommaLoc) {
|
this.raise(Errors.RestTrailingComma, {
|
at: trailingCommaLoc
|
});
|
}
|
}
|
}
|
}
|
isAssignable(node, isBinding) {
|
switch (node.type) {
|
case "Identifier":
|
case "ObjectPattern":
|
case "ArrayPattern":
|
case "AssignmentPattern":
|
case "RestElement":
|
return true;
|
case "ObjectExpression":
|
{
|
const last = node.properties.length - 1;
|
return node.properties.every((prop, i) => {
|
return prop.type !== "ObjectMethod" && (i === last || prop.type !== "SpreadElement") && this.isAssignable(prop);
|
});
|
}
|
case "ObjectProperty":
|
return this.isAssignable(node.value);
|
case "SpreadElement":
|
return this.isAssignable(node.argument);
|
case "ArrayExpression":
|
return node.elements.every(element => element === null || this.isAssignable(element));
|
case "AssignmentExpression":
|
return node.operator === "=";
|
case "ParenthesizedExpression":
|
return this.isAssignable(node.expression);
|
case "MemberExpression":
|
case "OptionalMemberExpression":
|
return !isBinding;
|
default:
|
return false;
|
}
|
}
|
toReferencedList(exprList, isParenthesizedExpr) {
|
return exprList;
|
}
|
toReferencedListDeep(exprList, isParenthesizedExpr) {
|
this.toReferencedList(exprList, isParenthesizedExpr);
|
for (const expr of exprList) {
|
if ((expr == null ? void 0 : expr.type) === "ArrayExpression") {
|
this.toReferencedListDeep(expr.elements);
|
}
|
}
|
}
|
parseSpread(refExpressionErrors) {
|
const node = this.startNode();
|
this.next();
|
node.argument = this.parseMaybeAssignAllowIn(refExpressionErrors, undefined);
|
return this.finishNode(node, "SpreadElement");
|
}
|
parseRestBinding() {
|
const node = this.startNode();
|
this.next();
|
node.argument = this.parseBindingAtom();
|
return this.finishNode(node, "RestElement");
|
}
|
parseBindingAtom() {
|
switch (this.state.type) {
|
case 0:
|
{
|
const node = this.startNode();
|
this.next();
|
node.elements = this.parseBindingList(3, 93, 1);
|
return this.finishNode(node, "ArrayPattern");
|
}
|
case 5:
|
return this.parseObjectLike(8, true);
|
}
|
return this.parseIdentifier();
|
}
|
parseBindingList(close, closeCharCode, flags) {
|
const allowEmpty = flags & 1;
|
const elts = [];
|
let first = true;
|
while (!this.eat(close)) {
|
if (first) {
|
first = false;
|
} else {
|
this.expect(12);
|
}
|
if (allowEmpty && this.match(12)) {
|
elts.push(null);
|
} else if (this.eat(close)) {
|
break;
|
} else if (this.match(21)) {
|
elts.push(this.parseAssignableListItemTypes(this.parseRestBinding(), flags));
|
if (!this.checkCommaAfterRest(closeCharCode)) {
|
this.expect(close);
|
break;
|
}
|
} else {
|
const decorators = [];
|
if (this.match(26) && this.hasPlugin("decorators")) {
|
this.raise(Errors.UnsupportedParameterDecorator, {
|
at: this.state.startLoc
|
});
|
}
|
while (this.match(26)) {
|
decorators.push(this.parseDecorator());
|
}
|
elts.push(this.parseAssignableListItem(flags, decorators));
|
}
|
}
|
return elts;
|
}
|
parseBindingRestProperty(prop) {
|
this.next();
|
prop.argument = this.parseIdentifier();
|
this.checkCommaAfterRest(125);
|
return this.finishNode(prop, "RestElement");
|
}
|
parseBindingProperty() {
|
const prop = this.startNode();
|
const {
|
type,
|
startLoc
|
} = this.state;
|
if (type === 21) {
|
return this.parseBindingRestProperty(prop);
|
} else if (type === 136) {
|
this.expectPlugin("destructuringPrivate", startLoc);
|
this.classScope.usePrivateName(this.state.value, startLoc);
|
prop.key = this.parsePrivateName();
|
} else {
|
this.parsePropertyName(prop);
|
}
|
prop.method = false;
|
return this.parseObjPropValue(prop, startLoc, false, false, true, false);
|
}
|
parseAssignableListItem(flags, decorators) {
|
const left = this.parseMaybeDefault();
|
this.parseAssignableListItemTypes(left, flags);
|
const elt = this.parseMaybeDefault(left.loc.start, left);
|
if (decorators.length) {
|
left.decorators = decorators;
|
}
|
return elt;
|
}
|
parseAssignableListItemTypes(param, flags) {
|
return param;
|
}
|
parseMaybeDefault(startLoc, left) {
|
var _startLoc, _left;
|
(_startLoc = startLoc) != null ? _startLoc : startLoc = this.state.startLoc;
|
left = (_left = left) != null ? _left : this.parseBindingAtom();
|
if (!this.eat(29)) return left;
|
const node = this.startNodeAt(startLoc);
|
node.left = left;
|
node.right = this.parseMaybeAssignAllowIn();
|
return this.finishNode(node, "AssignmentPattern");
|
}
|
isValidLVal(type, isUnparenthesizedInAssign, binding) {
|
return getOwn$1({
|
AssignmentPattern: "left",
|
RestElement: "argument",
|
ObjectProperty: "value",
|
ParenthesizedExpression: "expression",
|
ArrayPattern: "elements",
|
ObjectPattern: "properties"
|
}, type);
|
}
|
checkLVal(expression, {
|
in: ancestor,
|
binding = BIND_NONE,
|
checkClashes = false,
|
strictModeChanged = false,
|
hasParenthesizedAncestor = false
|
}) {
|
var _expression$extra;
|
const type = expression.type;
|
if (this.isObjectMethod(expression)) return;
|
if (type === "MemberExpression") {
|
if (binding !== BIND_NONE) {
|
this.raise(Errors.InvalidPropertyBindingPattern, {
|
at: expression
|
});
|
}
|
return;
|
}
|
if (type === "Identifier") {
|
this.checkIdentifier(expression, binding, strictModeChanged);
|
const {
|
name
|
} = expression;
|
if (checkClashes) {
|
if (checkClashes.has(name)) {
|
this.raise(Errors.ParamDupe, {
|
at: expression
|
});
|
} else {
|
checkClashes.add(name);
|
}
|
}
|
return;
|
}
|
const validity = this.isValidLVal(type, !(hasParenthesizedAncestor || (_expression$extra = expression.extra) != null && _expression$extra.parenthesized) && ancestor.type === "AssignmentExpression", binding);
|
if (validity === true) return;
|
if (validity === false) {
|
const ParseErrorClass = binding === BIND_NONE ? Errors.InvalidLhs : Errors.InvalidLhsBinding;
|
this.raise(ParseErrorClass, {
|
at: expression,
|
ancestor
|
});
|
return;
|
}
|
const [key, isParenthesizedExpression] = Array.isArray(validity) ? validity : [validity, type === "ParenthesizedExpression"];
|
const nextAncestor = type === "ArrayPattern" || type === "ObjectPattern" || type === "ParenthesizedExpression" ? {
|
type
|
} : ancestor;
|
for (const child of [].concat(expression[key])) {
|
if (child) {
|
this.checkLVal(child, {
|
in: nextAncestor,
|
binding,
|
checkClashes,
|
strictModeChanged,
|
hasParenthesizedAncestor: isParenthesizedExpression
|
});
|
}
|
}
|
}
|
checkIdentifier(at, bindingType, strictModeChanged = false) {
|
if (this.state.strict && (strictModeChanged ? isStrictBindReservedWord(at.name, this.inModule) : isStrictBindOnlyReservedWord(at.name))) {
|
if (bindingType === BIND_NONE) {
|
this.raise(Errors.StrictEvalArguments, {
|
at,
|
referenceName: at.name
|
});
|
} else {
|
this.raise(Errors.StrictEvalArgumentsBinding, {
|
at,
|
bindingName: at.name
|
});
|
}
|
}
|
if (bindingType & BIND_FLAGS_NO_LET_IN_LEXICAL && at.name === "let") {
|
this.raise(Errors.LetInLexicalBinding, {
|
at
|
});
|
}
|
if (!(bindingType & BIND_NONE)) {
|
this.declareNameFromIdentifier(at, bindingType);
|
}
|
}
|
declareNameFromIdentifier(identifier, binding) {
|
this.scope.declareName(identifier.name, binding, identifier.loc.start);
|
}
|
checkToRestConversion(node, allowPattern) {
|
switch (node.type) {
|
case "ParenthesizedExpression":
|
this.checkToRestConversion(node.expression, allowPattern);
|
break;
|
case "Identifier":
|
case "MemberExpression":
|
break;
|
case "ArrayExpression":
|
case "ObjectExpression":
|
if (allowPattern) break;
|
default:
|
this.raise(Errors.InvalidRestAssignmentPattern, {
|
at: node
|
});
|
}
|
}
|
checkCommaAfterRest(close) {
|
if (!this.match(12)) {
|
return false;
|
}
|
this.raise(this.lookaheadCharCode() === close ? Errors.RestTrailingComma : Errors.ElementAfterRest, {
|
at: this.state.startLoc
|
});
|
return true;
|
}
|
}
|
const getOwn = (object, key) => Object.hasOwnProperty.call(object, key) && object[key];
|
function nonNull(x) {
|
if (x == null) {
|
throw new Error(`Unexpected ${x} value.`);
|
}
|
return x;
|
}
|
function assert$1(x) {
|
if (!x) {
|
throw new Error("Assert fail");
|
}
|
}
|
const TSErrors = ParseErrorEnum`typescript`({
|
AbstractMethodHasImplementation: ({
|
methodName
|
}) => `Method '${methodName}' cannot have an implementation because it is marked abstract.`,
|
AbstractPropertyHasInitializer: ({
|
propertyName
|
}) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
|
AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
|
AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
|
AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
|
ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
|
ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
|
ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
|
ConstructorHasTypeParameters: "Type parameters cannot appear on a constructor declaration.",
|
DeclareAccessor: ({
|
kind
|
}) => `'declare' is not allowed in ${kind}ters.`,
|
DeclareClassFieldHasInitializer: "Initializers are not allowed in ambient contexts.",
|
DeclareFunctionHasImplementation: "An implementation cannot be declared in ambient contexts.",
|
DuplicateAccessibilityModifier: ({
|
modifier
|
}) => `Accessibility modifier already seen.`,
|
DuplicateModifier: ({
|
modifier
|
}) => `Duplicate modifier: '${modifier}'.`,
|
EmptyHeritageClauseType: ({
|
token
|
}) => `'${token}' list cannot be empty.`,
|
EmptyTypeArguments: "Type argument list cannot be empty.",
|
EmptyTypeParameters: "Type parameter list cannot be empty.",
|
ExpectedAmbientAfterExportDeclare: "'export declare' must be followed by an ambient declaration.",
|
ImportAliasHasImportType: "An import alias can not use 'import type'.",
|
ImportReflectionHasImportType: "An `import module` declaration can not use `type` modifier",
|
IncompatibleModifiers: ({
|
modifiers
|
}) => `'${modifiers[0]}' modifier cannot be used with '${modifiers[1]}' modifier.`,
|
IndexSignatureHasAbstract: "Index signatures cannot have the 'abstract' modifier.",
|
IndexSignatureHasAccessibility: ({
|
modifier
|
}) => `Index signatures cannot have an accessibility modifier ('${modifier}').`,
|
IndexSignatureHasDeclare: "Index signatures cannot have the 'declare' modifier.",
|
IndexSignatureHasOverride: "'override' modifier cannot appear on an index signature.",
|
IndexSignatureHasStatic: "Index signatures cannot have the 'static' modifier.",
|
InitializerNotAllowedInAmbientContext: "Initializers are not allowed in ambient contexts.",
|
InvalidModifierOnTypeMember: ({
|
modifier
|
}) => `'${modifier}' modifier cannot appear on a type member.`,
|
InvalidModifierOnTypeParameter: ({
|
modifier
|
}) => `'${modifier}' modifier cannot appear on a type parameter.`,
|
InvalidModifierOnTypeParameterPositions: ({
|
modifier
|
}) => `'${modifier}' modifier can only appear on a type parameter of a class, interface or type alias.`,
|
InvalidModifiersOrder: ({
|
orderedModifiers
|
}) => `'${orderedModifiers[0]}' modifier must precede '${orderedModifiers[1]}' modifier.`,
|
InvalidPropertyAccessAfterInstantiationExpression: "Invalid property access after an instantiation expression. " + "You can either wrap the instantiation expression in parentheses, or delete the type arguments.",
|
InvalidTupleMemberLabel: "Tuple members must be labeled with a simple identifier.",
|
MissingInterfaceName: "'interface' declarations must be followed by an identifier.",
|
MixedLabeledAndUnlabeledElements: "Tuple members must all have names or all not have names.",
|
NonAbstractClassHasAbstractMethod: "Abstract methods can only appear within an abstract class.",
|
NonClassMethodPropertyHasAbstractModifer: "'abstract' modifier can only appear on a class, method, or property declaration.",
|
OptionalTypeBeforeRequired: "A required element cannot follow an optional element.",
|
OverrideNotInSubClass: "This member cannot have an 'override' modifier because its containing class does not extend another class.",
|
PatternIsOptional: "A binding pattern parameter cannot be optional in an implementation signature.",
|
PrivateElementHasAbstract: "Private elements cannot have the 'abstract' modifier.",
|
PrivateElementHasAccessibility: ({
|
modifier
|
}) => `Private elements cannot have an accessibility modifier ('${modifier}').`,
|
ReadonlyForMethodSignature: "'readonly' modifier can only appear on a property declaration or index signature.",
|
ReservedArrowTypeParam: "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma, as in `<T,>() => ...`.",
|
ReservedTypeAssertion: "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead.",
|
SetAccesorCannotHaveOptionalParameter: "A 'set' accessor cannot have an optional parameter.",
|
SetAccesorCannotHaveRestParameter: "A 'set' accessor cannot have rest parameter.",
|
SetAccesorCannotHaveReturnType: "A 'set' accessor cannot have a return type annotation.",
|
SingleTypeParameterWithoutTrailingComma: ({
|
typeParameterName
|
}) => `Single type parameter ${typeParameterName} should have a trailing comma. Example usage: <${typeParameterName},>.`,
|
StaticBlockCannotHaveModifier: "Static class blocks cannot have any modifier.",
|
TupleOptionalAfterType: "A labeled tuple optional element must be declared using a question mark after the name and before the colon (`name?: type`), rather than after the type (`name: type?`).",
|
TypeAnnotationAfterAssign: "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
|
TypeImportCannotSpecifyDefaultAndNamed: "A type-only import can specify a default import or named bindings, but not both.",
|
TypeModifierIsUsedInTypeExports: "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
|
TypeModifierIsUsedInTypeImports: "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
|
UnexpectedParameterModifier: "A parameter property is only allowed in a constructor implementation.",
|
UnexpectedReadonly: "'readonly' type modifier is only permitted on array and tuple literal types.",
|
UnexpectedTypeAnnotation: "Did not expect a type annotation here.",
|
UnexpectedTypeCastInParameter: "Unexpected type cast in parameter position.",
|
UnsupportedImportTypeArgument: "Argument in a type import must be a string literal.",
|
UnsupportedParameterPropertyKind: "A parameter property may not be declared using a binding pattern.",
|
UnsupportedSignatureParameterKind: ({
|
type
|
}) => `Name in a signature must be an Identifier, ObjectPattern or ArrayPattern, instead got ${type}.`
|
});
|
function keywordTypeFromName(value) {
|
switch (value) {
|
case "any":
|
return "TSAnyKeyword";
|
case "boolean":
|
return "TSBooleanKeyword";
|
case "bigint":
|
return "TSBigIntKeyword";
|
case "never":
|
return "TSNeverKeyword";
|
case "number":
|
return "TSNumberKeyword";
|
case "object":
|
return "TSObjectKeyword";
|
case "string":
|
return "TSStringKeyword";
|
case "symbol":
|
return "TSSymbolKeyword";
|
case "undefined":
|
return "TSUndefinedKeyword";
|
case "unknown":
|
return "TSUnknownKeyword";
|
default:
|
return undefined;
|
}
|
}
|
function tsIsAccessModifier(modifier) {
|
return modifier === "private" || modifier === "public" || modifier === "protected";
|
}
|
function tsIsVarianceAnnotations(modifier) {
|
return modifier === "in" || modifier === "out";
|
}
|
var typescript = superClass => class TypeScriptParserMixin extends superClass {
|
constructor(...args) {
|
super(...args);
|
this.tsParseInOutModifiers = this.tsParseModifiers.bind(this, {
|
allowedModifiers: ["in", "out"],
|
disallowedModifiers: ["const", "public", "private", "protected", "readonly", "declare", "abstract", "override"],
|
errorTemplate: TSErrors.InvalidModifierOnTypeParameter
|
});
|
this.tsParseConstModifier = this.tsParseModifiers.bind(this, {
|
allowedModifiers: ["const"],
|
disallowedModifiers: ["in", "out"],
|
errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
|
});
|
this.tsParseInOutConstModifiers = this.tsParseModifiers.bind(this, {
|
allowedModifiers: ["in", "out", "const"],
|
disallowedModifiers: ["public", "private", "protected", "readonly", "declare", "abstract", "override"],
|
errorTemplate: TSErrors.InvalidModifierOnTypeParameter
|
});
|
}
|
getScopeHandler() {
|
return TypeScriptScopeHandler;
|
}
|
tsIsIdentifier() {
|
return tokenIsIdentifier(this.state.type);
|
}
|
tsTokenCanFollowModifier() {
|
return (this.match(0) || this.match(5) || this.match(55) || this.match(21) || this.match(136) || this.isLiteralPropertyName()) && !this.hasPrecedingLineBreak();
|
}
|
tsNextTokenCanFollowModifier() {
|
this.next();
|
return this.tsTokenCanFollowModifier();
|
}
|
tsParseModifier(allowedModifiers, stopOnStartOfClassStaticBlock) {
|
if (!tokenIsIdentifier(this.state.type) && this.state.type !== 58 && this.state.type !== 75) {
|
return undefined;
|
}
|
const modifier = this.state.value;
|
if (allowedModifiers.indexOf(modifier) !== -1) {
|
if (stopOnStartOfClassStaticBlock && this.tsIsStartOfStaticBlocks()) {
|
return undefined;
|
}
|
if (this.tsTryParse(this.tsNextTokenCanFollowModifier.bind(this))) {
|
return modifier;
|
}
|
}
|
return undefined;
|
}
|
tsParseModifiers({
|
allowedModifiers,
|
disallowedModifiers,
|
stopOnStartOfClassStaticBlock,
|
errorTemplate = TSErrors.InvalidModifierOnTypeMember
|
}, modified) {
|
const enforceOrder = (loc, modifier, before, after) => {
|
if (modifier === before && modified[after]) {
|
this.raise(TSErrors.InvalidModifiersOrder, {
|
at: loc,
|
orderedModifiers: [before, after]
|
});
|
}
|
};
|
const incompatible = (loc, modifier, mod1, mod2) => {
|
if (modified[mod1] && modifier === mod2 || modified[mod2] && modifier === mod1) {
|
this.raise(TSErrors.IncompatibleModifiers, {
|
at: loc,
|
modifiers: [mod1, mod2]
|
});
|
}
|
};
|
for (;;) {
|
const {
|
startLoc
|
} = this.state;
|
const modifier = this.tsParseModifier(allowedModifiers.concat(disallowedModifiers != null ? disallowedModifiers : []), stopOnStartOfClassStaticBlock);
|
if (!modifier) break;
|
if (tsIsAccessModifier(modifier)) {
|
if (modified.accessibility) {
|
this.raise(TSErrors.DuplicateAccessibilityModifier, {
|
at: startLoc,
|
modifier
|
});
|
} else {
|
enforceOrder(startLoc, modifier, modifier, "override");
|
enforceOrder(startLoc, modifier, modifier, "static");
|
enforceOrder(startLoc, modifier, modifier, "readonly");
|
modified.accessibility = modifier;
|
}
|
} else if (tsIsVarianceAnnotations(modifier)) {
|
if (modified[modifier]) {
|
this.raise(TSErrors.DuplicateModifier, {
|
at: startLoc,
|
modifier
|
});
|
}
|
modified[modifier] = true;
|
enforceOrder(startLoc, modifier, "in", "out");
|
} else {
|
if (Object.hasOwnProperty.call(modified, modifier)) {
|
this.raise(TSErrors.DuplicateModifier, {
|
at: startLoc,
|
modifier
|
});
|
} else {
|
enforceOrder(startLoc, modifier, "static", "readonly");
|
enforceOrder(startLoc, modifier, "static", "override");
|
enforceOrder(startLoc, modifier, "override", "readonly");
|
enforceOrder(startLoc, modifier, "abstract", "override");
|
incompatible(startLoc, modifier, "declare", "override");
|
incompatible(startLoc, modifier, "static", "abstract");
|
}
|
modified[modifier] = true;
|
}
|
if (disallowedModifiers != null && disallowedModifiers.includes(modifier)) {
|
this.raise(errorTemplate, {
|
at: startLoc,
|
modifier
|
});
|
}
|
}
|
}
|
tsIsListTerminator(kind) {
|
switch (kind) {
|
case "EnumMembers":
|
case "TypeMembers":
|
return this.match(8);
|
case "HeritageClauseElement":
|
return this.match(5);
|
case "TupleElementTypes":
|
return this.match(3);
|
case "TypeParametersOrArguments":
|
return this.match(48);
|
}
|
}
|
tsParseList(kind, parseElement) {
|
const result = [];
|
while (!this.tsIsListTerminator(kind)) {
|
result.push(parseElement());
|
}
|
return result;
|
}
|
tsParseDelimitedList(kind, parseElement, refTrailingCommaPos) {
|
return nonNull(this.tsParseDelimitedListWorker(kind, parseElement, true, refTrailingCommaPos));
|
}
|
tsParseDelimitedListWorker(kind, parseElement, expectSuccess, refTrailingCommaPos) {
|
const result = [];
|
let trailingCommaPos = -1;
|
for (;;) {
|
if (this.tsIsListTerminator(kind)) {
|
break;
|
}
|
trailingCommaPos = -1;
|
const element = parseElement();
|
if (element == null) {
|
return undefined;
|
}
|
result.push(element);
|
if (this.eat(12)) {
|
trailingCommaPos = this.state.lastTokStart;
|
continue;
|
}
|
if (this.tsIsListTerminator(kind)) {
|
break;
|
}
|
if (expectSuccess) {
|
this.expect(12);
|
}
|
return undefined;
|
}
|
if (refTrailingCommaPos) {
|
refTrailingCommaPos.value = trailingCommaPos;
|
}
|
return result;
|
}
|
tsParseBracketedList(kind, parseElement, bracket, skipFirstToken, refTrailingCommaPos) {
|
if (!skipFirstToken) {
|
if (bracket) {
|
this.expect(0);
|
} else {
|
this.expect(47);
|
}
|
}
|
const result = this.tsParseDelimitedList(kind, parseElement, refTrailingCommaPos);
|
if (bracket) {
|
this.expect(3);
|
} else {
|
this.expect(48);
|
}
|
return result;
|
}
|
tsParseImportType() {
|
const node = this.startNode();
|
this.expect(83);
|
this.expect(10);
|
if (!this.match(131)) {
|
this.raise(TSErrors.UnsupportedImportTypeArgument, {
|
at: this.state.startLoc
|
});
|
}
|
node.argument = super.parseExprAtom();
|
this.expect(11);
|
if (this.eat(16)) {
|
node.qualifier = this.tsParseEntityName();
|
}
|
if (this.match(47)) {
|
node.typeParameters = this.tsParseTypeArguments();
|
}
|
return this.finishNode(node, "TSImportType");
|
}
|
tsParseEntityName(allowReservedWords = true) {
|
let entity = this.parseIdentifier(allowReservedWords);
|
while (this.eat(16)) {
|
const node = this.startNodeAtNode(entity);
|
node.left = entity;
|
node.right = this.parseIdentifier(allowReservedWords);
|
entity = this.finishNode(node, "TSQualifiedName");
|
}
|
return entity;
|
}
|
tsParseTypeReference() {
|
const node = this.startNode();
|
node.typeName = this.tsParseEntityName();
|
if (!this.hasPrecedingLineBreak() && this.match(47)) {
|
node.typeParameters = this.tsParseTypeArguments();
|
}
|
return this.finishNode(node, "TSTypeReference");
|
}
|
tsParseThisTypePredicate(lhs) {
|
this.next();
|
const node = this.startNodeAtNode(lhs);
|
node.parameterName = lhs;
|
node.typeAnnotation = this.tsParseTypeAnnotation(false);
|
node.asserts = false;
|
return this.finishNode(node, "TSTypePredicate");
|
}
|
tsParseThisTypeNode() {
|
const node = this.startNode();
|
this.next();
|
return this.finishNode(node, "TSThisType");
|
}
|
tsParseTypeQuery() {
|
const node = this.startNode();
|
this.expect(87);
|
if (this.match(83)) {
|
node.exprName = this.tsParseImportType();
|
} else {
|
node.exprName = this.tsParseEntityName();
|
}
|
if (!this.hasPrecedingLineBreak() && this.match(47)) {
|
node.typeParameters = this.tsParseTypeArguments();
|
}
|
return this.finishNode(node, "TSTypeQuery");
|
}
|
tsParseTypeParameter(parseModifiers) {
|
const node = this.startNode();
|
parseModifiers(node);
|
node.name = this.tsParseTypeParameterName();
|
node.constraint = this.tsEatThenParseType(81);
|
node.default = this.tsEatThenParseType(29);
|
return this.finishNode(node, "TSTypeParameter");
|
}
|
tsTryParseTypeParameters(parseModifiers) {
|
if (this.match(47)) {
|
return this.tsParseTypeParameters(parseModifiers);
|
}
|
}
|
tsParseTypeParameters(parseModifiers) {
|
const node = this.startNode();
|
if (this.match(47) || this.match(140)) {
|
this.next();
|
} else {
|
this.unexpected();
|
}
|
const refTrailingCommaPos = {
|
value: -1
|
};
|
node.params = this.tsParseBracketedList("TypeParametersOrArguments", this.tsParseTypeParameter.bind(this, parseModifiers), false, true, refTrailingCommaPos);
|
if (node.params.length === 0) {
|
this.raise(TSErrors.EmptyTypeParameters, {
|
at: node
|
});
|
}
|
if (refTrailingCommaPos.value !== -1) {
|
this.addExtra(node, "trailingComma", refTrailingCommaPos.value);
|
}
|
return this.finishNode(node, "TSTypeParameterDeclaration");
|
}
|
tsFillSignature(returnToken, signature) {
|
const returnTokenRequired = returnToken === 19;
|
const paramsKey = "parameters";
|
const returnTypeKey = "typeAnnotation";
|
signature.typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
|
this.expect(10);
|
signature[paramsKey] = this.tsParseBindingListForSignature();
|
if (returnTokenRequired) {
|
signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
|
} else if (this.match(returnToken)) {
|
signature[returnTypeKey] = this.tsParseTypeOrTypePredicateAnnotation(returnToken);
|
}
|
}
|
tsParseBindingListForSignature() {
|
return super.parseBindingList(11, 41, 2).map(pattern => {
|
if (pattern.type !== "Identifier" && pattern.type !== "RestElement" && pattern.type !== "ObjectPattern" && pattern.type !== "ArrayPattern") {
|
this.raise(TSErrors.UnsupportedSignatureParameterKind, {
|
at: pattern,
|
type: pattern.type
|
});
|
}
|
return pattern;
|
});
|
}
|
tsParseTypeMemberSemicolon() {
|
if (!this.eat(12) && !this.isLineTerminator()) {
|
this.expect(13);
|
}
|
}
|
tsParseSignatureMember(kind, node) {
|
this.tsFillSignature(14, node);
|
this.tsParseTypeMemberSemicolon();
|
return this.finishNode(node, kind);
|
}
|
tsIsUnambiguouslyIndexSignature() {
|
this.next();
|
if (tokenIsIdentifier(this.state.type)) {
|
this.next();
|
return this.match(14);
|
}
|
return false;
|
}
|
tsTryParseIndexSignature(node) {
|
if (!(this.match(0) && this.tsLookAhead(this.tsIsUnambiguouslyIndexSignature.bind(this)))) {
|
return undefined;
|
}
|
this.expect(0);
|
const id = this.parseIdentifier();
|
id.typeAnnotation = this.tsParseTypeAnnotation();
|
this.resetEndLocation(id);
|
this.expect(3);
|
node.parameters = [id];
|
const type = this.tsTryParseTypeAnnotation();
|
if (type) node.typeAnnotation = type;
|
this.tsParseTypeMemberSemicolon();
|
return this.finishNode(node, "TSIndexSignature");
|
}
|
tsParsePropertyOrMethodSignature(node, readonly) {
|
if (this.eat(17)) node.optional = true;
|
const nodeAny = node;
|
if (this.match(10) || this.match(47)) {
|
if (readonly) {
|
this.raise(TSErrors.ReadonlyForMethodSignature, {
|
at: node
|
});
|
}
|
const method = nodeAny;
|
if (method.kind && this.match(47)) {
|
this.raise(TSErrors.AccesorCannotHaveTypeParameters, {
|
at: this.state.curPosition()
|
});
|
}
|
this.tsFillSignature(14, method);
|
this.tsParseTypeMemberSemicolon();
|
const paramsKey = "parameters";
|
const returnTypeKey = "typeAnnotation";
|
if (method.kind === "get") {
|
if (method[paramsKey].length > 0) {
|
this.raise(Errors.BadGetterArity, {
|
at: this.state.curPosition()
|
});
|
if (this.isThisParam(method[paramsKey][0])) {
|
this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
|
at: this.state.curPosition()
|
});
|
}
|
}
|
} else if (method.kind === "set") {
|
if (method[paramsKey].length !== 1) {
|
this.raise(Errors.BadSetterArity, {
|
at: this.state.curPosition()
|
});
|
} else {
|
const firstParameter = method[paramsKey][0];
|
if (this.isThisParam(firstParameter)) {
|
this.raise(TSErrors.AccesorCannotDeclareThisParameter, {
|
at: this.state.curPosition()
|
});
|
}
|
if (firstParameter.type === "Identifier" && firstParameter.optional) {
|
this.raise(TSErrors.SetAccesorCannotHaveOptionalParameter, {
|
at: this.state.curPosition()
|
});
|
}
|
if (firstParameter.type === "RestElement") {
|
this.raise(TSErrors.SetAccesorCannotHaveRestParameter, {
|
at: this.state.curPosition()
|
});
|
}
|
}
|
if (method[returnTypeKey]) {
|
this.raise(TSErrors.SetAccesorCannotHaveReturnType, {
|
at: method[returnTypeKey]
|
});
|
}
|
} else {
|
method.kind = "method";
|
}
|
return this.finishNode(method, "TSMethodSignature");
|
} else {
|
const property = nodeAny;
|
if (readonly) property.readonly = true;
|
const type = this.tsTryParseTypeAnnotation();
|
if (type) property.typeAnnotation = type;
|
this.tsParseTypeMemberSemicolon();
|
return this.finishNode(property, "TSPropertySignature");
|
}
|
}
|
tsParseTypeMember() {
|
const node = this.startNode();
|
if (this.match(10) || this.match(47)) {
|
return this.tsParseSignatureMember("TSCallSignatureDeclaration", node);
|
}
|
if (this.match(77)) {
|
const id = this.startNode();
|
this.next();
|
if (this.match(10) || this.match(47)) {
|
return this.tsParseSignatureMember("TSConstructSignatureDeclaration", node);
|
} else {
|
node.key = this.createIdentifier(id, "new");
|
return this.tsParsePropertyOrMethodSignature(node, false);
|
}
|
}
|
this.tsParseModifiers({
|
allowedModifiers: ["readonly"],
|
disallowedModifiers: ["declare", "abstract", "private", "protected", "public", "static", "override"]
|
}, node);
|
const idx = this.tsTryParseIndexSignature(node);
|
if (idx) {
|
return idx;
|
}
|
super.parsePropertyName(node);
|
if (!node.computed && node.key.type === "Identifier" && (node.key.name === "get" || node.key.name === "set") && this.tsTokenCanFollowModifier()) {
|
node.kind = node.key.name;
|
super.parsePropertyName(node);
|
}
|
return this.tsParsePropertyOrMethodSignature(node, !!node.readonly);
|
}
|
tsParseTypeLiteral() {
|
const node = this.startNode();
|
node.members = this.tsParseObjectTypeMembers();
|
return this.finishNode(node, "TSTypeLiteral");
|
}
|
tsParseObjectTypeMembers() {
|
this.expect(5);
|
const members = this.tsParseList("TypeMembers", this.tsParseTypeMember.bind(this));
|
this.expect(8);
|
return members;
|
}
|
tsIsStartOfMappedType() {
|
this.next();
|
if (this.eat(53)) {
|
return this.isContextual(120);
|
}
|
if (this.isContextual(120)) {
|
this.next();
|
}
|
if (!this.match(0)) {
|
return false;
|
}
|
this.next();
|
if (!this.tsIsIdentifier()) {
|
return false;
|
}
|
this.next();
|
return this.match(58);
|
}
|
tsParseMappedTypeParameter() {
|
const node = this.startNode();
|
node.name = this.tsParseTypeParameterName();
|
node.constraint = this.tsExpectThenParseType(58);
|
return this.finishNode(node, "TSTypeParameter");
|
}
|
tsParseMappedType() {
|
const node = this.startNode();
|
this.expect(5);
|
if (this.match(53)) {
|
node.readonly = this.state.value;
|
this.next();
|
this.expectContextual(120);
|
} else if (this.eatContextual(120)) {
|
node.readonly = true;
|
}
|
this.expect(0);
|
node.typeParameter = this.tsParseMappedTypeParameter();
|
node.nameType = this.eatContextual(93) ? this.tsParseType() : null;
|
this.expect(3);
|
if (this.match(53)) {
|
node.optional = this.state.value;
|
this.next();
|
this.expect(17);
|
} else if (this.eat(17)) {
|
node.optional = true;
|
}
|
node.typeAnnotation = this.tsTryParseType();
|
this.semicolon();
|
this.expect(8);
|
return this.finishNode(node, "TSMappedType");
|
}
|
tsParseTupleType() {
|
const node = this.startNode();
|
node.elementTypes = this.tsParseBracketedList("TupleElementTypes", this.tsParseTupleElementType.bind(this), true, false);
|
let seenOptionalElement = false;
|
let labeledElements = null;
|
node.elementTypes.forEach(elementNode => {
|
var _labeledElements;
|
const {
|
type
|
} = elementNode;
|
if (seenOptionalElement && type !== "TSRestType" && type !== "TSOptionalType" && !(type === "TSNamedTupleMember" && elementNode.optional)) {
|
this.raise(TSErrors.OptionalTypeBeforeRequired, {
|
at: elementNode
|
});
|
}
|
seenOptionalElement || (seenOptionalElement = type === "TSNamedTupleMember" && elementNode.optional || type === "TSOptionalType");
|
let checkType = type;
|
if (type === "TSRestType") {
|
elementNode = elementNode.typeAnnotation;
|
checkType = elementNode.type;
|
}
|
const isLabeled = checkType === "TSNamedTupleMember";
|
(_labeledElements = labeledElements) != null ? _labeledElements : labeledElements = isLabeled;
|
if (labeledElements !== isLabeled) {
|
this.raise(TSErrors.MixedLabeledAndUnlabeledElements, {
|
at: elementNode
|
});
|
}
|
});
|
return this.finishNode(node, "TSTupleType");
|
}
|
tsParseTupleElementType() {
|
const {
|
startLoc
|
} = this.state;
|
const rest = this.eat(21);
|
let labeled;
|
let label;
|
let optional;
|
let type;
|
const isWord = tokenIsKeywordOrIdentifier(this.state.type);
|
const chAfterWord = isWord ? this.lookaheadCharCode() : null;
|
if (chAfterWord === 58) {
|
labeled = true;
|
optional = false;
|
label = this.parseIdentifier(true);
|
this.expect(14);
|
type = this.tsParseType();
|
} else if (chAfterWord === 63) {
|
optional = true;
|
const startLoc = this.state.startLoc;
|
const wordName = this.state.value;
|
const typeOrLabel = this.tsParseNonArrayType();
|
if (this.lookaheadCharCode() === 58) {
|
labeled = true;
|
label = this.createIdentifier(this.startNodeAt(startLoc), wordName);
|
this.expect(17);
|
this.expect(14);
|
type = this.tsParseType();
|
} else {
|
labeled = false;
|
type = typeOrLabel;
|
this.expect(17);
|
}
|
} else {
|
type = this.tsParseType();
|
optional = this.eat(17);
|
labeled = this.eat(14);
|
}
|
if (labeled) {
|
let labeledNode;
|
if (label) {
|
labeledNode = this.startNodeAtNode(label);
|
labeledNode.optional = optional;
|
labeledNode.label = label;
|
labeledNode.elementType = type;
|
if (this.eat(17)) {
|
labeledNode.optional = true;
|
this.raise(TSErrors.TupleOptionalAfterType, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
} else {
|
labeledNode = this.startNodeAtNode(type);
|
labeledNode.optional = optional;
|
this.raise(TSErrors.InvalidTupleMemberLabel, {
|
at: type
|
});
|
labeledNode.label = type;
|
labeledNode.elementType = this.tsParseType();
|
}
|
type = this.finishNode(labeledNode, "TSNamedTupleMember");
|
} else if (optional) {
|
const optionalTypeNode = this.startNodeAtNode(type);
|
optionalTypeNode.typeAnnotation = type;
|
type = this.finishNode(optionalTypeNode, "TSOptionalType");
|
}
|
if (rest) {
|
const restNode = this.startNodeAt(startLoc);
|
restNode.typeAnnotation = type;
|
type = this.finishNode(restNode, "TSRestType");
|
}
|
return type;
|
}
|
tsParseParenthesizedType() {
|
const node = this.startNode();
|
this.expect(10);
|
node.typeAnnotation = this.tsParseType();
|
this.expect(11);
|
return this.finishNode(node, "TSParenthesizedType");
|
}
|
tsParseFunctionOrConstructorType(type, abstract) {
|
const node = this.startNode();
|
if (type === "TSConstructorType") {
|
node.abstract = !!abstract;
|
if (abstract) this.next();
|
this.next();
|
}
|
this.tsInAllowConditionalTypesContext(() => this.tsFillSignature(19, node));
|
return this.finishNode(node, type);
|
}
|
tsParseLiteralTypeNode() {
|
const node = this.startNode();
|
node.literal = (() => {
|
switch (this.state.type) {
|
case 132:
|
case 133:
|
case 131:
|
case 85:
|
case 86:
|
return super.parseExprAtom();
|
default:
|
this.unexpected();
|
}
|
})();
|
return this.finishNode(node, "TSLiteralType");
|
}
|
tsParseTemplateLiteralType() {
|
const node = this.startNode();
|
node.literal = super.parseTemplate(false);
|
return this.finishNode(node, "TSLiteralType");
|
}
|
parseTemplateSubstitution() {
|
if (this.state.inType) return this.tsParseType();
|
return super.parseTemplateSubstitution();
|
}
|
tsParseThisTypeOrThisTypePredicate() {
|
const thisKeyword = this.tsParseThisTypeNode();
|
if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
|
return this.tsParseThisTypePredicate(thisKeyword);
|
} else {
|
return thisKeyword;
|
}
|
}
|
tsParseNonArrayType() {
|
switch (this.state.type) {
|
case 131:
|
case 132:
|
case 133:
|
case 85:
|
case 86:
|
return this.tsParseLiteralTypeNode();
|
case 53:
|
if (this.state.value === "-") {
|
const node = this.startNode();
|
const nextToken = this.lookahead();
|
if (nextToken.type !== 132 && nextToken.type !== 133) {
|
this.unexpected();
|
}
|
node.literal = this.parseMaybeUnary();
|
return this.finishNode(node, "TSLiteralType");
|
}
|
break;
|
case 78:
|
return this.tsParseThisTypeOrThisTypePredicate();
|
case 87:
|
return this.tsParseTypeQuery();
|
case 83:
|
return this.tsParseImportType();
|
case 5:
|
return this.tsLookAhead(this.tsIsStartOfMappedType.bind(this)) ? this.tsParseMappedType() : this.tsParseTypeLiteral();
|
case 0:
|
return this.tsParseTupleType();
|
case 10:
|
return this.tsParseParenthesizedType();
|
case 25:
|
case 24:
|
return this.tsParseTemplateLiteralType();
|
default:
|
{
|
const {
|
type
|
} = this.state;
|
if (tokenIsIdentifier(type) || type === 88 || type === 84) {
|
const nodeType = type === 88 ? "TSVoidKeyword" : type === 84 ? "TSNullKeyword" : keywordTypeFromName(this.state.value);
|
if (nodeType !== undefined && this.lookaheadCharCode() !== 46) {
|
const node = this.startNode();
|
this.next();
|
return this.finishNode(node, nodeType);
|
}
|
return this.tsParseTypeReference();
|
}
|
}
|
}
|
this.unexpected();
|
}
|
tsParseArrayTypeOrHigher() {
|
let type = this.tsParseNonArrayType();
|
while (!this.hasPrecedingLineBreak() && this.eat(0)) {
|
if (this.match(3)) {
|
const node = this.startNodeAtNode(type);
|
node.elementType = type;
|
this.expect(3);
|
type = this.finishNode(node, "TSArrayType");
|
} else {
|
const node = this.startNodeAtNode(type);
|
node.objectType = type;
|
node.indexType = this.tsParseType();
|
this.expect(3);
|
type = this.finishNode(node, "TSIndexedAccessType");
|
}
|
}
|
return type;
|
}
|
tsParseTypeOperator() {
|
const node = this.startNode();
|
const operator = this.state.value;
|
this.next();
|
node.operator = operator;
|
node.typeAnnotation = this.tsParseTypeOperatorOrHigher();
|
if (operator === "readonly") {
|
this.tsCheckTypeAnnotationForReadOnly(node);
|
}
|
return this.finishNode(node, "TSTypeOperator");
|
}
|
tsCheckTypeAnnotationForReadOnly(node) {
|
switch (node.typeAnnotation.type) {
|
case "TSTupleType":
|
case "TSArrayType":
|
return;
|
default:
|
this.raise(TSErrors.UnexpectedReadonly, {
|
at: node
|
});
|
}
|
}
|
tsParseInferType() {
|
const node = this.startNode();
|
this.expectContextual(113);
|
const typeParameter = this.startNode();
|
typeParameter.name = this.tsParseTypeParameterName();
|
typeParameter.constraint = this.tsTryParse(() => this.tsParseConstraintForInferType());
|
node.typeParameter = this.finishNode(typeParameter, "TSTypeParameter");
|
return this.finishNode(node, "TSInferType");
|
}
|
tsParseConstraintForInferType() {
|
if (this.eat(81)) {
|
const constraint = this.tsInDisallowConditionalTypesContext(() => this.tsParseType());
|
if (this.state.inDisallowConditionalTypesContext || !this.match(17)) {
|
return constraint;
|
}
|
}
|
}
|
tsParseTypeOperatorOrHigher() {
|
const isTypeOperator = tokenIsTSTypeOperator(this.state.type) && !this.state.containsEsc;
|
return isTypeOperator ? this.tsParseTypeOperator() : this.isContextual(113) ? this.tsParseInferType() : this.tsInAllowConditionalTypesContext(() => this.tsParseArrayTypeOrHigher());
|
}
|
tsParseUnionOrIntersectionType(kind, parseConstituentType, operator) {
|
const node = this.startNode();
|
const hasLeadingOperator = this.eat(operator);
|
const types = [];
|
do {
|
types.push(parseConstituentType());
|
} while (this.eat(operator));
|
if (types.length === 1 && !hasLeadingOperator) {
|
return types[0];
|
}
|
node.types = types;
|
return this.finishNode(node, kind);
|
}
|
tsParseIntersectionTypeOrHigher() {
|
return this.tsParseUnionOrIntersectionType("TSIntersectionType", this.tsParseTypeOperatorOrHigher.bind(this), 45);
|
}
|
tsParseUnionTypeOrHigher() {
|
return this.tsParseUnionOrIntersectionType("TSUnionType", this.tsParseIntersectionTypeOrHigher.bind(this), 43);
|
}
|
tsIsStartOfFunctionType() {
|
if (this.match(47)) {
|
return true;
|
}
|
return this.match(10) && this.tsLookAhead(this.tsIsUnambiguouslyStartOfFunctionType.bind(this));
|
}
|
tsSkipParameterStart() {
|
if (tokenIsIdentifier(this.state.type) || this.match(78)) {
|
this.next();
|
return true;
|
}
|
if (this.match(5)) {
|
const {
|
errors
|
} = this.state;
|
const previousErrorCount = errors.length;
|
try {
|
this.parseObjectLike(8, true);
|
return errors.length === previousErrorCount;
|
} catch (_unused) {
|
return false;
|
}
|
}
|
if (this.match(0)) {
|
this.next();
|
const {
|
errors
|
} = this.state;
|
const previousErrorCount = errors.length;
|
try {
|
super.parseBindingList(3, 93, 1);
|
return errors.length === previousErrorCount;
|
} catch (_unused2) {
|
return false;
|
}
|
}
|
return false;
|
}
|
tsIsUnambiguouslyStartOfFunctionType() {
|
this.next();
|
if (this.match(11) || this.match(21)) {
|
return true;
|
}
|
if (this.tsSkipParameterStart()) {
|
if (this.match(14) || this.match(12) || this.match(17) || this.match(29)) {
|
return true;
|
}
|
if (this.match(11)) {
|
this.next();
|
if (this.match(19)) {
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
tsParseTypeOrTypePredicateAnnotation(returnToken) {
|
return this.tsInType(() => {
|
const t = this.startNode();
|
this.expect(returnToken);
|
const node = this.startNode();
|
const asserts = !!this.tsTryParse(this.tsParseTypePredicateAsserts.bind(this));
|
if (asserts && this.match(78)) {
|
let thisTypePredicate = this.tsParseThisTypeOrThisTypePredicate();
|
if (thisTypePredicate.type === "TSThisType") {
|
node.parameterName = thisTypePredicate;
|
node.asserts = true;
|
node.typeAnnotation = null;
|
thisTypePredicate = this.finishNode(node, "TSTypePredicate");
|
} else {
|
this.resetStartLocationFromNode(thisTypePredicate, node);
|
thisTypePredicate.asserts = true;
|
}
|
t.typeAnnotation = thisTypePredicate;
|
return this.finishNode(t, "TSTypeAnnotation");
|
}
|
const typePredicateVariable = this.tsIsIdentifier() && this.tsTryParse(this.tsParseTypePredicatePrefix.bind(this));
|
if (!typePredicateVariable) {
|
if (!asserts) {
|
return this.tsParseTypeAnnotation(false, t);
|
}
|
node.parameterName = this.parseIdentifier();
|
node.asserts = asserts;
|
node.typeAnnotation = null;
|
t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
|
return this.finishNode(t, "TSTypeAnnotation");
|
}
|
const type = this.tsParseTypeAnnotation(false);
|
node.parameterName = typePredicateVariable;
|
node.typeAnnotation = type;
|
node.asserts = asserts;
|
t.typeAnnotation = this.finishNode(node, "TSTypePredicate");
|
return this.finishNode(t, "TSTypeAnnotation");
|
});
|
}
|
tsTryParseTypeOrTypePredicateAnnotation() {
|
return this.match(14) ? this.tsParseTypeOrTypePredicateAnnotation(14) : undefined;
|
}
|
tsTryParseTypeAnnotation() {
|
return this.match(14) ? this.tsParseTypeAnnotation() : undefined;
|
}
|
tsTryParseType() {
|
return this.tsEatThenParseType(14);
|
}
|
tsParseTypePredicatePrefix() {
|
const id = this.parseIdentifier();
|
if (this.isContextual(114) && !this.hasPrecedingLineBreak()) {
|
this.next();
|
return id;
|
}
|
}
|
tsParseTypePredicateAsserts() {
|
if (this.state.type !== 107) {
|
return false;
|
}
|
const containsEsc = this.state.containsEsc;
|
this.next();
|
if (!tokenIsIdentifier(this.state.type) && !this.match(78)) {
|
return false;
|
}
|
if (containsEsc) {
|
this.raise(Errors.InvalidEscapedReservedWord, {
|
at: this.state.lastTokStartLoc,
|
reservedWord: "asserts"
|
});
|
}
|
return true;
|
}
|
tsParseTypeAnnotation(eatColon = true, t = this.startNode()) {
|
this.tsInType(() => {
|
if (eatColon) this.expect(14);
|
t.typeAnnotation = this.tsParseType();
|
});
|
return this.finishNode(t, "TSTypeAnnotation");
|
}
|
tsParseType() {
|
assert$1(this.state.inType);
|
const type = this.tsParseNonConditionalType();
|
if (this.state.inDisallowConditionalTypesContext || this.hasPrecedingLineBreak() || !this.eat(81)) {
|
return type;
|
}
|
const node = this.startNodeAtNode(type);
|
node.checkType = type;
|
node.extendsType = this.tsInDisallowConditionalTypesContext(() => this.tsParseNonConditionalType());
|
this.expect(17);
|
node.trueType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
|
this.expect(14);
|
node.falseType = this.tsInAllowConditionalTypesContext(() => this.tsParseType());
|
return this.finishNode(node, "TSConditionalType");
|
}
|
isAbstractConstructorSignature() {
|
return this.isContextual(122) && this.lookahead().type === 77;
|
}
|
tsParseNonConditionalType() {
|
if (this.tsIsStartOfFunctionType()) {
|
return this.tsParseFunctionOrConstructorType("TSFunctionType");
|
}
|
if (this.match(77)) {
|
return this.tsParseFunctionOrConstructorType("TSConstructorType");
|
} else if (this.isAbstractConstructorSignature()) {
|
return this.tsParseFunctionOrConstructorType("TSConstructorType", true);
|
}
|
return this.tsParseUnionTypeOrHigher();
|
}
|
tsParseTypeAssertion() {
|
if (this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
|
this.raise(TSErrors.ReservedTypeAssertion, {
|
at: this.state.startLoc
|
});
|
}
|
const node = this.startNode();
|
node.typeAnnotation = this.tsInType(() => {
|
this.next();
|
return this.match(75) ? this.tsParseTypeReference() : this.tsParseType();
|
});
|
this.expect(48);
|
node.expression = this.parseMaybeUnary();
|
return this.finishNode(node, "TSTypeAssertion");
|
}
|
tsParseHeritageClause(token) {
|
const originalStartLoc = this.state.startLoc;
|
const delimitedList = this.tsParseDelimitedList("HeritageClauseElement", () => {
|
const node = this.startNode();
|
node.expression = this.tsParseEntityName();
|
if (this.match(47)) {
|
node.typeParameters = this.tsParseTypeArguments();
|
}
|
return this.finishNode(node, "TSExpressionWithTypeArguments");
|
});
|
if (!delimitedList.length) {
|
this.raise(TSErrors.EmptyHeritageClauseType, {
|
at: originalStartLoc,
|
token
|
});
|
}
|
return delimitedList;
|
}
|
tsParseInterfaceDeclaration(node, properties = {}) {
|
if (this.hasFollowingLineBreak()) return null;
|
this.expectContextual(127);
|
if (properties.declare) node.declare = true;
|
if (tokenIsIdentifier(this.state.type)) {
|
node.id = this.parseIdentifier();
|
this.checkIdentifier(node.id, BIND_TS_INTERFACE);
|
} else {
|
node.id = null;
|
this.raise(TSErrors.MissingInterfaceName, {
|
at: this.state.startLoc
|
});
|
}
|
node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
|
if (this.eat(81)) {
|
node.extends = this.tsParseHeritageClause("extends");
|
}
|
const body = this.startNode();
|
body.body = this.tsInType(this.tsParseObjectTypeMembers.bind(this));
|
node.body = this.finishNode(body, "TSInterfaceBody");
|
return this.finishNode(node, "TSInterfaceDeclaration");
|
}
|
tsParseTypeAliasDeclaration(node) {
|
node.id = this.parseIdentifier();
|
this.checkIdentifier(node.id, BIND_TS_TYPE);
|
node.typeAnnotation = this.tsInType(() => {
|
node.typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutModifiers);
|
this.expect(29);
|
if (this.isContextual(112) && this.lookahead().type !== 16) {
|
const node = this.startNode();
|
this.next();
|
return this.finishNode(node, "TSIntrinsicKeyword");
|
}
|
return this.tsParseType();
|
});
|
this.semicolon();
|
return this.finishNode(node, "TSTypeAliasDeclaration");
|
}
|
tsInNoContext(cb) {
|
const oldContext = this.state.context;
|
this.state.context = [oldContext[0]];
|
try {
|
return cb();
|
} finally {
|
this.state.context = oldContext;
|
}
|
}
|
tsInType(cb) {
|
const oldInType = this.state.inType;
|
this.state.inType = true;
|
try {
|
return cb();
|
} finally {
|
this.state.inType = oldInType;
|
}
|
}
|
tsInDisallowConditionalTypesContext(cb) {
|
const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
|
this.state.inDisallowConditionalTypesContext = true;
|
try {
|
return cb();
|
} finally {
|
this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
|
}
|
}
|
tsInAllowConditionalTypesContext(cb) {
|
const oldInDisallowConditionalTypesContext = this.state.inDisallowConditionalTypesContext;
|
this.state.inDisallowConditionalTypesContext = false;
|
try {
|
return cb();
|
} finally {
|
this.state.inDisallowConditionalTypesContext = oldInDisallowConditionalTypesContext;
|
}
|
}
|
tsEatThenParseType(token) {
|
return !this.match(token) ? undefined : this.tsNextThenParseType();
|
}
|
tsExpectThenParseType(token) {
|
return this.tsDoThenParseType(() => this.expect(token));
|
}
|
tsNextThenParseType() {
|
return this.tsDoThenParseType(() => this.next());
|
}
|
tsDoThenParseType(cb) {
|
return this.tsInType(() => {
|
cb();
|
return this.tsParseType();
|
});
|
}
|
tsParseEnumMember() {
|
const node = this.startNode();
|
node.id = this.match(131) ? super.parseStringLiteral(this.state.value) : this.parseIdentifier(true);
|
if (this.eat(29)) {
|
node.initializer = super.parseMaybeAssignAllowIn();
|
}
|
return this.finishNode(node, "TSEnumMember");
|
}
|
tsParseEnumDeclaration(node, properties = {}) {
|
if (properties.const) node.const = true;
|
if (properties.declare) node.declare = true;
|
this.expectContextual(124);
|
node.id = this.parseIdentifier();
|
this.checkIdentifier(node.id, node.const ? BIND_TS_CONST_ENUM : BIND_TS_ENUM);
|
this.expect(5);
|
node.members = this.tsParseDelimitedList("EnumMembers", this.tsParseEnumMember.bind(this));
|
this.expect(8);
|
return this.finishNode(node, "TSEnumDeclaration");
|
}
|
tsParseModuleBlock() {
|
const node = this.startNode();
|
this.scope.enter(SCOPE_OTHER);
|
this.expect(5);
|
super.parseBlockOrModuleBlockBody(node.body = [], undefined, true, 8);
|
this.scope.exit();
|
return this.finishNode(node, "TSModuleBlock");
|
}
|
tsParseModuleOrNamespaceDeclaration(node, nested = false) {
|
node.id = this.parseIdentifier();
|
if (!nested) {
|
this.checkIdentifier(node.id, BIND_TS_NAMESPACE);
|
}
|
if (this.eat(16)) {
|
const inner = this.startNode();
|
this.tsParseModuleOrNamespaceDeclaration(inner, true);
|
node.body = inner;
|
} else {
|
this.scope.enter(SCOPE_TS_MODULE);
|
this.prodParam.enter(PARAM);
|
node.body = this.tsParseModuleBlock();
|
this.prodParam.exit();
|
this.scope.exit();
|
}
|
return this.finishNode(node, "TSModuleDeclaration");
|
}
|
tsParseAmbientExternalModuleDeclaration(node) {
|
if (this.isContextual(110)) {
|
node.global = true;
|
node.id = this.parseIdentifier();
|
} else if (this.match(131)) {
|
node.id = super.parseStringLiteral(this.state.value);
|
} else {
|
this.unexpected();
|
}
|
if (this.match(5)) {
|
this.scope.enter(SCOPE_TS_MODULE);
|
this.prodParam.enter(PARAM);
|
node.body = this.tsParseModuleBlock();
|
this.prodParam.exit();
|
this.scope.exit();
|
} else {
|
this.semicolon();
|
}
|
return this.finishNode(node, "TSModuleDeclaration");
|
}
|
tsParseImportEqualsDeclaration(node, isExport) {
|
node.isExport = isExport || false;
|
node.id = this.parseIdentifier();
|
this.checkIdentifier(node.id, BIND_FLAGS_TS_IMPORT);
|
this.expect(29);
|
const moduleReference = this.tsParseModuleReference();
|
if (node.importKind === "type" && moduleReference.type !== "TSExternalModuleReference") {
|
this.raise(TSErrors.ImportAliasHasImportType, {
|
at: moduleReference
|
});
|
}
|
node.moduleReference = moduleReference;
|
this.semicolon();
|
return this.finishNode(node, "TSImportEqualsDeclaration");
|
}
|
tsIsExternalModuleReference() {
|
return this.isContextual(117) && this.lookaheadCharCode() === 40;
|
}
|
tsParseModuleReference() {
|
return this.tsIsExternalModuleReference() ? this.tsParseExternalModuleReference() : this.tsParseEntityName(false);
|
}
|
tsParseExternalModuleReference() {
|
const node = this.startNode();
|
this.expectContextual(117);
|
this.expect(10);
|
if (!this.match(131)) {
|
this.unexpected();
|
}
|
node.expression = super.parseExprAtom();
|
this.expect(11);
|
return this.finishNode(node, "TSExternalModuleReference");
|
}
|
tsLookAhead(f) {
|
const state = this.state.clone();
|
const res = f();
|
this.state = state;
|
return res;
|
}
|
tsTryParseAndCatch(f) {
|
const result = this.tryParse(abort => f() || abort());
|
if (result.aborted || !result.node) return undefined;
|
if (result.error) this.state = result.failState;
|
return result.node;
|
}
|
tsTryParse(f) {
|
const state = this.state.clone();
|
const result = f();
|
if (result !== undefined && result !== false) {
|
return result;
|
} else {
|
this.state = state;
|
return undefined;
|
}
|
}
|
tsTryParseDeclare(nany) {
|
if (this.isLineTerminator()) {
|
return;
|
}
|
let starttype = this.state.type;
|
let kind;
|
if (this.isContextual(99)) {
|
starttype = 74;
|
kind = "let";
|
}
|
return this.tsInAmbientContext(() => {
|
if (starttype === 68) {
|
nany.declare = true;
|
return super.parseFunctionStatement(nany, false, false);
|
}
|
if (starttype === 80) {
|
nany.declare = true;
|
return this.parseClass(nany, true, false);
|
}
|
if (starttype === 124) {
|
return this.tsParseEnumDeclaration(nany, {
|
declare: true
|
});
|
}
|
if (starttype === 110) {
|
return this.tsParseAmbientExternalModuleDeclaration(nany);
|
}
|
if (starttype === 75 || starttype === 74) {
|
if (!this.match(75) || !this.isLookaheadContextual("enum")) {
|
nany.declare = true;
|
return this.parseVarStatement(nany, kind || this.state.value, true);
|
}
|
this.expect(75);
|
return this.tsParseEnumDeclaration(nany, {
|
const: true,
|
declare: true
|
});
|
}
|
if (starttype === 127) {
|
const result = this.tsParseInterfaceDeclaration(nany, {
|
declare: true
|
});
|
if (result) return result;
|
}
|
if (tokenIsIdentifier(starttype)) {
|
return this.tsParseDeclaration(nany, this.state.value, true, null);
|
}
|
});
|
}
|
tsTryParseExportDeclaration() {
|
return this.tsParseDeclaration(this.startNode(), this.state.value, true, null);
|
}
|
tsParseExpressionStatement(node, expr, decorators) {
|
switch (expr.name) {
|
case "declare":
|
{
|
const declaration = this.tsTryParseDeclare(node);
|
if (declaration) {
|
declaration.declare = true;
|
return declaration;
|
}
|
break;
|
}
|
case "global":
|
if (this.match(5)) {
|
this.scope.enter(SCOPE_TS_MODULE);
|
this.prodParam.enter(PARAM);
|
const mod = node;
|
mod.global = true;
|
mod.id = expr;
|
mod.body = this.tsParseModuleBlock();
|
this.scope.exit();
|
this.prodParam.exit();
|
return this.finishNode(mod, "TSModuleDeclaration");
|
}
|
break;
|
default:
|
return this.tsParseDeclaration(node, expr.name, false, decorators);
|
}
|
}
|
tsParseDeclaration(node, value, next, decorators) {
|
switch (value) {
|
case "abstract":
|
if (this.tsCheckLineTerminator(next) && (this.match(80) || tokenIsIdentifier(this.state.type))) {
|
return this.tsParseAbstractDeclaration(node, decorators);
|
}
|
break;
|
case "module":
|
if (this.tsCheckLineTerminator(next)) {
|
if (this.match(131)) {
|
return this.tsParseAmbientExternalModuleDeclaration(node);
|
} else if (tokenIsIdentifier(this.state.type)) {
|
return this.tsParseModuleOrNamespaceDeclaration(node);
|
}
|
}
|
break;
|
case "namespace":
|
if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
|
return this.tsParseModuleOrNamespaceDeclaration(node);
|
}
|
break;
|
case "type":
|
if (this.tsCheckLineTerminator(next) && tokenIsIdentifier(this.state.type)) {
|
return this.tsParseTypeAliasDeclaration(node);
|
}
|
break;
|
}
|
}
|
tsCheckLineTerminator(next) {
|
if (next) {
|
if (this.hasFollowingLineBreak()) return false;
|
this.next();
|
return true;
|
}
|
return !this.isLineTerminator();
|
}
|
tsTryParseGenericAsyncArrowFunction(startLoc) {
|
if (!this.match(47)) {
|
return undefined;
|
}
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
|
this.state.maybeInArrowParameters = true;
|
const res = this.tsTryParseAndCatch(() => {
|
const node = this.startNodeAt(startLoc);
|
node.typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
|
super.parseFunctionParams(node);
|
node.returnType = this.tsTryParseTypeOrTypePredicateAnnotation();
|
this.expect(19);
|
return node;
|
});
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
|
if (!res) {
|
return undefined;
|
}
|
return super.parseArrowExpression(res, null, true);
|
}
|
tsParseTypeArgumentsInExpression() {
|
if (this.reScan_lt() !== 47) {
|
return undefined;
|
}
|
return this.tsParseTypeArguments();
|
}
|
tsParseTypeArguments() {
|
const node = this.startNode();
|
node.params = this.tsInType(() => this.tsInNoContext(() => {
|
this.expect(47);
|
return this.tsParseDelimitedList("TypeParametersOrArguments", this.tsParseType.bind(this));
|
}));
|
if (node.params.length === 0) {
|
this.raise(TSErrors.EmptyTypeArguments, {
|
at: node
|
});
|
}
|
this.expect(48);
|
return this.finishNode(node, "TSTypeParameterInstantiation");
|
}
|
tsIsDeclarationStart() {
|
return tokenIsTSDeclarationStart(this.state.type);
|
}
|
isExportDefaultSpecifier() {
|
if (this.tsIsDeclarationStart()) return false;
|
return super.isExportDefaultSpecifier();
|
}
|
parseAssignableListItem(flags, decorators) {
|
const startLoc = this.state.startLoc;
|
const modified = {};
|
this.tsParseModifiers({
|
allowedModifiers: ["public", "private", "protected", "override", "readonly"]
|
}, modified);
|
const accessibility = modified.accessibility;
|
const override = modified.override;
|
const readonly = modified.readonly;
|
if (!(flags & 4) && (accessibility || readonly || override)) {
|
this.raise(TSErrors.UnexpectedParameterModifier, {
|
at: startLoc
|
});
|
}
|
const left = this.parseMaybeDefault();
|
this.parseAssignableListItemTypes(left, flags);
|
const elt = this.parseMaybeDefault(left.loc.start, left);
|
if (accessibility || readonly || override) {
|
const pp = this.startNodeAt(startLoc);
|
if (decorators.length) {
|
pp.decorators = decorators;
|
}
|
if (accessibility) pp.accessibility = accessibility;
|
if (readonly) pp.readonly = readonly;
|
if (override) pp.override = override;
|
if (elt.type !== "Identifier" && elt.type !== "AssignmentPattern") {
|
this.raise(TSErrors.UnsupportedParameterPropertyKind, {
|
at: pp
|
});
|
}
|
pp.parameter = elt;
|
return this.finishNode(pp, "TSParameterProperty");
|
}
|
if (decorators.length) {
|
left.decorators = decorators;
|
}
|
return elt;
|
}
|
isSimpleParameter(node) {
|
return node.type === "TSParameterProperty" && super.isSimpleParameter(node.parameter) || super.isSimpleParameter(node);
|
}
|
tsDisallowOptionalPattern(node) {
|
for (const param of node.params) {
|
if (param.type !== "Identifier" && param.optional && !this.state.isAmbientContext) {
|
this.raise(TSErrors.PatternIsOptional, {
|
at: param
|
});
|
}
|
}
|
}
|
setArrowFunctionParameters(node, params, trailingCommaLoc) {
|
super.setArrowFunctionParameters(node, params, trailingCommaLoc);
|
this.tsDisallowOptionalPattern(node);
|
}
|
parseFunctionBodyAndFinish(node, type, isMethod = false) {
|
if (this.match(14)) {
|
node.returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
|
}
|
const bodilessType = type === "FunctionDeclaration" ? "TSDeclareFunction" : type === "ClassMethod" || type === "ClassPrivateMethod" ? "TSDeclareMethod" : undefined;
|
if (bodilessType && !this.match(5) && this.isLineTerminator()) {
|
return this.finishNode(node, bodilessType);
|
}
|
if (bodilessType === "TSDeclareFunction" && this.state.isAmbientContext) {
|
this.raise(TSErrors.DeclareFunctionHasImplementation, {
|
at: node
|
});
|
if (node.declare) {
|
return super.parseFunctionBodyAndFinish(node, bodilessType, isMethod);
|
}
|
}
|
this.tsDisallowOptionalPattern(node);
|
return super.parseFunctionBodyAndFinish(node, type, isMethod);
|
}
|
registerFunctionStatementId(node) {
|
if (!node.body && node.id) {
|
this.checkIdentifier(node.id, BIND_TS_AMBIENT);
|
} else {
|
super.registerFunctionStatementId(node);
|
}
|
}
|
tsCheckForInvalidTypeCasts(items) {
|
items.forEach(node => {
|
if ((node == null ? void 0 : node.type) === "TSTypeCastExpression") {
|
this.raise(TSErrors.UnexpectedTypeAnnotation, {
|
at: node.typeAnnotation
|
});
|
}
|
});
|
}
|
toReferencedList(exprList, isInParens) {
|
this.tsCheckForInvalidTypeCasts(exprList);
|
return exprList;
|
}
|
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
|
const node = super.parseArrayLike(close, canBePattern, isTuple, refExpressionErrors);
|
if (node.type === "ArrayExpression") {
|
this.tsCheckForInvalidTypeCasts(node.elements);
|
}
|
return node;
|
}
|
parseSubscript(base, startLoc, noCalls, state) {
|
if (!this.hasPrecedingLineBreak() && this.match(35)) {
|
this.state.canStartJSXElement = false;
|
this.next();
|
const nonNullExpression = this.startNodeAt(startLoc);
|
nonNullExpression.expression = base;
|
return this.finishNode(nonNullExpression, "TSNonNullExpression");
|
}
|
let isOptionalCall = false;
|
if (this.match(18) && this.lookaheadCharCode() === 60) {
|
if (noCalls) {
|
state.stop = true;
|
return base;
|
}
|
state.optionalChainMember = isOptionalCall = true;
|
this.next();
|
}
|
if (this.match(47) || this.match(51)) {
|
let missingParenErrorLoc;
|
const result = this.tsTryParseAndCatch(() => {
|
if (!noCalls && this.atPossibleAsyncArrow(base)) {
|
const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);
|
if (asyncArrowFn) {
|
return asyncArrowFn;
|
}
|
}
|
const typeArguments = this.tsParseTypeArgumentsInExpression();
|
if (!typeArguments) return;
|
if (isOptionalCall && !this.match(10)) {
|
missingParenErrorLoc = this.state.curPosition();
|
return;
|
}
|
if (tokenIsTemplate(this.state.type)) {
|
const result = super.parseTaggedTemplateExpression(base, startLoc, state);
|
result.typeParameters = typeArguments;
|
return result;
|
}
|
if (!noCalls && this.eat(10)) {
|
const node = this.startNodeAt(startLoc);
|
node.callee = base;
|
node.arguments = this.parseCallExpressionArguments(11, false);
|
this.tsCheckForInvalidTypeCasts(node.arguments);
|
node.typeParameters = typeArguments;
|
if (state.optionalChainMember) {
|
node.optional = isOptionalCall;
|
}
|
return this.finishCallExpression(node, state.optionalChainMember);
|
}
|
const tokenType = this.state.type;
|
if (tokenType === 48 || tokenType === 52 || tokenType !== 10 && tokenCanStartExpression(tokenType) && !this.hasPrecedingLineBreak()) {
|
return;
|
}
|
const node = this.startNodeAt(startLoc);
|
node.expression = base;
|
node.typeParameters = typeArguments;
|
return this.finishNode(node, "TSInstantiationExpression");
|
});
|
if (missingParenErrorLoc) {
|
this.unexpected(missingParenErrorLoc, 10);
|
}
|
if (result) {
|
if (result.type === "TSInstantiationExpression" && (this.match(16) || this.match(18) && this.lookaheadCharCode() !== 40)) {
|
this.raise(TSErrors.InvalidPropertyAccessAfterInstantiationExpression, {
|
at: this.state.startLoc
|
});
|
}
|
return result;
|
}
|
}
|
return super.parseSubscript(base, startLoc, noCalls, state);
|
}
|
parseNewCallee(node) {
|
var _callee$extra;
|
super.parseNewCallee(node);
|
const {
|
callee
|
} = node;
|
if (callee.type === "TSInstantiationExpression" && !((_callee$extra = callee.extra) != null && _callee$extra.parenthesized)) {
|
node.typeParameters = callee.typeParameters;
|
node.callee = callee.expression;
|
}
|
}
|
parseExprOp(left, leftStartLoc, minPrec) {
|
let isSatisfies;
|
if (tokenOperatorPrecedence(58) > minPrec && !this.hasPrecedingLineBreak() && (this.isContextual(93) || (isSatisfies = this.isContextual(118)))) {
|
const node = this.startNodeAt(leftStartLoc);
|
node.expression = left;
|
node.typeAnnotation = this.tsInType(() => {
|
this.next();
|
if (this.match(75)) {
|
if (isSatisfies) {
|
this.raise(Errors.UnexpectedKeyword, {
|
at: this.state.startLoc,
|
keyword: "const"
|
});
|
}
|
return this.tsParseTypeReference();
|
}
|
return this.tsParseType();
|
});
|
this.finishNode(node, isSatisfies ? "TSSatisfiesExpression" : "TSAsExpression");
|
this.reScan_lt_gt();
|
return this.parseExprOp(node, leftStartLoc, minPrec);
|
}
|
return super.parseExprOp(left, leftStartLoc, minPrec);
|
}
|
checkReservedWord(word, startLoc, checkKeywords, isBinding) {
|
if (!this.state.isAmbientContext) {
|
super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
|
}
|
}
|
checkImportReflection(node) {
|
super.checkImportReflection(node);
|
if (node.module && node.importKind !== "value") {
|
this.raise(TSErrors.ImportReflectionHasImportType, {
|
at: node.specifiers[0].loc.start
|
});
|
}
|
}
|
checkDuplicateExports() {}
|
parseImport(node) {
|
node.importKind = "value";
|
if (tokenIsIdentifier(this.state.type) || this.match(55) || this.match(5)) {
|
let ahead = this.lookahead();
|
if (this.isContextual(128) && ahead.type !== 12 && ahead.type !== 97 && ahead.type !== 29) {
|
node.importKind = "type";
|
this.next();
|
ahead = this.lookahead();
|
}
|
if (tokenIsIdentifier(this.state.type) && ahead.type === 29) {
|
return this.tsParseImportEqualsDeclaration(node);
|
}
|
}
|
const importNode = super.parseImport(node);
|
if (importNode.importKind === "type" && importNode.specifiers.length > 1 && importNode.specifiers[0].type === "ImportDefaultSpecifier") {
|
this.raise(TSErrors.TypeImportCannotSpecifyDefaultAndNamed, {
|
at: importNode
|
});
|
}
|
return importNode;
|
}
|
parseExport(node, decorators) {
|
if (this.match(83)) {
|
this.next();
|
if (this.isContextual(128) && this.lookaheadCharCode() !== 61) {
|
node.importKind = "type";
|
this.next();
|
} else {
|
node.importKind = "value";
|
}
|
return this.tsParseImportEqualsDeclaration(node, true);
|
} else if (this.eat(29)) {
|
const assign = node;
|
assign.expression = super.parseExpression();
|
this.semicolon();
|
return this.finishNode(assign, "TSExportAssignment");
|
} else if (this.eatContextual(93)) {
|
const decl = node;
|
this.expectContextual(126);
|
decl.id = this.parseIdentifier();
|
this.semicolon();
|
return this.finishNode(decl, "TSNamespaceExportDeclaration");
|
} else {
|
node.exportKind = "value";
|
if (this.isContextual(128)) {
|
const ch = this.lookaheadCharCode();
|
if (ch === 123 || ch === 42) {
|
this.next();
|
node.exportKind = "type";
|
}
|
}
|
return super.parseExport(node, decorators);
|
}
|
}
|
isAbstractClass() {
|
return this.isContextual(122) && this.lookahead().type === 80;
|
}
|
parseExportDefaultExpression() {
|
if (this.isAbstractClass()) {
|
const cls = this.startNode();
|
this.next();
|
cls.abstract = true;
|
return this.parseClass(cls, true, true);
|
}
|
if (this.match(127)) {
|
const result = this.tsParseInterfaceDeclaration(this.startNode());
|
if (result) return result;
|
}
|
return super.parseExportDefaultExpression();
|
}
|
parseVarStatement(node, kind, allowMissingInitializer = false) {
|
const {
|
isAmbientContext
|
} = this.state;
|
const declaration = super.parseVarStatement(node, kind, allowMissingInitializer || isAmbientContext);
|
if (!isAmbientContext) return declaration;
|
for (const {
|
id,
|
init
|
} of declaration.declarations) {
|
if (!init) continue;
|
if (kind !== "const" || !!id.typeAnnotation) {
|
this.raise(TSErrors.InitializerNotAllowedInAmbientContext, {
|
at: init
|
});
|
} else if (!isValidAmbientConstInitializer(init, this.hasPlugin("estree"))) {
|
this.raise(TSErrors.ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference, {
|
at: init
|
});
|
}
|
}
|
return declaration;
|
}
|
parseStatementContent(flags, decorators) {
|
if (this.match(75) && this.isLookaheadContextual("enum")) {
|
const node = this.startNode();
|
this.expect(75);
|
return this.tsParseEnumDeclaration(node, {
|
const: true
|
});
|
}
|
if (this.isContextual(124)) {
|
return this.tsParseEnumDeclaration(this.startNode());
|
}
|
if (this.isContextual(127)) {
|
const result = this.tsParseInterfaceDeclaration(this.startNode());
|
if (result) return result;
|
}
|
return super.parseStatementContent(flags, decorators);
|
}
|
parseAccessModifier() {
|
return this.tsParseModifier(["public", "protected", "private"]);
|
}
|
tsHasSomeModifiers(member, modifiers) {
|
return modifiers.some(modifier => {
|
if (tsIsAccessModifier(modifier)) {
|
return member.accessibility === modifier;
|
}
|
return !!member[modifier];
|
});
|
}
|
tsIsStartOfStaticBlocks() {
|
return this.isContextual(104) && this.lookaheadCharCode() === 123;
|
}
|
parseClassMember(classBody, member, state) {
|
const modifiers = ["declare", "private", "public", "protected", "override", "abstract", "readonly", "static"];
|
this.tsParseModifiers({
|
allowedModifiers: modifiers,
|
disallowedModifiers: ["in", "out"],
|
stopOnStartOfClassStaticBlock: true,
|
errorTemplate: TSErrors.InvalidModifierOnTypeParameterPositions
|
}, member);
|
const callParseClassMemberWithIsStatic = () => {
|
if (this.tsIsStartOfStaticBlocks()) {
|
this.next();
|
this.next();
|
if (this.tsHasSomeModifiers(member, modifiers)) {
|
this.raise(TSErrors.StaticBlockCannotHaveModifier, {
|
at: this.state.curPosition()
|
});
|
}
|
super.parseClassStaticBlock(classBody, member);
|
} else {
|
this.parseClassMemberWithIsStatic(classBody, member, state, !!member.static);
|
}
|
};
|
if (member.declare) {
|
this.tsInAmbientContext(callParseClassMemberWithIsStatic);
|
} else {
|
callParseClassMemberWithIsStatic();
|
}
|
}
|
parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
|
const idx = this.tsTryParseIndexSignature(member);
|
if (idx) {
|
classBody.body.push(idx);
|
if (member.abstract) {
|
this.raise(TSErrors.IndexSignatureHasAbstract, {
|
at: member
|
});
|
}
|
if (member.accessibility) {
|
this.raise(TSErrors.IndexSignatureHasAccessibility, {
|
at: member,
|
modifier: member.accessibility
|
});
|
}
|
if (member.declare) {
|
this.raise(TSErrors.IndexSignatureHasDeclare, {
|
at: member
|
});
|
}
|
if (member.override) {
|
this.raise(TSErrors.IndexSignatureHasOverride, {
|
at: member
|
});
|
}
|
return;
|
}
|
if (!this.state.inAbstractClass && member.abstract) {
|
this.raise(TSErrors.NonAbstractClassHasAbstractMethod, {
|
at: member
|
});
|
}
|
if (member.override) {
|
if (!state.hadSuperClass) {
|
this.raise(TSErrors.OverrideNotInSubClass, {
|
at: member
|
});
|
}
|
}
|
super.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
|
}
|
parsePostMemberNameModifiers(methodOrProp) {
|
const optional = this.eat(17);
|
if (optional) methodOrProp.optional = true;
|
if (methodOrProp.readonly && this.match(10)) {
|
this.raise(TSErrors.ClassMethodHasReadonly, {
|
at: methodOrProp
|
});
|
}
|
if (methodOrProp.declare && this.match(10)) {
|
this.raise(TSErrors.ClassMethodHasDeclare, {
|
at: methodOrProp
|
});
|
}
|
}
|
parseExpressionStatement(node, expr, decorators) {
|
const decl = expr.type === "Identifier" ? this.tsParseExpressionStatement(node, expr, decorators) : undefined;
|
return decl || super.parseExpressionStatement(node, expr, decorators);
|
}
|
shouldParseExportDeclaration() {
|
if (this.tsIsDeclarationStart()) return true;
|
return super.shouldParseExportDeclaration();
|
}
|
parseConditional(expr, startLoc, refExpressionErrors) {
|
if (!this.state.maybeInArrowParameters || !this.match(17)) {
|
return super.parseConditional(expr, startLoc, refExpressionErrors);
|
}
|
const result = this.tryParse(() => super.parseConditional(expr, startLoc));
|
if (!result.node) {
|
if (result.error) {
|
super.setOptionalParametersError(refExpressionErrors, result.error);
|
}
|
return expr;
|
}
|
if (result.error) this.state = result.failState;
|
return result.node;
|
}
|
parseParenItem(node, startLoc) {
|
node = super.parseParenItem(node, startLoc);
|
if (this.eat(17)) {
|
node.optional = true;
|
this.resetEndLocation(node);
|
}
|
if (this.match(14)) {
|
const typeCastNode = this.startNodeAt(startLoc);
|
typeCastNode.expression = node;
|
typeCastNode.typeAnnotation = this.tsParseTypeAnnotation();
|
return this.finishNode(typeCastNode, "TSTypeCastExpression");
|
}
|
return node;
|
}
|
parseExportDeclaration(node) {
|
if (!this.state.isAmbientContext && this.isContextual(123)) {
|
return this.tsInAmbientContext(() => this.parseExportDeclaration(node));
|
}
|
const startLoc = this.state.startLoc;
|
const isDeclare = this.eatContextual(123);
|
if (isDeclare && (this.isContextual(123) || !this.shouldParseExportDeclaration())) {
|
throw this.raise(TSErrors.ExpectedAmbientAfterExportDeclare, {
|
at: this.state.startLoc
|
});
|
}
|
const isIdentifier = tokenIsIdentifier(this.state.type);
|
const declaration = isIdentifier && this.tsTryParseExportDeclaration() || super.parseExportDeclaration(node);
|
if (!declaration) return null;
|
if (declaration.type === "TSInterfaceDeclaration" || declaration.type === "TSTypeAliasDeclaration" || isDeclare) {
|
node.exportKind = "type";
|
}
|
if (isDeclare) {
|
this.resetStartLocation(declaration, startLoc);
|
declaration.declare = true;
|
}
|
return declaration;
|
}
|
parseClassId(node, isStatement, optionalId, bindingType) {
|
if ((!isStatement || optionalId) && this.isContextual(111)) {
|
return;
|
}
|
super.parseClassId(node, isStatement, optionalId, node.declare ? BIND_TS_AMBIENT : BIND_CLASS);
|
const typeParameters = this.tsTryParseTypeParameters(this.tsParseInOutConstModifiers);
|
if (typeParameters) node.typeParameters = typeParameters;
|
}
|
parseClassPropertyAnnotation(node) {
|
if (!node.optional) {
|
if (this.eat(35)) {
|
node.definite = true;
|
} else if (this.eat(17)) {
|
node.optional = true;
|
}
|
}
|
const type = this.tsTryParseTypeAnnotation();
|
if (type) node.typeAnnotation = type;
|
}
|
parseClassProperty(node) {
|
this.parseClassPropertyAnnotation(node);
|
if (this.state.isAmbientContext && !(node.readonly && !node.typeAnnotation) && this.match(29)) {
|
this.raise(TSErrors.DeclareClassFieldHasInitializer, {
|
at: this.state.startLoc
|
});
|
}
|
if (node.abstract && this.match(29)) {
|
const {
|
key
|
} = node;
|
this.raise(TSErrors.AbstractPropertyHasInitializer, {
|
at: this.state.startLoc,
|
propertyName: key.type === "Identifier" && !node.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
|
});
|
}
|
return super.parseClassProperty(node);
|
}
|
parseClassPrivateProperty(node) {
|
if (node.abstract) {
|
this.raise(TSErrors.PrivateElementHasAbstract, {
|
at: node
|
});
|
}
|
if (node.accessibility) {
|
this.raise(TSErrors.PrivateElementHasAccessibility, {
|
at: node,
|
modifier: node.accessibility
|
});
|
}
|
this.parseClassPropertyAnnotation(node);
|
return super.parseClassPrivateProperty(node);
|
}
|
parseClassAccessorProperty(node) {
|
this.parseClassPropertyAnnotation(node);
|
if (node.optional) {
|
this.raise(TSErrors.AccessorCannotBeOptional, {
|
at: node
|
});
|
}
|
return super.parseClassAccessorProperty(node);
|
}
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
|
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
|
if (typeParameters && isConstructor) {
|
this.raise(TSErrors.ConstructorHasTypeParameters, {
|
at: typeParameters
|
});
|
}
|
const {
|
declare = false,
|
kind
|
} = method;
|
if (declare && (kind === "get" || kind === "set")) {
|
this.raise(TSErrors.DeclareAccessor, {
|
at: method,
|
kind
|
});
|
}
|
if (typeParameters) method.typeParameters = typeParameters;
|
super.pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper);
|
}
|
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
|
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
|
if (typeParameters) method.typeParameters = typeParameters;
|
super.pushClassPrivateMethod(classBody, method, isGenerator, isAsync);
|
}
|
declareClassPrivateMethodInScope(node, kind) {
|
if (node.type === "TSDeclareMethod") return;
|
if (node.type === "MethodDefinition" && !node.value.body) return;
|
super.declareClassPrivateMethodInScope(node, kind);
|
}
|
parseClassSuper(node) {
|
super.parseClassSuper(node);
|
if (node.superClass && (this.match(47) || this.match(51))) {
|
node.superTypeParameters = this.tsParseTypeArgumentsInExpression();
|
}
|
if (this.eatContextual(111)) {
|
node.implements = this.tsParseHeritageClause("implements");
|
}
|
}
|
parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
|
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
|
if (typeParameters) prop.typeParameters = typeParameters;
|
return super.parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors);
|
}
|
parseFunctionParams(node, isConstructor) {
|
const typeParameters = this.tsTryParseTypeParameters(this.tsParseConstModifier);
|
if (typeParameters) node.typeParameters = typeParameters;
|
super.parseFunctionParams(node, isConstructor);
|
}
|
parseVarId(decl, kind) {
|
super.parseVarId(decl, kind);
|
if (decl.id.type === "Identifier" && !this.hasPrecedingLineBreak() && this.eat(35)) {
|
decl.definite = true;
|
}
|
const type = this.tsTryParseTypeAnnotation();
|
if (type) {
|
decl.id.typeAnnotation = type;
|
this.resetEndLocation(decl.id);
|
}
|
}
|
parseAsyncArrowFromCallExpression(node, call) {
|
if (this.match(14)) {
|
node.returnType = this.tsParseTypeAnnotation();
|
}
|
return super.parseAsyncArrowFromCallExpression(node, call);
|
}
|
parseMaybeAssign(refExpressionErrors, afterLeftParse) {
|
var _jsx, _jsx2, _typeCast, _jsx3, _typeCast2, _jsx4, _typeCast3;
|
let state;
|
let jsx;
|
let typeCast;
|
if (this.hasPlugin("jsx") && (this.match(140) || this.match(47))) {
|
state = this.state.clone();
|
jsx = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
|
if (!jsx.error) return jsx.node;
|
const {
|
context
|
} = this.state;
|
const currentContext = context[context.length - 1];
|
if (currentContext === types$1.j_oTag || currentContext === types$1.j_expr) {
|
context.pop();
|
}
|
}
|
if (!((_jsx = jsx) != null && _jsx.error) && !this.match(47)) {
|
return super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
|
}
|
if (!state || state === this.state) state = this.state.clone();
|
let typeParameters;
|
const arrow = this.tryParse(abort => {
|
var _expr$extra, _typeParameters;
|
typeParameters = this.tsParseTypeParameters(this.tsParseConstModifier);
|
const expr = super.parseMaybeAssign(refExpressionErrors, afterLeftParse);
|
if (expr.type !== "ArrowFunctionExpression" || (_expr$extra = expr.extra) != null && _expr$extra.parenthesized) {
|
abort();
|
}
|
if (((_typeParameters = typeParameters) == null ? void 0 : _typeParameters.params.length) !== 0) {
|
this.resetStartLocationFromNode(expr, typeParameters);
|
}
|
expr.typeParameters = typeParameters;
|
return expr;
|
}, state);
|
if (!arrow.error && !arrow.aborted) {
|
if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
|
return arrow.node;
|
}
|
if (!jsx) {
|
assert$1(!this.hasPlugin("jsx"));
|
typeCast = this.tryParse(() => super.parseMaybeAssign(refExpressionErrors, afterLeftParse), state);
|
if (!typeCast.error) return typeCast.node;
|
}
|
if ((_jsx2 = jsx) != null && _jsx2.node) {
|
this.state = jsx.failState;
|
return jsx.node;
|
}
|
if (arrow.node) {
|
this.state = arrow.failState;
|
if (typeParameters) this.reportReservedArrowTypeParam(typeParameters);
|
return arrow.node;
|
}
|
if ((_typeCast = typeCast) != null && _typeCast.node) {
|
this.state = typeCast.failState;
|
return typeCast.node;
|
}
|
if ((_jsx3 = jsx) != null && _jsx3.thrown) throw jsx.error;
|
if (arrow.thrown) throw arrow.error;
|
if ((_typeCast2 = typeCast) != null && _typeCast2.thrown) throw typeCast.error;
|
throw ((_jsx4 = jsx) == null ? void 0 : _jsx4.error) || arrow.error || ((_typeCast3 = typeCast) == null ? void 0 : _typeCast3.error);
|
}
|
reportReservedArrowTypeParam(node) {
|
var _node$extra;
|
if (node.params.length === 1 && !node.params[0].constraint && !((_node$extra = node.extra) != null && _node$extra.trailingComma) && this.getPluginOption("typescript", "disallowAmbiguousJSXLike")) {
|
this.raise(TSErrors.ReservedArrowTypeParam, {
|
at: node
|
});
|
}
|
}
|
parseMaybeUnary(refExpressionErrors, sawUnary) {
|
if (!this.hasPlugin("jsx") && this.match(47)) {
|
return this.tsParseTypeAssertion();
|
} else {
|
return super.parseMaybeUnary(refExpressionErrors, sawUnary);
|
}
|
}
|
parseArrow(node) {
|
if (this.match(14)) {
|
const result = this.tryParse(abort => {
|
const returnType = this.tsParseTypeOrTypePredicateAnnotation(14);
|
if (this.canInsertSemicolon() || !this.match(19)) abort();
|
return returnType;
|
});
|
if (result.aborted) return;
|
if (!result.thrown) {
|
if (result.error) this.state = result.failState;
|
node.returnType = result.node;
|
}
|
}
|
return super.parseArrow(node);
|
}
|
parseAssignableListItemTypes(param, flags) {
|
if (!(flags & 2)) return param;
|
if (this.eat(17)) {
|
param.optional = true;
|
}
|
const type = this.tsTryParseTypeAnnotation();
|
if (type) param.typeAnnotation = type;
|
this.resetEndLocation(param);
|
return param;
|
}
|
isAssignable(node, isBinding) {
|
switch (node.type) {
|
case "TSTypeCastExpression":
|
return this.isAssignable(node.expression, isBinding);
|
case "TSParameterProperty":
|
return true;
|
default:
|
return super.isAssignable(node, isBinding);
|
}
|
}
|
toAssignable(node, isLHS = false) {
|
switch (node.type) {
|
case "ParenthesizedExpression":
|
this.toAssignableParenthesizedExpression(node, isLHS);
|
break;
|
case "TSAsExpression":
|
case "TSSatisfiesExpression":
|
case "TSNonNullExpression":
|
case "TSTypeAssertion":
|
if (isLHS) {
|
this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
|
at: node
|
});
|
} else {
|
this.raise(TSErrors.UnexpectedTypeCastInParameter, {
|
at: node
|
});
|
}
|
this.toAssignable(node.expression, isLHS);
|
break;
|
case "AssignmentExpression":
|
if (!isLHS && node.left.type === "TSTypeCastExpression") {
|
node.left = this.typeCastToParameter(node.left);
|
}
|
default:
|
super.toAssignable(node, isLHS);
|
}
|
}
|
toAssignableParenthesizedExpression(node, isLHS) {
|
switch (node.expression.type) {
|
case "TSAsExpression":
|
case "TSSatisfiesExpression":
|
case "TSNonNullExpression":
|
case "TSTypeAssertion":
|
case "ParenthesizedExpression":
|
this.toAssignable(node.expression, isLHS);
|
break;
|
default:
|
super.toAssignable(node, isLHS);
|
}
|
}
|
checkToRestConversion(node, allowPattern) {
|
switch (node.type) {
|
case "TSAsExpression":
|
case "TSSatisfiesExpression":
|
case "TSTypeAssertion":
|
case "TSNonNullExpression":
|
this.checkToRestConversion(node.expression, false);
|
break;
|
default:
|
super.checkToRestConversion(node, allowPattern);
|
}
|
}
|
isValidLVal(type, isUnparenthesizedInAssign, binding) {
|
return getOwn({
|
TSTypeCastExpression: true,
|
TSParameterProperty: "parameter",
|
TSNonNullExpression: "expression",
|
TSAsExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
|
TSSatisfiesExpression: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true],
|
TSTypeAssertion: (binding !== BIND_NONE || !isUnparenthesizedInAssign) && ["expression", true]
|
}, type) || super.isValidLVal(type, isUnparenthesizedInAssign, binding);
|
}
|
parseBindingAtom() {
|
switch (this.state.type) {
|
case 78:
|
return this.parseIdentifier(true);
|
default:
|
return super.parseBindingAtom();
|
}
|
}
|
parseMaybeDecoratorArguments(expr) {
|
if (this.match(47) || this.match(51)) {
|
const typeArguments = this.tsParseTypeArgumentsInExpression();
|
if (this.match(10)) {
|
const call = super.parseMaybeDecoratorArguments(expr);
|
call.typeParameters = typeArguments;
|
return call;
|
}
|
this.unexpected(null, 10);
|
}
|
return super.parseMaybeDecoratorArguments(expr);
|
}
|
checkCommaAfterRest(close) {
|
if (this.state.isAmbientContext && this.match(12) && this.lookaheadCharCode() === close) {
|
this.next();
|
return false;
|
} else {
|
return super.checkCommaAfterRest(close);
|
}
|
}
|
isClassMethod() {
|
return this.match(47) || super.isClassMethod();
|
}
|
isClassProperty() {
|
return this.match(35) || this.match(14) || super.isClassProperty();
|
}
|
parseMaybeDefault(startLoc, left) {
|
const node = super.parseMaybeDefault(startLoc, left);
|
if (node.type === "AssignmentPattern" && node.typeAnnotation && node.right.start < node.typeAnnotation.start) {
|
this.raise(TSErrors.TypeAnnotationAfterAssign, {
|
at: node.typeAnnotation
|
});
|
}
|
return node;
|
}
|
getTokenFromCode(code) {
|
if (this.state.inType) {
|
if (code === 62) {
|
this.finishOp(48, 1);
|
return;
|
}
|
if (code === 60) {
|
this.finishOp(47, 1);
|
return;
|
}
|
}
|
super.getTokenFromCode(code);
|
}
|
reScan_lt_gt() {
|
const {
|
type
|
} = this.state;
|
if (type === 47) {
|
this.state.pos -= 1;
|
this.readToken_lt();
|
} else if (type === 48) {
|
this.state.pos -= 1;
|
this.readToken_gt();
|
}
|
}
|
reScan_lt() {
|
const {
|
type
|
} = this.state;
|
if (type === 51) {
|
this.state.pos -= 2;
|
this.finishOp(47, 1);
|
return 47;
|
}
|
return type;
|
}
|
toAssignableList(exprList, trailingCommaLoc, isLHS) {
|
for (let i = 0; i < exprList.length; i++) {
|
const expr = exprList[i];
|
if ((expr == null ? void 0 : expr.type) === "TSTypeCastExpression") {
|
exprList[i] = this.typeCastToParameter(expr);
|
}
|
}
|
super.toAssignableList(exprList, trailingCommaLoc, isLHS);
|
}
|
typeCastToParameter(node) {
|
node.expression.typeAnnotation = node.typeAnnotation;
|
this.resetEndLocation(node.expression, node.typeAnnotation.loc.end);
|
return node.expression;
|
}
|
shouldParseArrow(params) {
|
if (this.match(14)) {
|
return params.every(expr => this.isAssignable(expr, true));
|
}
|
return super.shouldParseArrow(params);
|
}
|
shouldParseAsyncArrow() {
|
return this.match(14) || super.shouldParseAsyncArrow();
|
}
|
canHaveLeadingDecorator() {
|
return super.canHaveLeadingDecorator() || this.isAbstractClass();
|
}
|
jsxParseOpeningElementAfterName(node) {
|
if (this.match(47) || this.match(51)) {
|
const typeArguments = this.tsTryParseAndCatch(() => this.tsParseTypeArgumentsInExpression());
|
if (typeArguments) node.typeParameters = typeArguments;
|
}
|
return super.jsxParseOpeningElementAfterName(node);
|
}
|
getGetterSetterExpectedParamCount(method) {
|
const baseCount = super.getGetterSetterExpectedParamCount(method);
|
const params = this.getObjectOrClassMethodParams(method);
|
const firstParam = params[0];
|
const hasContextParam = firstParam && this.isThisParam(firstParam);
|
return hasContextParam ? baseCount + 1 : baseCount;
|
}
|
parseCatchClauseParam() {
|
const param = super.parseCatchClauseParam();
|
const type = this.tsTryParseTypeAnnotation();
|
if (type) {
|
param.typeAnnotation = type;
|
this.resetEndLocation(param);
|
}
|
return param;
|
}
|
tsInAmbientContext(cb) {
|
const oldIsAmbientContext = this.state.isAmbientContext;
|
this.state.isAmbientContext = true;
|
try {
|
return cb();
|
} finally {
|
this.state.isAmbientContext = oldIsAmbientContext;
|
}
|
}
|
parseClass(node, isStatement, optionalId) {
|
const oldInAbstractClass = this.state.inAbstractClass;
|
this.state.inAbstractClass = !!node.abstract;
|
try {
|
return super.parseClass(node, isStatement, optionalId);
|
} finally {
|
this.state.inAbstractClass = oldInAbstractClass;
|
}
|
}
|
tsParseAbstractDeclaration(node, decorators) {
|
if (this.match(80)) {
|
node.abstract = true;
|
return this.maybeTakeDecorators(decorators, this.parseClass(node, true, false));
|
} else if (this.isContextual(127)) {
|
if (!this.hasFollowingLineBreak()) {
|
node.abstract = true;
|
this.raise(TSErrors.NonClassMethodPropertyHasAbstractModifer, {
|
at: node
|
});
|
return this.tsParseInterfaceDeclaration(node);
|
}
|
} else {
|
this.unexpected(null, 80);
|
}
|
}
|
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope) {
|
const method = super.parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope);
|
if (method.abstract) {
|
const hasBody = this.hasPlugin("estree") ? !!method.value.body : !!method.body;
|
if (hasBody) {
|
const {
|
key
|
} = method;
|
this.raise(TSErrors.AbstractMethodHasImplementation, {
|
at: method,
|
methodName: key.type === "Identifier" && !method.computed ? key.name : `[${this.input.slice(key.start, key.end)}]`
|
});
|
}
|
}
|
return method;
|
}
|
tsParseTypeParameterName() {
|
const typeName = this.parseIdentifier();
|
return typeName.name;
|
}
|
shouldParseAsAmbientContext() {
|
return !!this.getPluginOption("typescript", "dts");
|
}
|
parse() {
|
if (this.shouldParseAsAmbientContext()) {
|
this.state.isAmbientContext = true;
|
}
|
return super.parse();
|
}
|
getExpression() {
|
if (this.shouldParseAsAmbientContext()) {
|
this.state.isAmbientContext = true;
|
}
|
return super.getExpression();
|
}
|
parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
|
if (!isString && isMaybeTypeOnly) {
|
this.parseTypeOnlyImportExportSpecifier(node, false, isInTypeExport);
|
return this.finishNode(node, "ExportSpecifier");
|
}
|
node.exportKind = "value";
|
return super.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly);
|
}
|
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
|
if (!importedIsString && isMaybeTypeOnly) {
|
this.parseTypeOnlyImportExportSpecifier(specifier, true, isInTypeOnlyImport);
|
return this.finishNode(specifier, "ImportSpecifier");
|
}
|
specifier.importKind = "value";
|
return super.parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, isInTypeOnlyImport ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
|
}
|
parseTypeOnlyImportExportSpecifier(node, isImport, isInTypeOnlyImportExport) {
|
const leftOfAsKey = isImport ? "imported" : "local";
|
const rightOfAsKey = isImport ? "local" : "exported";
|
let leftOfAs = node[leftOfAsKey];
|
let rightOfAs;
|
let hasTypeSpecifier = false;
|
let canParseAsKeyword = true;
|
const loc = leftOfAs.loc.start;
|
if (this.isContextual(93)) {
|
const firstAs = this.parseIdentifier();
|
if (this.isContextual(93)) {
|
const secondAs = this.parseIdentifier();
|
if (tokenIsKeywordOrIdentifier(this.state.type)) {
|
hasTypeSpecifier = true;
|
leftOfAs = firstAs;
|
rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
|
canParseAsKeyword = false;
|
} else {
|
rightOfAs = secondAs;
|
canParseAsKeyword = false;
|
}
|
} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
|
canParseAsKeyword = false;
|
rightOfAs = isImport ? this.parseIdentifier() : this.parseModuleExportName();
|
} else {
|
hasTypeSpecifier = true;
|
leftOfAs = firstAs;
|
}
|
} else if (tokenIsKeywordOrIdentifier(this.state.type)) {
|
hasTypeSpecifier = true;
|
if (isImport) {
|
leftOfAs = this.parseIdentifier(true);
|
if (!this.isContextual(93)) {
|
this.checkReservedWord(leftOfAs.name, leftOfAs.loc.start, true, true);
|
}
|
} else {
|
leftOfAs = this.parseModuleExportName();
|
}
|
}
|
if (hasTypeSpecifier && isInTypeOnlyImportExport) {
|
this.raise(isImport ? TSErrors.TypeModifierIsUsedInTypeImports : TSErrors.TypeModifierIsUsedInTypeExports, {
|
at: loc
|
});
|
}
|
node[leftOfAsKey] = leftOfAs;
|
node[rightOfAsKey] = rightOfAs;
|
const kindKey = isImport ? "importKind" : "exportKind";
|
node[kindKey] = hasTypeSpecifier ? "type" : "value";
|
if (canParseAsKeyword && this.eatContextual(93)) {
|
node[rightOfAsKey] = isImport ? this.parseIdentifier() : this.parseModuleExportName();
|
}
|
if (!node[rightOfAsKey]) {
|
node[rightOfAsKey] = cloneIdentifier(node[leftOfAsKey]);
|
}
|
if (isImport) {
|
this.checkIdentifier(node[rightOfAsKey], hasTypeSpecifier ? BIND_TS_TYPE_IMPORT : BIND_FLAGS_TS_IMPORT);
|
}
|
}
|
};
|
function isPossiblyLiteralEnum(expression) {
|
if (expression.type !== "MemberExpression") return false;
|
const {
|
computed,
|
property
|
} = expression;
|
if (computed && property.type !== "StringLiteral" && (property.type !== "TemplateLiteral" || property.expressions.length > 0)) {
|
return false;
|
}
|
return isUncomputedMemberExpressionChain(expression.object);
|
}
|
function isValidAmbientConstInitializer(expression, estree) {
|
var _expression$extra;
|
const {
|
type
|
} = expression;
|
if ((_expression$extra = expression.extra) != null && _expression$extra.parenthesized) {
|
return false;
|
}
|
if (estree) {
|
if (type === "Literal") {
|
const {
|
value
|
} = expression;
|
if (typeof value === "string" || typeof value === "boolean") {
|
return true;
|
}
|
}
|
} else {
|
if (type === "StringLiteral" || type === "BooleanLiteral") {
|
return true;
|
}
|
}
|
if (isNumber$1(expression, estree) || isNegativeNumber(expression, estree)) {
|
return true;
|
}
|
if (type === "TemplateLiteral" && expression.expressions.length === 0) {
|
return true;
|
}
|
if (isPossiblyLiteralEnum(expression)) {
|
return true;
|
}
|
return false;
|
}
|
function isNumber$1(expression, estree) {
|
if (estree) {
|
return expression.type === "Literal" && (typeof expression.value === "number" || "bigint" in expression);
|
} else {
|
return expression.type === "NumericLiteral" || expression.type === "BigIntLiteral";
|
}
|
}
|
function isNegativeNumber(expression, estree) {
|
if (expression.type === "UnaryExpression") {
|
const {
|
operator,
|
argument
|
} = expression;
|
if (operator === "-" && isNumber$1(argument, estree)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
function isUncomputedMemberExpressionChain(expression) {
|
if (expression.type === "Identifier") return true;
|
if (expression.type !== "MemberExpression") return false;
|
if (expression.computed) return false;
|
return isUncomputedMemberExpressionChain(expression.object);
|
}
|
const PlaceholderErrors = ParseErrorEnum`placeholders`({
|
ClassNameIsRequired: "A class name is required.",
|
UnexpectedSpace: "Unexpected space in placeholder."
|
});
|
var placeholders = superClass => class PlaceholdersParserMixin extends superClass {
|
parsePlaceholder(expectedNode) {
|
if (this.match(142)) {
|
const node = this.startNode();
|
this.next();
|
this.assertNoSpace();
|
node.name = super.parseIdentifier(true);
|
this.assertNoSpace();
|
this.expect(142);
|
return this.finishPlaceholder(node, expectedNode);
|
}
|
}
|
finishPlaceholder(node, expectedNode) {
|
const isFinished = !!(node.expectedNode && node.type === "Placeholder");
|
node.expectedNode = expectedNode;
|
return isFinished ? node : this.finishNode(node, "Placeholder");
|
}
|
getTokenFromCode(code) {
|
if (code === 37 && this.input.charCodeAt(this.state.pos + 1) === 37) {
|
this.finishOp(142, 2);
|
} else {
|
super.getTokenFromCode(code);
|
}
|
}
|
parseExprAtom(refExpressionErrors) {
|
return this.parsePlaceholder("Expression") || super.parseExprAtom(refExpressionErrors);
|
}
|
parseIdentifier(liberal) {
|
return this.parsePlaceholder("Identifier") || super.parseIdentifier(liberal);
|
}
|
checkReservedWord(word, startLoc, checkKeywords, isBinding) {
|
if (word !== undefined) {
|
super.checkReservedWord(word, startLoc, checkKeywords, isBinding);
|
}
|
}
|
parseBindingAtom() {
|
return this.parsePlaceholder("Pattern") || super.parseBindingAtom();
|
}
|
isValidLVal(type, isParenthesized, binding) {
|
return type === "Placeholder" || super.isValidLVal(type, isParenthesized, binding);
|
}
|
toAssignable(node, isLHS) {
|
if (node && node.type === "Placeholder" && node.expectedNode === "Expression") {
|
node.expectedNode = "Pattern";
|
} else {
|
super.toAssignable(node, isLHS);
|
}
|
}
|
chStartsBindingIdentifier(ch, pos) {
|
if (super.chStartsBindingIdentifier(ch, pos)) {
|
return true;
|
}
|
const nextToken = this.lookahead();
|
if (nextToken.type === 142) {
|
return true;
|
}
|
return false;
|
}
|
verifyBreakContinue(node, isBreak) {
|
if (node.label && node.label.type === "Placeholder") return;
|
super.verifyBreakContinue(node, isBreak);
|
}
|
parseExpressionStatement(node, expr) {
|
if (expr.type !== "Placeholder" || expr.extra && expr.extra.parenthesized) {
|
return super.parseExpressionStatement(node, expr);
|
}
|
if (this.match(14)) {
|
const stmt = node;
|
stmt.label = this.finishPlaceholder(expr, "Identifier");
|
this.next();
|
stmt.body = super.parseStatementOrSloppyAnnexBFunctionDeclaration();
|
return this.finishNode(stmt, "LabeledStatement");
|
}
|
this.semicolon();
|
node.name = expr.name;
|
return this.finishPlaceholder(node, "Statement");
|
}
|
parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse) {
|
return this.parsePlaceholder("BlockStatement") || super.parseBlock(allowDirectives, createNewLexicalScope, afterBlockParse);
|
}
|
parseFunctionId(requireId) {
|
return this.parsePlaceholder("Identifier") || super.parseFunctionId(requireId);
|
}
|
parseClass(node, isStatement, optionalId) {
|
const type = isStatement ? "ClassDeclaration" : "ClassExpression";
|
this.next();
|
const oldStrict = this.state.strict;
|
const placeholder = this.parsePlaceholder("Identifier");
|
if (placeholder) {
|
if (this.match(81) || this.match(142) || this.match(5)) {
|
node.id = placeholder;
|
} else if (optionalId || !isStatement) {
|
node.id = null;
|
node.body = this.finishPlaceholder(placeholder, "ClassBody");
|
return this.finishNode(node, type);
|
} else {
|
throw this.raise(PlaceholderErrors.ClassNameIsRequired, {
|
at: this.state.startLoc
|
});
|
}
|
} else {
|
this.parseClassId(node, isStatement, optionalId);
|
}
|
super.parseClassSuper(node);
|
node.body = this.parsePlaceholder("ClassBody") || super.parseClassBody(!!node.superClass, oldStrict);
|
return this.finishNode(node, type);
|
}
|
parseExport(node, decorators) {
|
const placeholder = this.parsePlaceholder("Identifier");
|
if (!placeholder) return super.parseExport(node, decorators);
|
if (!this.isContextual(97) && !this.match(12)) {
|
node.specifiers = [];
|
node.source = null;
|
node.declaration = this.finishPlaceholder(placeholder, "Declaration");
|
return this.finishNode(node, "ExportNamedDeclaration");
|
}
|
this.expectPlugin("exportDefaultFrom");
|
const specifier = this.startNode();
|
specifier.exported = placeholder;
|
node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
|
return super.parseExport(node, decorators);
|
}
|
isExportDefaultSpecifier() {
|
if (this.match(65)) {
|
const next = this.nextTokenStart();
|
if (this.isUnparsedContextual(next, "from")) {
|
if (this.input.startsWith(tokenLabelName(142), this.nextTokenStartSince(next + 4))) {
|
return true;
|
}
|
}
|
}
|
return super.isExportDefaultSpecifier();
|
}
|
maybeParseExportDefaultSpecifier(node) {
|
if (node.specifiers && node.specifiers.length > 0) {
|
return true;
|
}
|
return super.maybeParseExportDefaultSpecifier(node);
|
}
|
checkExport(node) {
|
const {
|
specifiers
|
} = node;
|
if (specifiers != null && specifiers.length) {
|
node.specifiers = specifiers.filter(node => node.exported.type === "Placeholder");
|
}
|
super.checkExport(node);
|
node.specifiers = specifiers;
|
}
|
parseImport(node) {
|
const placeholder = this.parsePlaceholder("Identifier");
|
if (!placeholder) return super.parseImport(node);
|
node.specifiers = [];
|
if (!this.isContextual(97) && !this.match(12)) {
|
node.source = this.finishPlaceholder(placeholder, "StringLiteral");
|
this.semicolon();
|
return this.finishNode(node, "ImportDeclaration");
|
}
|
const specifier = this.startNodeAtNode(placeholder);
|
specifier.local = placeholder;
|
node.specifiers.push(this.finishNode(specifier, "ImportDefaultSpecifier"));
|
if (this.eat(12)) {
|
const hasStarImport = this.maybeParseStarImportSpecifier(node);
|
if (!hasStarImport) this.parseNamedImportSpecifiers(node);
|
}
|
this.expectContextual(97);
|
node.source = this.parseImportSource();
|
this.semicolon();
|
return this.finishNode(node, "ImportDeclaration");
|
}
|
parseImportSource() {
|
return this.parsePlaceholder("StringLiteral") || super.parseImportSource();
|
}
|
assertNoSpace() {
|
if (this.state.start > this.state.lastTokEndLoc.index) {
|
this.raise(PlaceholderErrors.UnexpectedSpace, {
|
at: this.state.lastTokEndLoc
|
});
|
}
|
}
|
};
|
var v8intrinsic = superClass => class V8IntrinsicMixin extends superClass {
|
parseV8Intrinsic() {
|
if (this.match(54)) {
|
const v8IntrinsicStartLoc = this.state.startLoc;
|
const node = this.startNode();
|
this.next();
|
if (tokenIsIdentifier(this.state.type)) {
|
const name = this.parseIdentifierName();
|
const identifier = this.createIdentifier(node, name);
|
identifier.type = "V8IntrinsicIdentifier";
|
if (this.match(10)) {
|
return identifier;
|
}
|
}
|
this.unexpected(v8IntrinsicStartLoc);
|
}
|
}
|
parseExprAtom(refExpressionErrors) {
|
return this.parseV8Intrinsic() || super.parseExprAtom(refExpressionErrors);
|
}
|
};
|
function hasPlugin(plugins, expectedConfig) {
|
const [expectedName, expectedOptions] = typeof expectedConfig === "string" ? [expectedConfig, {}] : expectedConfig;
|
const expectedKeys = Object.keys(expectedOptions);
|
const expectedOptionsIsEmpty = expectedKeys.length === 0;
|
return plugins.some(p => {
|
if (typeof p === "string") {
|
return expectedOptionsIsEmpty && p === expectedName;
|
} else {
|
const [pluginName, pluginOptions] = p;
|
if (pluginName !== expectedName) {
|
return false;
|
}
|
for (const key of expectedKeys) {
|
if (pluginOptions[key] !== expectedOptions[key]) {
|
return false;
|
}
|
}
|
return true;
|
}
|
});
|
}
|
function getPluginOption(plugins, name, option) {
|
const plugin = plugins.find(plugin => {
|
if (Array.isArray(plugin)) {
|
return plugin[0] === name;
|
} else {
|
return plugin === name;
|
}
|
});
|
if (plugin && Array.isArray(plugin) && plugin.length > 1) {
|
return plugin[1][option];
|
}
|
return null;
|
}
|
const PIPELINE_PROPOSALS = ["minimal", "fsharp", "hack", "smart"];
|
const TOPIC_TOKENS = ["^^", "@@", "^", "%", "#"];
|
const RECORD_AND_TUPLE_SYNTAX_TYPES = ["hash", "bar"];
|
function validatePlugins(plugins) {
|
if (hasPlugin(plugins, "decorators")) {
|
if (hasPlugin(plugins, "decorators-legacy")) {
|
throw new Error("Cannot use the decorators and decorators-legacy plugin together");
|
}
|
const decoratorsBeforeExport = getPluginOption(plugins, "decorators", "decoratorsBeforeExport");
|
if (decoratorsBeforeExport != null && typeof decoratorsBeforeExport !== "boolean") {
|
throw new Error("'decoratorsBeforeExport' must be a boolean, if specified.");
|
}
|
const allowCallParenthesized = getPluginOption(plugins, "decorators", "allowCallParenthesized");
|
if (allowCallParenthesized != null && typeof allowCallParenthesized !== "boolean") {
|
throw new Error("'allowCallParenthesized' must be a boolean.");
|
}
|
}
|
if (hasPlugin(plugins, "flow") && hasPlugin(plugins, "typescript")) {
|
throw new Error("Cannot combine flow and typescript plugins.");
|
}
|
if (hasPlugin(plugins, "placeholders") && hasPlugin(plugins, "v8intrinsic")) {
|
throw new Error("Cannot combine placeholders and v8intrinsic plugins.");
|
}
|
if (hasPlugin(plugins, "pipelineOperator")) {
|
const proposal = getPluginOption(plugins, "pipelineOperator", "proposal");
|
if (!PIPELINE_PROPOSALS.includes(proposal)) {
|
const proposalList = PIPELINE_PROPOSALS.map(p => `"${p}"`).join(", ");
|
throw new Error(`"pipelineOperator" requires "proposal" option whose value must be one of: ${proposalList}.`);
|
}
|
const tupleSyntaxIsHash = hasPlugin(plugins, ["recordAndTuple", {
|
syntaxType: "hash"
|
}]);
|
if (proposal === "hack") {
|
if (hasPlugin(plugins, "placeholders")) {
|
throw new Error("Cannot combine placeholders plugin and Hack-style pipes.");
|
}
|
if (hasPlugin(plugins, "v8intrinsic")) {
|
throw new Error("Cannot combine v8intrinsic plugin and Hack-style pipes.");
|
}
|
const topicToken = getPluginOption(plugins, "pipelineOperator", "topicToken");
|
if (!TOPIC_TOKENS.includes(topicToken)) {
|
const tokenList = TOPIC_TOKENS.map(t => `"${t}"`).join(", ");
|
throw new Error(`"pipelineOperator" in "proposal": "hack" mode also requires a "topicToken" option whose value must be one of: ${tokenList}.`);
|
}
|
if (topicToken === "#" && tupleSyntaxIsHash) {
|
throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "hack", topicToken: "#" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
|
}
|
} else if (proposal === "smart" && tupleSyntaxIsHash) {
|
throw new Error('Plugin conflict between `["pipelineOperator", { proposal: "smart" }]` and `["recordAndtuple", { syntaxType: "hash"}]`.');
|
}
|
}
|
if (hasPlugin(plugins, "moduleAttributes")) {
|
{
|
if (hasPlugin(plugins, "importAssertions")) {
|
throw new Error("Cannot combine importAssertions and moduleAttributes plugins.");
|
}
|
const moduleAttributesVersionPluginOption = getPluginOption(plugins, "moduleAttributes", "version");
|
if (moduleAttributesVersionPluginOption !== "may-2020") {
|
throw new Error("The 'moduleAttributes' plugin requires a 'version' option," + " representing the last proposal update. Currently, the" + " only supported value is 'may-2020'.");
|
}
|
}
|
}
|
if (hasPlugin(plugins, "recordAndTuple") && getPluginOption(plugins, "recordAndTuple", "syntaxType") != null && !RECORD_AND_TUPLE_SYNTAX_TYPES.includes(getPluginOption(plugins, "recordAndTuple", "syntaxType"))) {
|
throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map(p => `'${p}'`).join(", "));
|
}
|
if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
|
const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
|
error.missingPlugins = "doExpressions";
|
throw error;
|
}
|
}
|
const mixinPlugins = {
|
estree,
|
jsx,
|
flow,
|
typescript,
|
v8intrinsic,
|
placeholders
|
};
|
const mixinPluginNames = Object.keys(mixinPlugins);
|
class ExpressionParser extends LValParser {
|
checkProto(prop, isRecord, protoRef, refExpressionErrors) {
|
if (prop.type === "SpreadElement" || this.isObjectMethod(prop) || prop.computed || prop.shorthand) {
|
return;
|
}
|
const key = prop.key;
|
const name = key.type === "Identifier" ? key.name : key.value;
|
if (name === "__proto__") {
|
if (isRecord) {
|
this.raise(Errors.RecordNoProto, {
|
at: key
|
});
|
return;
|
}
|
if (protoRef.used) {
|
if (refExpressionErrors) {
|
if (refExpressionErrors.doubleProtoLoc === null) {
|
refExpressionErrors.doubleProtoLoc = key.loc.start;
|
}
|
} else {
|
this.raise(Errors.DuplicateProto, {
|
at: key
|
});
|
}
|
}
|
protoRef.used = true;
|
}
|
}
|
shouldExitDescending(expr, potentialArrowAt) {
|
return expr.type === "ArrowFunctionExpression" && expr.start === potentialArrowAt;
|
}
|
getExpression() {
|
this.enterInitialScopes();
|
this.nextToken();
|
const expr = this.parseExpression();
|
if (!this.match(137)) {
|
this.unexpected();
|
}
|
this.finalizeRemainingComments();
|
expr.comments = this.state.comments;
|
expr.errors = this.state.errors;
|
if (this.options.tokens) {
|
expr.tokens = this.tokens;
|
}
|
return expr;
|
}
|
parseExpression(disallowIn, refExpressionErrors) {
|
if (disallowIn) {
|
return this.disallowInAnd(() => this.parseExpressionBase(refExpressionErrors));
|
}
|
return this.allowInAnd(() => this.parseExpressionBase(refExpressionErrors));
|
}
|
parseExpressionBase(refExpressionErrors) {
|
const startLoc = this.state.startLoc;
|
const expr = this.parseMaybeAssign(refExpressionErrors);
|
if (this.match(12)) {
|
const node = this.startNodeAt(startLoc);
|
node.expressions = [expr];
|
while (this.eat(12)) {
|
node.expressions.push(this.parseMaybeAssign(refExpressionErrors));
|
}
|
this.toReferencedList(node.expressions);
|
return this.finishNode(node, "SequenceExpression");
|
}
|
return expr;
|
}
|
parseMaybeAssignDisallowIn(refExpressionErrors, afterLeftParse) {
|
return this.disallowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
|
}
|
parseMaybeAssignAllowIn(refExpressionErrors, afterLeftParse) {
|
return this.allowInAnd(() => this.parseMaybeAssign(refExpressionErrors, afterLeftParse));
|
}
|
setOptionalParametersError(refExpressionErrors, resultError) {
|
var _resultError$loc;
|
refExpressionErrors.optionalParametersLoc = (_resultError$loc = resultError == null ? void 0 : resultError.loc) != null ? _resultError$loc : this.state.startLoc;
|
}
|
parseMaybeAssign(refExpressionErrors, afterLeftParse) {
|
const startLoc = this.state.startLoc;
|
if (this.isContextual(106)) {
|
if (this.prodParam.hasYield) {
|
let left = this.parseYield();
|
if (afterLeftParse) {
|
left = afterLeftParse.call(this, left, startLoc);
|
}
|
return left;
|
}
|
}
|
let ownExpressionErrors;
|
if (refExpressionErrors) {
|
ownExpressionErrors = false;
|
} else {
|
refExpressionErrors = new ExpressionErrors();
|
ownExpressionErrors = true;
|
}
|
const {
|
type
|
} = this.state;
|
if (type === 10 || tokenIsIdentifier(type)) {
|
this.state.potentialArrowAt = this.state.start;
|
}
|
let left = this.parseMaybeConditional(refExpressionErrors);
|
if (afterLeftParse) {
|
left = afterLeftParse.call(this, left, startLoc);
|
}
|
if (tokenIsAssignment(this.state.type)) {
|
const node = this.startNodeAt(startLoc);
|
const operator = this.state.value;
|
node.operator = operator;
|
if (this.match(29)) {
|
this.toAssignable(left, true);
|
node.left = left;
|
const startIndex = startLoc.index;
|
if (refExpressionErrors.doubleProtoLoc != null && refExpressionErrors.doubleProtoLoc.index >= startIndex) {
|
refExpressionErrors.doubleProtoLoc = null;
|
}
|
if (refExpressionErrors.shorthandAssignLoc != null && refExpressionErrors.shorthandAssignLoc.index >= startIndex) {
|
refExpressionErrors.shorthandAssignLoc = null;
|
}
|
if (refExpressionErrors.privateKeyLoc != null && refExpressionErrors.privateKeyLoc.index >= startIndex) {
|
this.checkDestructuringPrivate(refExpressionErrors);
|
refExpressionErrors.privateKeyLoc = null;
|
}
|
} else {
|
node.left = left;
|
}
|
this.next();
|
node.right = this.parseMaybeAssign();
|
this.checkLVal(left, {
|
in: this.finishNode(node, "AssignmentExpression")
|
});
|
return node;
|
} else if (ownExpressionErrors) {
|
this.checkExpressionErrors(refExpressionErrors, true);
|
}
|
return left;
|
}
|
parseMaybeConditional(refExpressionErrors) {
|
const startLoc = this.state.startLoc;
|
const potentialArrowAt = this.state.potentialArrowAt;
|
const expr = this.parseExprOps(refExpressionErrors);
|
if (this.shouldExitDescending(expr, potentialArrowAt)) {
|
return expr;
|
}
|
return this.parseConditional(expr, startLoc, refExpressionErrors);
|
}
|
parseConditional(expr, startLoc, refExpressionErrors) {
|
if (this.eat(17)) {
|
const node = this.startNodeAt(startLoc);
|
node.test = expr;
|
node.consequent = this.parseMaybeAssignAllowIn();
|
this.expect(14);
|
node.alternate = this.parseMaybeAssign();
|
return this.finishNode(node, "ConditionalExpression");
|
}
|
return expr;
|
}
|
parseMaybeUnaryOrPrivate(refExpressionErrors) {
|
return this.match(136) ? this.parsePrivateName() : this.parseMaybeUnary(refExpressionErrors);
|
}
|
parseExprOps(refExpressionErrors) {
|
const startLoc = this.state.startLoc;
|
const potentialArrowAt = this.state.potentialArrowAt;
|
const expr = this.parseMaybeUnaryOrPrivate(refExpressionErrors);
|
if (this.shouldExitDescending(expr, potentialArrowAt)) {
|
return expr;
|
}
|
return this.parseExprOp(expr, startLoc, -1);
|
}
|
parseExprOp(left, leftStartLoc, minPrec) {
|
if (this.isPrivateName(left)) {
|
const value = this.getPrivateNameSV(left);
|
if (minPrec >= tokenOperatorPrecedence(58) || !this.prodParam.hasIn || !this.match(58)) {
|
this.raise(Errors.PrivateInExpectedIn, {
|
at: left,
|
identifierName: value
|
});
|
}
|
this.classScope.usePrivateName(value, left.loc.start);
|
}
|
const op = this.state.type;
|
if (tokenIsOperator(op) && (this.prodParam.hasIn || !this.match(58))) {
|
let prec = tokenOperatorPrecedence(op);
|
if (prec > minPrec) {
|
if (op === 39) {
|
this.expectPlugin("pipelineOperator");
|
if (this.state.inFSharpPipelineDirectBody) {
|
return left;
|
}
|
this.checkPipelineAtInfixOperator(left, leftStartLoc);
|
}
|
const node = this.startNodeAt(leftStartLoc);
|
node.left = left;
|
node.operator = this.state.value;
|
const logical = op === 41 || op === 42;
|
const coalesce = op === 40;
|
if (coalesce) {
|
prec = tokenOperatorPrecedence(42);
|
}
|
this.next();
|
if (op === 39 && this.hasPlugin(["pipelineOperator", {
|
proposal: "minimal"
|
}])) {
|
if (this.state.type === 96 && this.prodParam.hasAwait) {
|
throw this.raise(Errors.UnexpectedAwaitAfterPipelineBody, {
|
at: this.state.startLoc
|
});
|
}
|
}
|
node.right = this.parseExprOpRightExpr(op, prec);
|
const finishedNode = this.finishNode(node, logical || coalesce ? "LogicalExpression" : "BinaryExpression");
|
const nextOp = this.state.type;
|
if (coalesce && (nextOp === 41 || nextOp === 42) || logical && nextOp === 40) {
|
throw this.raise(Errors.MixingCoalesceWithLogical, {
|
at: this.state.startLoc
|
});
|
}
|
return this.parseExprOp(finishedNode, leftStartLoc, minPrec);
|
}
|
}
|
return left;
|
}
|
parseExprOpRightExpr(op, prec) {
|
const startLoc = this.state.startLoc;
|
switch (op) {
|
case 39:
|
switch (this.getPluginOption("pipelineOperator", "proposal")) {
|
case "hack":
|
return this.withTopicBindingContext(() => {
|
return this.parseHackPipeBody();
|
});
|
case "smart":
|
return this.withTopicBindingContext(() => {
|
if (this.prodParam.hasYield && this.isContextual(106)) {
|
throw this.raise(Errors.PipeBodyIsTighter, {
|
at: this.state.startLoc
|
});
|
}
|
return this.parseSmartPipelineBodyInStyle(this.parseExprOpBaseRightExpr(op, prec), startLoc);
|
});
|
case "fsharp":
|
return this.withSoloAwaitPermittingContext(() => {
|
return this.parseFSharpPipelineBody(prec);
|
});
|
}
|
default:
|
return this.parseExprOpBaseRightExpr(op, prec);
|
}
|
}
|
parseExprOpBaseRightExpr(op, prec) {
|
const startLoc = this.state.startLoc;
|
return this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, tokenIsRightAssociative(op) ? prec - 1 : prec);
|
}
|
parseHackPipeBody() {
|
var _body$extra;
|
const {
|
startLoc
|
} = this.state;
|
const body = this.parseMaybeAssign();
|
const requiredParentheses = UnparenthesizedPipeBodyDescriptions.has(body.type);
|
if (requiredParentheses && !((_body$extra = body.extra) != null && _body$extra.parenthesized)) {
|
this.raise(Errors.PipeUnparenthesizedBody, {
|
at: startLoc,
|
type: body.type
|
});
|
}
|
if (!this.topicReferenceWasUsedInCurrentContext()) {
|
this.raise(Errors.PipeTopicUnused, {
|
at: startLoc
|
});
|
}
|
return body;
|
}
|
checkExponentialAfterUnary(node) {
|
if (this.match(57)) {
|
this.raise(Errors.UnexpectedTokenUnaryExponentiation, {
|
at: node.argument
|
});
|
}
|
}
|
parseMaybeUnary(refExpressionErrors, sawUnary) {
|
const startLoc = this.state.startLoc;
|
const isAwait = this.isContextual(96);
|
if (isAwait && this.isAwaitAllowed()) {
|
this.next();
|
const expr = this.parseAwait(startLoc);
|
if (!sawUnary) this.checkExponentialAfterUnary(expr);
|
return expr;
|
}
|
const update = this.match(34);
|
const node = this.startNode();
|
if (tokenIsPrefix(this.state.type)) {
|
node.operator = this.state.value;
|
node.prefix = true;
|
if (this.match(72)) {
|
this.expectPlugin("throwExpressions");
|
}
|
const isDelete = this.match(89);
|
this.next();
|
node.argument = this.parseMaybeUnary(null, true);
|
this.checkExpressionErrors(refExpressionErrors, true);
|
if (this.state.strict && isDelete) {
|
const arg = node.argument;
|
if (arg.type === "Identifier") {
|
this.raise(Errors.StrictDelete, {
|
at: node
|
});
|
} else if (this.hasPropertyAsPrivateName(arg)) {
|
this.raise(Errors.DeletePrivateField, {
|
at: node
|
});
|
}
|
}
|
if (!update) {
|
if (!sawUnary) {
|
this.checkExponentialAfterUnary(node);
|
}
|
return this.finishNode(node, "UnaryExpression");
|
}
|
}
|
const expr = this.parseUpdate(node, update, refExpressionErrors);
|
if (isAwait) {
|
const {
|
type
|
} = this.state;
|
const startsExpr = this.hasPlugin("v8intrinsic") ? tokenCanStartExpression(type) : tokenCanStartExpression(type) && !this.match(54);
|
if (startsExpr && !this.isAmbiguousAwait()) {
|
this.raiseOverwrite(Errors.AwaitNotInAsyncContext, {
|
at: startLoc
|
});
|
return this.parseAwait(startLoc);
|
}
|
}
|
return expr;
|
}
|
parseUpdate(node, update, refExpressionErrors) {
|
if (update) {
|
const updateExpressionNode = node;
|
this.checkLVal(updateExpressionNode.argument, {
|
in: this.finishNode(updateExpressionNode, "UpdateExpression")
|
});
|
return node;
|
}
|
const startLoc = this.state.startLoc;
|
let expr = this.parseExprSubscripts(refExpressionErrors);
|
if (this.checkExpressionErrors(refExpressionErrors, false)) return expr;
|
while (tokenIsPostfix(this.state.type) && !this.canInsertSemicolon()) {
|
const node = this.startNodeAt(startLoc);
|
node.operator = this.state.value;
|
node.prefix = false;
|
node.argument = expr;
|
this.next();
|
this.checkLVal(expr, {
|
in: expr = this.finishNode(node, "UpdateExpression")
|
});
|
}
|
return expr;
|
}
|
parseExprSubscripts(refExpressionErrors) {
|
const startLoc = this.state.startLoc;
|
const potentialArrowAt = this.state.potentialArrowAt;
|
const expr = this.parseExprAtom(refExpressionErrors);
|
if (this.shouldExitDescending(expr, potentialArrowAt)) {
|
return expr;
|
}
|
return this.parseSubscripts(expr, startLoc);
|
}
|
parseSubscripts(base, startLoc, noCalls) {
|
const state = {
|
optionalChainMember: false,
|
maybeAsyncArrow: this.atPossibleAsyncArrow(base),
|
stop: false
|
};
|
do {
|
base = this.parseSubscript(base, startLoc, noCalls, state);
|
state.maybeAsyncArrow = false;
|
} while (!state.stop);
|
return base;
|
}
|
parseSubscript(base, startLoc, noCalls, state) {
|
const {
|
type
|
} = this.state;
|
if (!noCalls && type === 15) {
|
return this.parseBind(base, startLoc, noCalls, state);
|
} else if (tokenIsTemplate(type)) {
|
return this.parseTaggedTemplateExpression(base, startLoc, state);
|
}
|
let optional = false;
|
if (type === 18) {
|
if (noCalls) {
|
this.raise(Errors.OptionalChainingNoNew, {
|
at: this.state.startLoc
|
});
|
if (this.lookaheadCharCode() === 40) {
|
state.stop = true;
|
return base;
|
}
|
}
|
state.optionalChainMember = optional = true;
|
this.next();
|
}
|
if (!noCalls && this.match(10)) {
|
return this.parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional);
|
} else {
|
const computed = this.eat(0);
|
if (computed || optional || this.eat(16)) {
|
return this.parseMember(base, startLoc, state, computed, optional);
|
} else {
|
state.stop = true;
|
return base;
|
}
|
}
|
}
|
parseMember(base, startLoc, state, computed, optional) {
|
const node = this.startNodeAt(startLoc);
|
node.object = base;
|
node.computed = computed;
|
if (computed) {
|
node.property = this.parseExpression();
|
this.expect(3);
|
} else if (this.match(136)) {
|
if (base.type === "Super") {
|
this.raise(Errors.SuperPrivateField, {
|
at: startLoc
|
});
|
}
|
this.classScope.usePrivateName(this.state.value, this.state.startLoc);
|
node.property = this.parsePrivateName();
|
} else {
|
node.property = this.parseIdentifier(true);
|
}
|
if (state.optionalChainMember) {
|
node.optional = optional;
|
return this.finishNode(node, "OptionalMemberExpression");
|
} else {
|
return this.finishNode(node, "MemberExpression");
|
}
|
}
|
parseBind(base, startLoc, noCalls, state) {
|
const node = this.startNodeAt(startLoc);
|
node.object = base;
|
this.next();
|
node.callee = this.parseNoCallExpr();
|
state.stop = true;
|
return this.parseSubscripts(this.finishNode(node, "BindExpression"), startLoc, noCalls);
|
}
|
parseCoverCallAndAsyncArrowHead(base, startLoc, state, optional) {
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
|
let refExpressionErrors = null;
|
this.state.maybeInArrowParameters = true;
|
this.next();
|
const node = this.startNodeAt(startLoc);
|
node.callee = base;
|
const {
|
maybeAsyncArrow,
|
optionalChainMember
|
} = state;
|
if (maybeAsyncArrow) {
|
this.expressionScope.enter(newAsyncArrowScope());
|
refExpressionErrors = new ExpressionErrors();
|
}
|
if (optionalChainMember) {
|
node.optional = optional;
|
}
|
if (optional) {
|
node.arguments = this.parseCallExpressionArguments(11);
|
} else {
|
node.arguments = this.parseCallExpressionArguments(11, base.type === "Import", base.type !== "Super", node, refExpressionErrors);
|
}
|
let finishedNode = this.finishCallExpression(node, optionalChainMember);
|
if (maybeAsyncArrow && this.shouldParseAsyncArrow() && !optional) {
|
state.stop = true;
|
this.checkDestructuringPrivate(refExpressionErrors);
|
this.expressionScope.validateAsPattern();
|
this.expressionScope.exit();
|
finishedNode = this.parseAsyncArrowFromCallExpression(this.startNodeAt(startLoc), finishedNode);
|
} else {
|
if (maybeAsyncArrow) {
|
this.checkExpressionErrors(refExpressionErrors, true);
|
this.expressionScope.exit();
|
}
|
this.toReferencedArguments(finishedNode);
|
}
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
|
return finishedNode;
|
}
|
toReferencedArguments(node, isParenthesizedExpr) {
|
this.toReferencedListDeep(node.arguments, isParenthesizedExpr);
|
}
|
parseTaggedTemplateExpression(base, startLoc, state) {
|
const node = this.startNodeAt(startLoc);
|
node.tag = base;
|
node.quasi = this.parseTemplate(true);
|
if (state.optionalChainMember) {
|
this.raise(Errors.OptionalChainingNoTemplate, {
|
at: startLoc
|
});
|
}
|
return this.finishNode(node, "TaggedTemplateExpression");
|
}
|
atPossibleAsyncArrow(base) {
|
return base.type === "Identifier" && base.name === "async" && this.state.lastTokEndLoc.index === base.end && !this.canInsertSemicolon() && base.end - base.start === 5 && base.start === this.state.potentialArrowAt;
|
}
|
finishCallExpression(node, optional) {
|
if (node.callee.type === "Import") {
|
if (node.arguments.length === 2) {
|
{
|
if (!this.hasPlugin("moduleAttributes")) {
|
this.expectPlugin("importAssertions");
|
}
|
}
|
}
|
if (node.arguments.length === 0 || node.arguments.length > 2) {
|
this.raise(Errors.ImportCallArity, {
|
at: node,
|
maxArgumentCount: this.hasPlugin("importAssertions") || this.hasPlugin("moduleAttributes") ? 2 : 1
|
});
|
} else {
|
for (const arg of node.arguments) {
|
if (arg.type === "SpreadElement") {
|
this.raise(Errors.ImportCallSpreadArgument, {
|
at: arg
|
});
|
}
|
}
|
}
|
}
|
return this.finishNode(node, optional ? "OptionalCallExpression" : "CallExpression");
|
}
|
parseCallExpressionArguments(close, dynamicImport, allowPlaceholder, nodeForExtra, refExpressionErrors) {
|
const elts = [];
|
let first = true;
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
|
this.state.inFSharpPipelineDirectBody = false;
|
while (!this.eat(close)) {
|
if (first) {
|
first = false;
|
} else {
|
this.expect(12);
|
if (this.match(close)) {
|
if (dynamicImport && !this.hasPlugin("importAssertions") && !this.hasPlugin("moduleAttributes")) {
|
this.raise(Errors.ImportCallArgumentTrailingComma, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
if (nodeForExtra) {
|
this.addTrailingCommaExtraToNode(nodeForExtra);
|
}
|
this.next();
|
break;
|
}
|
}
|
elts.push(this.parseExprListItem(false, refExpressionErrors, allowPlaceholder));
|
}
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
|
return elts;
|
}
|
shouldParseAsyncArrow() {
|
return this.match(19) && !this.canInsertSemicolon();
|
}
|
parseAsyncArrowFromCallExpression(node, call) {
|
var _call$extra;
|
this.resetPreviousNodeTrailingComments(call);
|
this.expect(19);
|
this.parseArrowExpression(node, call.arguments, true, (_call$extra = call.extra) == null ? void 0 : _call$extra.trailingCommaLoc);
|
if (call.innerComments) {
|
setInnerComments(node, call.innerComments);
|
}
|
if (call.callee.trailingComments) {
|
setInnerComments(node, call.callee.trailingComments);
|
}
|
return node;
|
}
|
parseNoCallExpr() {
|
const startLoc = this.state.startLoc;
|
return this.parseSubscripts(this.parseExprAtom(), startLoc, true);
|
}
|
parseExprAtom(refExpressionErrors) {
|
let node;
|
let decorators = null;
|
const {
|
type
|
} = this.state;
|
switch (type) {
|
case 79:
|
return this.parseSuper();
|
case 83:
|
node = this.startNode();
|
this.next();
|
if (this.match(16)) {
|
return this.parseImportMetaProperty(node);
|
}
|
if (!this.match(10)) {
|
this.raise(Errors.UnsupportedImport, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
return this.finishNode(node, "Import");
|
case 78:
|
node = this.startNode();
|
this.next();
|
return this.finishNode(node, "ThisExpression");
|
case 90:
|
{
|
return this.parseDo(this.startNode(), false);
|
}
|
case 56:
|
case 31:
|
{
|
this.readRegexp();
|
return this.parseRegExpLiteral(this.state.value);
|
}
|
case 132:
|
return this.parseNumericLiteral(this.state.value);
|
case 133:
|
return this.parseBigIntLiteral(this.state.value);
|
case 134:
|
return this.parseDecimalLiteral(this.state.value);
|
case 131:
|
return this.parseStringLiteral(this.state.value);
|
case 84:
|
return this.parseNullLiteral();
|
case 85:
|
return this.parseBooleanLiteral(true);
|
case 86:
|
return this.parseBooleanLiteral(false);
|
case 10:
|
{
|
const canBeArrow = this.state.potentialArrowAt === this.state.start;
|
return this.parseParenAndDistinguishExpression(canBeArrow);
|
}
|
case 2:
|
case 1:
|
{
|
return this.parseArrayLike(this.state.type === 2 ? 4 : 3, false, true);
|
}
|
case 0:
|
{
|
return this.parseArrayLike(3, true, false, refExpressionErrors);
|
}
|
case 6:
|
case 7:
|
{
|
return this.parseObjectLike(this.state.type === 6 ? 9 : 8, false, true);
|
}
|
case 5:
|
{
|
return this.parseObjectLike(8, false, false, refExpressionErrors);
|
}
|
case 68:
|
return this.parseFunctionOrFunctionSent();
|
case 26:
|
decorators = this.parseDecorators();
|
case 80:
|
return this.parseClass(this.maybeTakeDecorators(decorators, this.startNode()), false);
|
case 77:
|
return this.parseNewOrNewTarget();
|
case 25:
|
case 24:
|
return this.parseTemplate(false);
|
case 15:
|
{
|
node = this.startNode();
|
this.next();
|
node.object = null;
|
const callee = node.callee = this.parseNoCallExpr();
|
if (callee.type === "MemberExpression") {
|
return this.finishNode(node, "BindExpression");
|
} else {
|
throw this.raise(Errors.UnsupportedBind, {
|
at: callee
|
});
|
}
|
}
|
case 136:
|
{
|
this.raise(Errors.PrivateInExpectedIn, {
|
at: this.state.startLoc,
|
identifierName: this.state.value
|
});
|
return this.parsePrivateName();
|
}
|
case 33:
|
{
|
return this.parseTopicReferenceThenEqualsSign(54, "%");
|
}
|
case 32:
|
{
|
return this.parseTopicReferenceThenEqualsSign(44, "^");
|
}
|
case 37:
|
case 38:
|
{
|
return this.parseTopicReference("hack");
|
}
|
case 44:
|
case 54:
|
case 27:
|
{
|
const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
|
if (pipeProposal) {
|
return this.parseTopicReference(pipeProposal);
|
}
|
this.unexpected();
|
break;
|
}
|
case 47:
|
{
|
const lookaheadCh = this.input.codePointAt(this.nextTokenStart());
|
if (isIdentifierStart(lookaheadCh) || lookaheadCh === 62) {
|
this.expectOnePlugin(["jsx", "flow", "typescript"]);
|
} else {
|
this.unexpected();
|
}
|
break;
|
}
|
default:
|
if (tokenIsIdentifier(type)) {
|
if (this.isContextual(125) && this.lookaheadCharCode() === 123 && !this.hasFollowingLineBreak()) {
|
return this.parseModuleExpression();
|
}
|
const canBeArrow = this.state.potentialArrowAt === this.state.start;
|
const containsEsc = this.state.containsEsc;
|
const id = this.parseIdentifier();
|
if (!containsEsc && id.name === "async" && !this.canInsertSemicolon()) {
|
const {
|
type
|
} = this.state;
|
if (type === 68) {
|
this.resetPreviousNodeTrailingComments(id);
|
this.next();
|
return this.parseAsyncFunctionExpression(this.startNodeAtNode(id));
|
} else if (tokenIsIdentifier(type)) {
|
if (this.lookaheadCharCode() === 61) {
|
return this.parseAsyncArrowUnaryFunction(this.startNodeAtNode(id));
|
} else {
|
return id;
|
}
|
} else if (type === 90) {
|
this.resetPreviousNodeTrailingComments(id);
|
return this.parseDo(this.startNodeAtNode(id), true);
|
}
|
}
|
if (canBeArrow && this.match(19) && !this.canInsertSemicolon()) {
|
this.next();
|
return this.parseArrowExpression(this.startNodeAtNode(id), [id], false);
|
}
|
return id;
|
} else {
|
this.unexpected();
|
}
|
}
|
}
|
parseTopicReferenceThenEqualsSign(topicTokenType, topicTokenValue) {
|
const pipeProposal = this.getPluginOption("pipelineOperator", "proposal");
|
if (pipeProposal) {
|
this.state.type = topicTokenType;
|
this.state.value = topicTokenValue;
|
this.state.pos--;
|
this.state.end--;
|
this.state.endLoc = createPositionWithColumnOffset(this.state.endLoc, -1);
|
return this.parseTopicReference(pipeProposal);
|
} else {
|
this.unexpected();
|
}
|
}
|
parseTopicReference(pipeProposal) {
|
const node = this.startNode();
|
const startLoc = this.state.startLoc;
|
const tokenType = this.state.type;
|
this.next();
|
return this.finishTopicReference(node, startLoc, pipeProposal, tokenType);
|
}
|
finishTopicReference(node, startLoc, pipeProposal, tokenType) {
|
if (this.testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType)) {
|
const nodeType = pipeProposal === "smart" ? "PipelinePrimaryTopicReference" : "TopicReference";
|
if (!this.topicReferenceIsAllowedInCurrentContext()) {
|
this.raise(pipeProposal === "smart" ? Errors.PrimaryTopicNotAllowed : Errors.PipeTopicUnbound, {
|
at: startLoc
|
});
|
}
|
this.registerTopicReference();
|
return this.finishNode(node, nodeType);
|
} else {
|
throw this.raise(Errors.PipeTopicUnconfiguredToken, {
|
at: startLoc,
|
token: tokenLabelName(tokenType)
|
});
|
}
|
}
|
testTopicReferenceConfiguration(pipeProposal, startLoc, tokenType) {
|
switch (pipeProposal) {
|
case "hack":
|
{
|
return this.hasPlugin(["pipelineOperator", {
|
topicToken: tokenLabelName(tokenType)
|
}]);
|
}
|
case "smart":
|
return tokenType === 27;
|
default:
|
throw this.raise(Errors.PipeTopicRequiresHackPipes, {
|
at: startLoc
|
});
|
}
|
}
|
parseAsyncArrowUnaryFunction(node) {
|
this.prodParam.enter(functionFlags(true, this.prodParam.hasYield));
|
const params = [this.parseIdentifier()];
|
this.prodParam.exit();
|
if (this.hasPrecedingLineBreak()) {
|
this.raise(Errors.LineTerminatorBeforeArrow, {
|
at: this.state.curPosition()
|
});
|
}
|
this.expect(19);
|
return this.parseArrowExpression(node, params, true);
|
}
|
parseDo(node, isAsync) {
|
this.expectPlugin("doExpressions");
|
if (isAsync) {
|
this.expectPlugin("asyncDoExpressions");
|
}
|
node.async = isAsync;
|
this.next();
|
const oldLabels = this.state.labels;
|
this.state.labels = [];
|
if (isAsync) {
|
this.prodParam.enter(PARAM_AWAIT);
|
node.body = this.parseBlock();
|
this.prodParam.exit();
|
} else {
|
node.body = this.parseBlock();
|
}
|
this.state.labels = oldLabels;
|
return this.finishNode(node, "DoExpression");
|
}
|
parseSuper() {
|
const node = this.startNode();
|
this.next();
|
if (this.match(10) && !this.scope.allowDirectSuper && !this.options.allowSuperOutsideMethod) {
|
this.raise(Errors.SuperNotAllowed, {
|
at: node
|
});
|
} else if (!this.scope.allowSuper && !this.options.allowSuperOutsideMethod) {
|
this.raise(Errors.UnexpectedSuper, {
|
at: node
|
});
|
}
|
if (!this.match(10) && !this.match(0) && !this.match(16)) {
|
this.raise(Errors.UnsupportedSuper, {
|
at: node
|
});
|
}
|
return this.finishNode(node, "Super");
|
}
|
parsePrivateName() {
|
const node = this.startNode();
|
const id = this.startNodeAt(createPositionWithColumnOffset(this.state.startLoc, 1));
|
const name = this.state.value;
|
this.next();
|
node.id = this.createIdentifier(id, name);
|
return this.finishNode(node, "PrivateName");
|
}
|
parseFunctionOrFunctionSent() {
|
const node = this.startNode();
|
this.next();
|
if (this.prodParam.hasYield && this.match(16)) {
|
const meta = this.createIdentifier(this.startNodeAtNode(node), "function");
|
this.next();
|
if (this.match(102)) {
|
this.expectPlugin("functionSent");
|
} else if (!this.hasPlugin("functionSent")) {
|
this.unexpected();
|
}
|
return this.parseMetaProperty(node, meta, "sent");
|
}
|
return this.parseFunction(node);
|
}
|
parseMetaProperty(node, meta, propertyName) {
|
node.meta = meta;
|
const containsEsc = this.state.containsEsc;
|
node.property = this.parseIdentifier(true);
|
if (node.property.name !== propertyName || containsEsc) {
|
this.raise(Errors.UnsupportedMetaProperty, {
|
at: node.property,
|
target: meta.name,
|
onlyValidPropertyName: propertyName
|
});
|
}
|
return this.finishNode(node, "MetaProperty");
|
}
|
parseImportMetaProperty(node) {
|
const id = this.createIdentifier(this.startNodeAtNode(node), "import");
|
this.next();
|
if (this.isContextual(100)) {
|
if (!this.inModule) {
|
this.raise(Errors.ImportMetaOutsideModule, {
|
at: id
|
});
|
}
|
this.sawUnambiguousESM = true;
|
}
|
return this.parseMetaProperty(node, id, "meta");
|
}
|
parseLiteralAtNode(value, type, node) {
|
this.addExtra(node, "rawValue", value);
|
this.addExtra(node, "raw", this.input.slice(node.start, this.state.end));
|
node.value = value;
|
this.next();
|
return this.finishNode(node, type);
|
}
|
parseLiteral(value, type) {
|
const node = this.startNode();
|
return this.parseLiteralAtNode(value, type, node);
|
}
|
parseStringLiteral(value) {
|
return this.parseLiteral(value, "StringLiteral");
|
}
|
parseNumericLiteral(value) {
|
return this.parseLiteral(value, "NumericLiteral");
|
}
|
parseBigIntLiteral(value) {
|
return this.parseLiteral(value, "BigIntLiteral");
|
}
|
parseDecimalLiteral(value) {
|
return this.parseLiteral(value, "DecimalLiteral");
|
}
|
parseRegExpLiteral(value) {
|
const node = this.parseLiteral(value.value, "RegExpLiteral");
|
node.pattern = value.pattern;
|
node.flags = value.flags;
|
return node;
|
}
|
parseBooleanLiteral(value) {
|
const node = this.startNode();
|
node.value = value;
|
this.next();
|
return this.finishNode(node, "BooleanLiteral");
|
}
|
parseNullLiteral() {
|
const node = this.startNode();
|
this.next();
|
return this.finishNode(node, "NullLiteral");
|
}
|
parseParenAndDistinguishExpression(canBeArrow) {
|
const startLoc = this.state.startLoc;
|
let val;
|
this.next();
|
this.expressionScope.enter(newArrowHeadScope());
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
|
this.state.maybeInArrowParameters = true;
|
this.state.inFSharpPipelineDirectBody = false;
|
const innerStartLoc = this.state.startLoc;
|
const exprList = [];
|
const refExpressionErrors = new ExpressionErrors();
|
let first = true;
|
let spreadStartLoc;
|
let optionalCommaStartLoc;
|
while (!this.match(11)) {
|
if (first) {
|
first = false;
|
} else {
|
this.expect(12, refExpressionErrors.optionalParametersLoc === null ? null : refExpressionErrors.optionalParametersLoc);
|
if (this.match(11)) {
|
optionalCommaStartLoc = this.state.startLoc;
|
break;
|
}
|
}
|
if (this.match(21)) {
|
const spreadNodeStartLoc = this.state.startLoc;
|
spreadStartLoc = this.state.startLoc;
|
exprList.push(this.parseParenItem(this.parseRestBinding(), spreadNodeStartLoc));
|
if (!this.checkCommaAfterRest(41)) {
|
break;
|
}
|
} else {
|
exprList.push(this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem));
|
}
|
}
|
const innerEndLoc = this.state.lastTokEndLoc;
|
this.expect(11);
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
|
let arrowNode = this.startNodeAt(startLoc);
|
if (canBeArrow && this.shouldParseArrow(exprList) && (arrowNode = this.parseArrow(arrowNode))) {
|
this.checkDestructuringPrivate(refExpressionErrors);
|
this.expressionScope.validateAsPattern();
|
this.expressionScope.exit();
|
this.parseArrowExpression(arrowNode, exprList, false);
|
return arrowNode;
|
}
|
this.expressionScope.exit();
|
if (!exprList.length) {
|
this.unexpected(this.state.lastTokStartLoc);
|
}
|
if (optionalCommaStartLoc) this.unexpected(optionalCommaStartLoc);
|
if (spreadStartLoc) this.unexpected(spreadStartLoc);
|
this.checkExpressionErrors(refExpressionErrors, true);
|
this.toReferencedListDeep(exprList, true);
|
if (exprList.length > 1) {
|
val = this.startNodeAt(innerStartLoc);
|
val.expressions = exprList;
|
this.finishNode(val, "SequenceExpression");
|
this.resetEndLocation(val, innerEndLoc);
|
} else {
|
val = exprList[0];
|
}
|
return this.wrapParenthesis(startLoc, val);
|
}
|
wrapParenthesis(startLoc, expression) {
|
if (!this.options.createParenthesizedExpressions) {
|
this.addExtra(expression, "parenthesized", true);
|
this.addExtra(expression, "parenStart", startLoc.index);
|
this.takeSurroundingComments(expression, startLoc.index, this.state.lastTokEndLoc.index);
|
return expression;
|
}
|
const parenExpression = this.startNodeAt(startLoc);
|
parenExpression.expression = expression;
|
return this.finishNode(parenExpression, "ParenthesizedExpression");
|
}
|
shouldParseArrow(params) {
|
return !this.canInsertSemicolon();
|
}
|
parseArrow(node) {
|
if (this.eat(19)) {
|
return node;
|
}
|
}
|
parseParenItem(node, startLoc) {
|
return node;
|
}
|
parseNewOrNewTarget() {
|
const node = this.startNode();
|
this.next();
|
if (this.match(16)) {
|
const meta = this.createIdentifier(this.startNodeAtNode(node), "new");
|
this.next();
|
const metaProp = this.parseMetaProperty(node, meta, "target");
|
if (!this.scope.inNonArrowFunction && !this.scope.inClass && !this.options.allowNewTargetOutsideFunction) {
|
this.raise(Errors.UnexpectedNewTarget, {
|
at: metaProp
|
});
|
}
|
return metaProp;
|
}
|
return this.parseNew(node);
|
}
|
parseNew(node) {
|
this.parseNewCallee(node);
|
if (this.eat(10)) {
|
const args = this.parseExprList(11);
|
this.toReferencedList(args);
|
node.arguments = args;
|
} else {
|
node.arguments = [];
|
}
|
return this.finishNode(node, "NewExpression");
|
}
|
parseNewCallee(node) {
|
node.callee = this.parseNoCallExpr();
|
if (node.callee.type === "Import") {
|
this.raise(Errors.ImportCallNotNewExpression, {
|
at: node.callee
|
});
|
}
|
}
|
parseTemplateElement(isTagged) {
|
const {
|
start,
|
startLoc,
|
end,
|
value
|
} = this.state;
|
const elemStart = start + 1;
|
const elem = this.startNodeAt(createPositionWithColumnOffset(startLoc, 1));
|
if (value === null) {
|
if (!isTagged) {
|
this.raise(Errors.InvalidEscapeSequenceTemplate, {
|
at: createPositionWithColumnOffset(this.state.firstInvalidTemplateEscapePos, 1)
|
});
|
}
|
}
|
const isTail = this.match(24);
|
const endOffset = isTail ? -1 : -2;
|
const elemEnd = end + endOffset;
|
elem.value = {
|
raw: this.input.slice(elemStart, elemEnd).replace(/\r\n?/g, "\n"),
|
cooked: value === null ? null : value.slice(1, endOffset)
|
};
|
elem.tail = isTail;
|
this.next();
|
const finishedNode = this.finishNode(elem, "TemplateElement");
|
this.resetEndLocation(finishedNode, createPositionWithColumnOffset(this.state.lastTokEndLoc, endOffset));
|
return finishedNode;
|
}
|
parseTemplate(isTagged) {
|
const node = this.startNode();
|
node.expressions = [];
|
let curElt = this.parseTemplateElement(isTagged);
|
node.quasis = [curElt];
|
while (!curElt.tail) {
|
node.expressions.push(this.parseTemplateSubstitution());
|
this.readTemplateContinuation();
|
node.quasis.push(curElt = this.parseTemplateElement(isTagged));
|
}
|
return this.finishNode(node, "TemplateLiteral");
|
}
|
parseTemplateSubstitution() {
|
return this.parseExpression();
|
}
|
parseObjectLike(close, isPattern, isRecord, refExpressionErrors) {
|
if (isRecord) {
|
this.expectPlugin("recordAndTuple");
|
}
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
|
this.state.inFSharpPipelineDirectBody = false;
|
const propHash = Object.create(null);
|
let first = true;
|
const node = this.startNode();
|
node.properties = [];
|
this.next();
|
while (!this.match(close)) {
|
if (first) {
|
first = false;
|
} else {
|
this.expect(12);
|
if (this.match(close)) {
|
this.addTrailingCommaExtraToNode(node);
|
break;
|
}
|
}
|
let prop;
|
if (isPattern) {
|
prop = this.parseBindingProperty();
|
} else {
|
prop = this.parsePropertyDefinition(refExpressionErrors);
|
this.checkProto(prop, isRecord, propHash, refExpressionErrors);
|
}
|
if (isRecord && !this.isObjectProperty(prop) && prop.type !== "SpreadElement") {
|
this.raise(Errors.InvalidRecordProperty, {
|
at: prop
|
});
|
}
|
if (prop.shorthand) {
|
this.addExtra(prop, "shorthand", true);
|
}
|
node.properties.push(prop);
|
}
|
this.next();
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
|
let type = "ObjectExpression";
|
if (isPattern) {
|
type = "ObjectPattern";
|
} else if (isRecord) {
|
type = "RecordExpression";
|
}
|
return this.finishNode(node, type);
|
}
|
addTrailingCommaExtraToNode(node) {
|
this.addExtra(node, "trailingComma", this.state.lastTokStart);
|
this.addExtra(node, "trailingCommaLoc", this.state.lastTokStartLoc, false);
|
}
|
maybeAsyncOrAccessorProp(prop) {
|
return !prop.computed && prop.key.type === "Identifier" && (this.isLiteralPropertyName() || this.match(0) || this.match(55));
|
}
|
parsePropertyDefinition(refExpressionErrors) {
|
let decorators = [];
|
if (this.match(26)) {
|
if (this.hasPlugin("decorators")) {
|
this.raise(Errors.UnsupportedPropertyDecorator, {
|
at: this.state.startLoc
|
});
|
}
|
while (this.match(26)) {
|
decorators.push(this.parseDecorator());
|
}
|
}
|
const prop = this.startNode();
|
let isAsync = false;
|
let isAccessor = false;
|
let startLoc;
|
if (this.match(21)) {
|
if (decorators.length) this.unexpected();
|
return this.parseSpread();
|
}
|
if (decorators.length) {
|
prop.decorators = decorators;
|
decorators = [];
|
}
|
prop.method = false;
|
if (refExpressionErrors) {
|
startLoc = this.state.startLoc;
|
}
|
let isGenerator = this.eat(55);
|
this.parsePropertyNamePrefixOperator(prop);
|
const containsEsc = this.state.containsEsc;
|
const key = this.parsePropertyName(prop, refExpressionErrors);
|
if (!isGenerator && !containsEsc && this.maybeAsyncOrAccessorProp(prop)) {
|
const keyName = key.name;
|
if (keyName === "async" && !this.hasPrecedingLineBreak()) {
|
isAsync = true;
|
this.resetPreviousNodeTrailingComments(key);
|
isGenerator = this.eat(55);
|
this.parsePropertyName(prop);
|
}
|
if (keyName === "get" || keyName === "set") {
|
isAccessor = true;
|
this.resetPreviousNodeTrailingComments(key);
|
prop.kind = keyName;
|
if (this.match(55)) {
|
isGenerator = true;
|
this.raise(Errors.AccessorIsGenerator, {
|
at: this.state.curPosition(),
|
kind: keyName
|
});
|
this.next();
|
}
|
this.parsePropertyName(prop);
|
}
|
}
|
return this.parseObjPropValue(prop, startLoc, isGenerator, isAsync, false, isAccessor, refExpressionErrors);
|
}
|
getGetterSetterExpectedParamCount(method) {
|
return method.kind === "get" ? 0 : 1;
|
}
|
getObjectOrClassMethodParams(method) {
|
return method.params;
|
}
|
checkGetterSetterParams(method) {
|
var _params;
|
const paramCount = this.getGetterSetterExpectedParamCount(method);
|
const params = this.getObjectOrClassMethodParams(method);
|
if (params.length !== paramCount) {
|
this.raise(method.kind === "get" ? Errors.BadGetterArity : Errors.BadSetterArity, {
|
at: method
|
});
|
}
|
if (method.kind === "set" && ((_params = params[params.length - 1]) == null ? void 0 : _params.type) === "RestElement") {
|
this.raise(Errors.BadSetterRestParameter, {
|
at: method
|
});
|
}
|
}
|
parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) {
|
if (isAccessor) {
|
const finishedProp = this.parseMethod(prop, isGenerator, false, false, false, "ObjectMethod");
|
this.checkGetterSetterParams(finishedProp);
|
return finishedProp;
|
}
|
if (isAsync || isGenerator || this.match(10)) {
|
if (isPattern) this.unexpected();
|
prop.kind = "method";
|
prop.method = true;
|
return this.parseMethod(prop, isGenerator, isAsync, false, false, "ObjectMethod");
|
}
|
}
|
parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors) {
|
prop.shorthand = false;
|
if (this.eat(14)) {
|
prop.value = isPattern ? this.parseMaybeDefault(this.state.startLoc) : this.parseMaybeAssignAllowIn(refExpressionErrors);
|
return this.finishNode(prop, "ObjectProperty");
|
}
|
if (!prop.computed && prop.key.type === "Identifier") {
|
this.checkReservedWord(prop.key.name, prop.key.loc.start, true, false);
|
if (isPattern) {
|
prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
|
} else if (this.match(29)) {
|
const shorthandAssignLoc = this.state.startLoc;
|
if (refExpressionErrors != null) {
|
if (refExpressionErrors.shorthandAssignLoc === null) {
|
refExpressionErrors.shorthandAssignLoc = shorthandAssignLoc;
|
}
|
} else {
|
this.raise(Errors.InvalidCoverInitializedName, {
|
at: shorthandAssignLoc
|
});
|
}
|
prop.value = this.parseMaybeDefault(startLoc, cloneIdentifier(prop.key));
|
} else {
|
prop.value = cloneIdentifier(prop.key);
|
}
|
prop.shorthand = true;
|
return this.finishNode(prop, "ObjectProperty");
|
}
|
}
|
parseObjPropValue(prop, startLoc, isGenerator, isAsync, isPattern, isAccessor, refExpressionErrors) {
|
const node = this.parseObjectMethod(prop, isGenerator, isAsync, isPattern, isAccessor) || this.parseObjectProperty(prop, startLoc, isPattern, refExpressionErrors);
|
if (!node) this.unexpected();
|
return node;
|
}
|
parsePropertyName(prop, refExpressionErrors) {
|
if (this.eat(0)) {
|
prop.computed = true;
|
prop.key = this.parseMaybeAssignAllowIn();
|
this.expect(3);
|
} else {
|
const {
|
type,
|
value
|
} = this.state;
|
let key;
|
if (tokenIsKeywordOrIdentifier(type)) {
|
key = this.parseIdentifier(true);
|
} else {
|
switch (type) {
|
case 132:
|
key = this.parseNumericLiteral(value);
|
break;
|
case 131:
|
key = this.parseStringLiteral(value);
|
break;
|
case 133:
|
key = this.parseBigIntLiteral(value);
|
break;
|
case 134:
|
key = this.parseDecimalLiteral(value);
|
break;
|
case 136:
|
{
|
const privateKeyLoc = this.state.startLoc;
|
if (refExpressionErrors != null) {
|
if (refExpressionErrors.privateKeyLoc === null) {
|
refExpressionErrors.privateKeyLoc = privateKeyLoc;
|
}
|
} else {
|
this.raise(Errors.UnexpectedPrivateField, {
|
at: privateKeyLoc
|
});
|
}
|
key = this.parsePrivateName();
|
break;
|
}
|
default:
|
this.unexpected();
|
}
|
}
|
prop.key = key;
|
if (type !== 136) {
|
prop.computed = false;
|
}
|
}
|
return prop.key;
|
}
|
initFunction(node, isAsync) {
|
node.id = null;
|
node.generator = false;
|
node.async = isAsync;
|
}
|
parseMethod(node, isGenerator, isAsync, isConstructor, allowDirectSuper, type, inClassScope = false) {
|
this.initFunction(node, isAsync);
|
node.generator = isGenerator;
|
this.scope.enter(SCOPE_FUNCTION | SCOPE_SUPER | (inClassScope ? SCOPE_CLASS : 0) | (allowDirectSuper ? SCOPE_DIRECT_SUPER : 0));
|
this.prodParam.enter(functionFlags(isAsync, node.generator));
|
this.parseFunctionParams(node, isConstructor);
|
const finishedNode = this.parseFunctionBodyAndFinish(node, type, true);
|
this.prodParam.exit();
|
this.scope.exit();
|
return finishedNode;
|
}
|
parseArrayLike(close, canBePattern, isTuple, refExpressionErrors) {
|
if (isTuple) {
|
this.expectPlugin("recordAndTuple");
|
}
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
|
this.state.inFSharpPipelineDirectBody = false;
|
const node = this.startNode();
|
this.next();
|
node.elements = this.parseExprList(close, !isTuple, refExpressionErrors, node);
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
|
return this.finishNode(node, isTuple ? "TupleExpression" : "ArrayExpression");
|
}
|
parseArrowExpression(node, params, isAsync, trailingCommaLoc) {
|
this.scope.enter(SCOPE_FUNCTION | SCOPE_ARROW);
|
let flags = functionFlags(isAsync, false);
|
if (!this.match(5) && this.prodParam.hasIn) {
|
flags |= PARAM_IN;
|
}
|
this.prodParam.enter(flags);
|
this.initFunction(node, isAsync);
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
|
if (params) {
|
this.state.maybeInArrowParameters = true;
|
this.setArrowFunctionParameters(node, params, trailingCommaLoc);
|
}
|
this.state.maybeInArrowParameters = false;
|
this.parseFunctionBody(node, true);
|
this.prodParam.exit();
|
this.scope.exit();
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
|
return this.finishNode(node, "ArrowFunctionExpression");
|
}
|
setArrowFunctionParameters(node, params, trailingCommaLoc) {
|
this.toAssignableList(params, trailingCommaLoc, false);
|
node.params = params;
|
}
|
parseFunctionBodyAndFinish(node, type, isMethod = false) {
|
this.parseFunctionBody(node, false, isMethod);
|
return this.finishNode(node, type);
|
}
|
parseFunctionBody(node, allowExpression, isMethod = false) {
|
const isExpression = allowExpression && !this.match(5);
|
this.expressionScope.enter(newExpressionScope());
|
if (isExpression) {
|
node.body = this.parseMaybeAssign();
|
this.checkParams(node, false, allowExpression, false);
|
} else {
|
const oldStrict = this.state.strict;
|
const oldLabels = this.state.labels;
|
this.state.labels = [];
|
this.prodParam.enter(this.prodParam.currentFlags() | PARAM_RETURN);
|
node.body = this.parseBlock(true, false, hasStrictModeDirective => {
|
const nonSimple = !this.isSimpleParamList(node.params);
|
if (hasStrictModeDirective && nonSimple) {
|
this.raise(Errors.IllegalLanguageModeDirective, {
|
at: (node.kind === "method" || node.kind === "constructor") && !!node.key ? node.key.loc.end : node
|
});
|
}
|
const strictModeChanged = !oldStrict && this.state.strict;
|
this.checkParams(node, !this.state.strict && !allowExpression && !isMethod && !nonSimple, allowExpression, strictModeChanged);
|
if (this.state.strict && node.id) {
|
this.checkIdentifier(node.id, BIND_OUTSIDE, strictModeChanged);
|
}
|
});
|
this.prodParam.exit();
|
this.state.labels = oldLabels;
|
}
|
this.expressionScope.exit();
|
}
|
isSimpleParameter(node) {
|
return node.type === "Identifier";
|
}
|
isSimpleParamList(params) {
|
for (let i = 0, len = params.length; i < len; i++) {
|
if (!this.isSimpleParameter(params[i])) return false;
|
}
|
return true;
|
}
|
checkParams(node, allowDuplicates, isArrowFunction, strictModeChanged = true) {
|
const checkClashes = !allowDuplicates && new Set();
|
const formalParameters = {
|
type: "FormalParameters"
|
};
|
for (const param of node.params) {
|
this.checkLVal(param, {
|
in: formalParameters,
|
binding: BIND_VAR,
|
checkClashes,
|
strictModeChanged
|
});
|
}
|
}
|
parseExprList(close, allowEmpty, refExpressionErrors, nodeForExtra) {
|
const elts = [];
|
let first = true;
|
while (!this.eat(close)) {
|
if (first) {
|
first = false;
|
} else {
|
this.expect(12);
|
if (this.match(close)) {
|
if (nodeForExtra) {
|
this.addTrailingCommaExtraToNode(nodeForExtra);
|
}
|
this.next();
|
break;
|
}
|
}
|
elts.push(this.parseExprListItem(allowEmpty, refExpressionErrors));
|
}
|
return elts;
|
}
|
parseExprListItem(allowEmpty, refExpressionErrors, allowPlaceholder) {
|
let elt;
|
if (this.match(12)) {
|
if (!allowEmpty) {
|
this.raise(Errors.UnexpectedToken, {
|
at: this.state.curPosition(),
|
unexpected: ","
|
});
|
}
|
elt = null;
|
} else if (this.match(21)) {
|
const spreadNodeStartLoc = this.state.startLoc;
|
elt = this.parseParenItem(this.parseSpread(refExpressionErrors), spreadNodeStartLoc);
|
} else if (this.match(17)) {
|
this.expectPlugin("partialApplication");
|
if (!allowPlaceholder) {
|
this.raise(Errors.UnexpectedArgumentPlaceholder, {
|
at: this.state.startLoc
|
});
|
}
|
const node = this.startNode();
|
this.next();
|
elt = this.finishNode(node, "ArgumentPlaceholder");
|
} else {
|
elt = this.parseMaybeAssignAllowIn(refExpressionErrors, this.parseParenItem);
|
}
|
return elt;
|
}
|
parseIdentifier(liberal) {
|
const node = this.startNode();
|
const name = this.parseIdentifierName(liberal);
|
return this.createIdentifier(node, name);
|
}
|
createIdentifier(node, name) {
|
node.name = name;
|
node.loc.identifierName = name;
|
return this.finishNode(node, "Identifier");
|
}
|
parseIdentifierName(liberal) {
|
let name;
|
const {
|
startLoc,
|
type
|
} = this.state;
|
if (tokenIsKeywordOrIdentifier(type)) {
|
name = this.state.value;
|
} else {
|
this.unexpected();
|
}
|
const tokenIsKeyword = tokenKeywordOrIdentifierIsKeyword(type);
|
if (liberal) {
|
if (tokenIsKeyword) {
|
this.replaceToken(130);
|
}
|
} else {
|
this.checkReservedWord(name, startLoc, tokenIsKeyword, false);
|
}
|
this.next();
|
return name;
|
}
|
checkReservedWord(word, startLoc, checkKeywords, isBinding) {
|
if (word.length > 10) {
|
return;
|
}
|
if (!canBeReservedWord(word)) {
|
return;
|
}
|
if (checkKeywords && isKeyword(word)) {
|
this.raise(Errors.UnexpectedKeyword, {
|
at: startLoc,
|
keyword: word
|
});
|
return;
|
}
|
const reservedTest = !this.state.strict ? isReservedWord : isBinding ? isStrictBindReservedWord : isStrictReservedWord;
|
if (reservedTest(word, this.inModule)) {
|
this.raise(Errors.UnexpectedReservedWord, {
|
at: startLoc,
|
reservedWord: word
|
});
|
return;
|
} else if (word === "yield") {
|
if (this.prodParam.hasYield) {
|
this.raise(Errors.YieldBindingIdentifier, {
|
at: startLoc
|
});
|
return;
|
}
|
} else if (word === "await") {
|
if (this.prodParam.hasAwait) {
|
this.raise(Errors.AwaitBindingIdentifier, {
|
at: startLoc
|
});
|
return;
|
}
|
if (this.scope.inStaticBlock) {
|
this.raise(Errors.AwaitBindingIdentifierInStaticBlock, {
|
at: startLoc
|
});
|
return;
|
}
|
this.expressionScope.recordAsyncArrowParametersError({
|
at: startLoc
|
});
|
} else if (word === "arguments") {
|
if (this.scope.inClassAndNotInNonArrowFunction) {
|
this.raise(Errors.ArgumentsInClass, {
|
at: startLoc
|
});
|
return;
|
}
|
}
|
}
|
isAwaitAllowed() {
|
if (this.prodParam.hasAwait) return true;
|
if (this.options.allowAwaitOutsideFunction && !this.scope.inFunction) {
|
return true;
|
}
|
return false;
|
}
|
parseAwait(startLoc) {
|
const node = this.startNodeAt(startLoc);
|
this.expressionScope.recordParameterInitializerError(Errors.AwaitExpressionFormalParameter, {
|
at: node
|
});
|
if (this.eat(55)) {
|
this.raise(Errors.ObsoleteAwaitStar, {
|
at: node
|
});
|
}
|
if (!this.scope.inFunction && !this.options.allowAwaitOutsideFunction) {
|
if (this.isAmbiguousAwait()) {
|
this.ambiguousScriptDifferentAst = true;
|
} else {
|
this.sawUnambiguousESM = true;
|
}
|
}
|
if (!this.state.soloAwait) {
|
node.argument = this.parseMaybeUnary(null, true);
|
}
|
return this.finishNode(node, "AwaitExpression");
|
}
|
isAmbiguousAwait() {
|
if (this.hasPrecedingLineBreak()) return true;
|
const {
|
type
|
} = this.state;
|
return type === 53 || type === 10 || type === 0 || tokenIsTemplate(type) || type === 101 && !this.state.containsEsc || type === 135 || type === 56 || this.hasPlugin("v8intrinsic") && type === 54;
|
}
|
parseYield() {
|
const node = this.startNode();
|
this.expressionScope.recordParameterInitializerError(Errors.YieldInParameter, {
|
at: node
|
});
|
this.next();
|
let delegating = false;
|
let argument = null;
|
if (!this.hasPrecedingLineBreak()) {
|
delegating = this.eat(55);
|
switch (this.state.type) {
|
case 13:
|
case 137:
|
case 8:
|
case 11:
|
case 3:
|
case 9:
|
case 14:
|
case 12:
|
if (!delegating) break;
|
default:
|
argument = this.parseMaybeAssign();
|
}
|
}
|
node.delegate = delegating;
|
node.argument = argument;
|
return this.finishNode(node, "YieldExpression");
|
}
|
checkPipelineAtInfixOperator(left, leftStartLoc) {
|
if (this.hasPlugin(["pipelineOperator", {
|
proposal: "smart"
|
}])) {
|
if (left.type === "SequenceExpression") {
|
this.raise(Errors.PipelineHeadSequenceExpression, {
|
at: leftStartLoc
|
});
|
}
|
}
|
}
|
parseSmartPipelineBodyInStyle(childExpr, startLoc) {
|
if (this.isSimpleReference(childExpr)) {
|
const bodyNode = this.startNodeAt(startLoc);
|
bodyNode.callee = childExpr;
|
return this.finishNode(bodyNode, "PipelineBareFunction");
|
} else {
|
const bodyNode = this.startNodeAt(startLoc);
|
this.checkSmartPipeTopicBodyEarlyErrors(startLoc);
|
bodyNode.expression = childExpr;
|
return this.finishNode(bodyNode, "PipelineTopicExpression");
|
}
|
}
|
isSimpleReference(expression) {
|
switch (expression.type) {
|
case "MemberExpression":
|
return !expression.computed && this.isSimpleReference(expression.object);
|
case "Identifier":
|
return true;
|
default:
|
return false;
|
}
|
}
|
checkSmartPipeTopicBodyEarlyErrors(startLoc) {
|
if (this.match(19)) {
|
throw this.raise(Errors.PipelineBodyNoArrow, {
|
at: this.state.startLoc
|
});
|
}
|
if (!this.topicReferenceWasUsedInCurrentContext()) {
|
this.raise(Errors.PipelineTopicUnused, {
|
at: startLoc
|
});
|
}
|
}
|
withTopicBindingContext(callback) {
|
const outerContextTopicState = this.state.topicContext;
|
this.state.topicContext = {
|
maxNumOfResolvableTopics: 1,
|
maxTopicIndex: null
|
};
|
try {
|
return callback();
|
} finally {
|
this.state.topicContext = outerContextTopicState;
|
}
|
}
|
withSmartMixTopicForbiddingContext(callback) {
|
if (this.hasPlugin(["pipelineOperator", {
|
proposal: "smart"
|
}])) {
|
const outerContextTopicState = this.state.topicContext;
|
this.state.topicContext = {
|
maxNumOfResolvableTopics: 0,
|
maxTopicIndex: null
|
};
|
try {
|
return callback();
|
} finally {
|
this.state.topicContext = outerContextTopicState;
|
}
|
} else {
|
return callback();
|
}
|
}
|
withSoloAwaitPermittingContext(callback) {
|
const outerContextSoloAwaitState = this.state.soloAwait;
|
this.state.soloAwait = true;
|
try {
|
return callback();
|
} finally {
|
this.state.soloAwait = outerContextSoloAwaitState;
|
}
|
}
|
allowInAnd(callback) {
|
const flags = this.prodParam.currentFlags();
|
const prodParamToSet = PARAM_IN & ~flags;
|
if (prodParamToSet) {
|
this.prodParam.enter(flags | PARAM_IN);
|
try {
|
return callback();
|
} finally {
|
this.prodParam.exit();
|
}
|
}
|
return callback();
|
}
|
disallowInAnd(callback) {
|
const flags = this.prodParam.currentFlags();
|
const prodParamToClear = PARAM_IN & flags;
|
if (prodParamToClear) {
|
this.prodParam.enter(flags & ~PARAM_IN);
|
try {
|
return callback();
|
} finally {
|
this.prodParam.exit();
|
}
|
}
|
return callback();
|
}
|
registerTopicReference() {
|
this.state.topicContext.maxTopicIndex = 0;
|
}
|
topicReferenceIsAllowedInCurrentContext() {
|
return this.state.topicContext.maxNumOfResolvableTopics >= 1;
|
}
|
topicReferenceWasUsedInCurrentContext() {
|
return this.state.topicContext.maxTopicIndex != null && this.state.topicContext.maxTopicIndex >= 0;
|
}
|
parseFSharpPipelineBody(prec) {
|
const startLoc = this.state.startLoc;
|
this.state.potentialArrowAt = this.state.start;
|
const oldInFSharpPipelineDirectBody = this.state.inFSharpPipelineDirectBody;
|
this.state.inFSharpPipelineDirectBody = true;
|
const ret = this.parseExprOp(this.parseMaybeUnaryOrPrivate(), startLoc, prec);
|
this.state.inFSharpPipelineDirectBody = oldInFSharpPipelineDirectBody;
|
return ret;
|
}
|
parseModuleExpression() {
|
this.expectPlugin("moduleBlocks");
|
const node = this.startNode();
|
this.next();
|
if (!this.match(5)) {
|
this.unexpected(null, 5);
|
}
|
const program = this.startNodeAt(this.state.endLoc);
|
this.next();
|
const revertScopes = this.initializeScopes(true);
|
this.enterInitialScopes();
|
try {
|
node.body = this.parseProgram(program, 8, "module");
|
} finally {
|
revertScopes();
|
}
|
return this.finishNode(node, "ModuleExpression");
|
}
|
parsePropertyNamePrefixOperator(prop) {}
|
}
|
const loopLabel = {
|
kind: "loop"
|
},
|
switchLabel = {
|
kind: "switch"
|
};
|
const loneSurrogate = /[\uD800-\uDFFF]/u;
|
const keywordRelationalOperator = /in(?:stanceof)?/y;
|
function babel7CompatTokens(tokens, input) {
|
for (let i = 0; i < tokens.length; i++) {
|
const token = tokens[i];
|
const {
|
type
|
} = token;
|
if (typeof type === "number") {
|
{
|
if (type === 136) {
|
const {
|
loc,
|
start,
|
value,
|
end
|
} = token;
|
const hashEndPos = start + 1;
|
const hashEndLoc = createPositionWithColumnOffset(loc.start, 1);
|
tokens.splice(i, 1, new Token({
|
type: getExportedToken(27),
|
value: "#",
|
start: start,
|
end: hashEndPos,
|
startLoc: loc.start,
|
endLoc: hashEndLoc
|
}), new Token({
|
type: getExportedToken(130),
|
value: value,
|
start: hashEndPos,
|
end: end,
|
startLoc: hashEndLoc,
|
endLoc: loc.end
|
}));
|
i++;
|
continue;
|
}
|
if (tokenIsTemplate(type)) {
|
const {
|
loc,
|
start,
|
value,
|
end
|
} = token;
|
const backquoteEnd = start + 1;
|
const backquoteEndLoc = createPositionWithColumnOffset(loc.start, 1);
|
let startToken;
|
if (input.charCodeAt(start) === 96) {
|
startToken = new Token({
|
type: getExportedToken(22),
|
value: "`",
|
start: start,
|
end: backquoteEnd,
|
startLoc: loc.start,
|
endLoc: backquoteEndLoc
|
});
|
} else {
|
startToken = new Token({
|
type: getExportedToken(8),
|
value: "}",
|
start: start,
|
end: backquoteEnd,
|
startLoc: loc.start,
|
endLoc: backquoteEndLoc
|
});
|
}
|
let templateValue, templateElementEnd, templateElementEndLoc, endToken;
|
if (type === 24) {
|
templateElementEnd = end - 1;
|
templateElementEndLoc = createPositionWithColumnOffset(loc.end, -1);
|
templateValue = value === null ? null : value.slice(1, -1);
|
endToken = new Token({
|
type: getExportedToken(22),
|
value: "`",
|
start: templateElementEnd,
|
end: end,
|
startLoc: templateElementEndLoc,
|
endLoc: loc.end
|
});
|
} else {
|
templateElementEnd = end - 2;
|
templateElementEndLoc = createPositionWithColumnOffset(loc.end, -2);
|
templateValue = value === null ? null : value.slice(1, -2);
|
endToken = new Token({
|
type: getExportedToken(23),
|
value: "${",
|
start: templateElementEnd,
|
end: end,
|
startLoc: templateElementEndLoc,
|
endLoc: loc.end
|
});
|
}
|
tokens.splice(i, 1, startToken, new Token({
|
type: getExportedToken(20),
|
value: templateValue,
|
start: backquoteEnd,
|
end: templateElementEnd,
|
startLoc: backquoteEndLoc,
|
endLoc: templateElementEndLoc
|
}), endToken);
|
i += 2;
|
continue;
|
}
|
}
|
token.type = getExportedToken(type);
|
}
|
}
|
return tokens;
|
}
|
class StatementParser extends ExpressionParser {
|
parseTopLevel(file, program) {
|
file.program = this.parseProgram(program);
|
file.comments = this.state.comments;
|
if (this.options.tokens) {
|
file.tokens = babel7CompatTokens(this.tokens, this.input);
|
}
|
return this.finishNode(file, "File");
|
}
|
parseProgram(program, end = 137, sourceType = this.options.sourceType) {
|
program.sourceType = sourceType;
|
program.interpreter = this.parseInterpreterDirective();
|
this.parseBlockBody(program, true, true, end);
|
if (this.inModule && !this.options.allowUndeclaredExports && this.scope.undefinedExports.size > 0) {
|
for (const [localName, at] of Array.from(this.scope.undefinedExports)) {
|
this.raise(Errors.ModuleExportUndefined, {
|
at,
|
localName
|
});
|
}
|
}
|
let finishedProgram;
|
if (end === 137) {
|
finishedProgram = this.finishNode(program, "Program");
|
} else {
|
finishedProgram = this.finishNodeAt(program, "Program", createPositionWithColumnOffset(this.state.startLoc, -1));
|
}
|
return finishedProgram;
|
}
|
stmtToDirective(stmt) {
|
const directive = stmt;
|
directive.type = "Directive";
|
directive.value = directive.expression;
|
delete directive.expression;
|
const directiveLiteral = directive.value;
|
const expressionValue = directiveLiteral.value;
|
const raw = this.input.slice(directiveLiteral.start, directiveLiteral.end);
|
const val = directiveLiteral.value = raw.slice(1, -1);
|
this.addExtra(directiveLiteral, "raw", raw);
|
this.addExtra(directiveLiteral, "rawValue", val);
|
this.addExtra(directiveLiteral, "expressionValue", expressionValue);
|
directiveLiteral.type = "DirectiveLiteral";
|
return directive;
|
}
|
parseInterpreterDirective() {
|
if (!this.match(28)) {
|
return null;
|
}
|
const node = this.startNode();
|
node.value = this.state.value;
|
this.next();
|
return this.finishNode(node, "InterpreterDirective");
|
}
|
isLet() {
|
if (!this.isContextual(99)) {
|
return false;
|
}
|
return this.hasFollowingBindingAtom();
|
}
|
chStartsBindingIdentifier(ch, pos) {
|
if (isIdentifierStart(ch)) {
|
keywordRelationalOperator.lastIndex = pos;
|
if (keywordRelationalOperator.test(this.input)) {
|
const endCh = this.codePointAtPos(keywordRelationalOperator.lastIndex);
|
if (!isIdentifierChar(endCh) && endCh !== 92) {
|
return false;
|
}
|
}
|
return true;
|
} else if (ch === 92) {
|
return true;
|
} else {
|
return false;
|
}
|
}
|
chStartsBindingPattern(ch) {
|
return ch === 91 || ch === 123;
|
}
|
hasFollowingBindingAtom() {
|
const next = this.nextTokenStart();
|
const nextCh = this.codePointAtPos(next);
|
return this.chStartsBindingPattern(nextCh) || this.chStartsBindingIdentifier(nextCh, next);
|
}
|
hasFollowingBindingIdentifier() {
|
const next = this.nextTokenStart();
|
const nextCh = this.codePointAtPos(next);
|
return this.chStartsBindingIdentifier(nextCh, next);
|
}
|
startsUsingForOf() {
|
const lookahead = this.lookahead();
|
if (lookahead.type === 101 && !lookahead.containsEsc) {
|
return false;
|
} else {
|
this.expectPlugin("explicitResourceManagement");
|
return true;
|
}
|
}
|
parseModuleItem() {
|
return this.parseStatementLike(1 | 2 | 4 | 8);
|
}
|
parseStatementListItem() {
|
return this.parseStatementLike(2 | 4 | (!this.options.annexB || this.state.strict ? 0 : 8));
|
}
|
parseStatementOrSloppyAnnexBFunctionDeclaration(allowLabeledFunction = false) {
|
let flags = 0;
|
if (this.options.annexB && !this.state.strict) {
|
flags |= 4;
|
if (allowLabeledFunction) {
|
flags |= 8;
|
}
|
}
|
return this.parseStatementLike(flags);
|
}
|
parseStatement() {
|
return this.parseStatementLike(0);
|
}
|
parseStatementLike(flags) {
|
let decorators = null;
|
if (this.match(26)) {
|
decorators = this.parseDecorators(true);
|
}
|
return this.parseStatementContent(flags, decorators);
|
}
|
parseStatementContent(flags, decorators) {
|
const starttype = this.state.type;
|
const node = this.startNode();
|
const allowDeclaration = !!(flags & 2);
|
const allowFunctionDeclaration = !!(flags & 4);
|
const topLevel = flags & 1;
|
switch (starttype) {
|
case 60:
|
return this.parseBreakContinueStatement(node, true);
|
case 63:
|
return this.parseBreakContinueStatement(node, false);
|
case 64:
|
return this.parseDebuggerStatement(node);
|
case 90:
|
return this.parseDoWhileStatement(node);
|
case 91:
|
return this.parseForStatement(node);
|
case 68:
|
if (this.lookaheadCharCode() === 46) break;
|
if (!allowFunctionDeclaration) {
|
this.raise(this.state.strict ? Errors.StrictFunction : this.options.annexB ? Errors.SloppyFunctionAnnexB : Errors.SloppyFunction, {
|
at: this.state.startLoc
|
});
|
}
|
return this.parseFunctionStatement(node, false, !allowDeclaration && allowFunctionDeclaration);
|
case 80:
|
if (!allowDeclaration) this.unexpected();
|
return this.parseClass(this.maybeTakeDecorators(decorators, node), true);
|
case 69:
|
return this.parseIfStatement(node);
|
case 70:
|
return this.parseReturnStatement(node);
|
case 71:
|
return this.parseSwitchStatement(node);
|
case 72:
|
return this.parseThrowStatement(node);
|
case 73:
|
return this.parseTryStatement(node);
|
case 105:
|
if (this.hasFollowingLineBreak() || this.state.containsEsc || !this.hasFollowingBindingIdentifier()) {
|
break;
|
}
|
this.expectPlugin("explicitResourceManagement");
|
if (!this.scope.inModule && this.scope.inTopLevel) {
|
this.raise(Errors.UnexpectedUsingDeclaration, {
|
at: this.state.startLoc
|
});
|
} else if (!allowDeclaration) {
|
this.raise(Errors.UnexpectedLexicalDeclaration, {
|
at: this.state.startLoc
|
});
|
}
|
return this.parseVarStatement(node, "using");
|
case 99:
|
{
|
if (this.state.containsEsc) {
|
break;
|
}
|
const next = this.nextTokenStart();
|
const nextCh = this.codePointAtPos(next);
|
if (nextCh !== 91) {
|
if (!allowDeclaration && this.hasFollowingLineBreak()) break;
|
if (!this.chStartsBindingIdentifier(nextCh, next) && nextCh !== 123) {
|
break;
|
}
|
}
|
}
|
case 75:
|
{
|
if (!allowDeclaration) {
|
this.raise(Errors.UnexpectedLexicalDeclaration, {
|
at: this.state.startLoc
|
});
|
}
|
}
|
case 74:
|
{
|
const kind = this.state.value;
|
return this.parseVarStatement(node, kind);
|
}
|
case 92:
|
return this.parseWhileStatement(node);
|
case 76:
|
return this.parseWithStatement(node);
|
case 5:
|
return this.parseBlock();
|
case 13:
|
return this.parseEmptyStatement(node);
|
case 83:
|
{
|
const nextTokenCharCode = this.lookaheadCharCode();
|
if (nextTokenCharCode === 40 || nextTokenCharCode === 46) {
|
break;
|
}
|
}
|
case 82:
|
{
|
if (!this.options.allowImportExportEverywhere && !topLevel) {
|
this.raise(Errors.UnexpectedImportExport, {
|
at: this.state.startLoc
|
});
|
}
|
this.next();
|
let result;
|
if (starttype === 83) {
|
result = this.parseImport(node);
|
if (result.type === "ImportDeclaration" && (!result.importKind || result.importKind === "value")) {
|
this.sawUnambiguousESM = true;
|
}
|
} else {
|
result = this.parseExport(node, decorators);
|
if (result.type === "ExportNamedDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportAllDeclaration" && (!result.exportKind || result.exportKind === "value") || result.type === "ExportDefaultDeclaration") {
|
this.sawUnambiguousESM = true;
|
}
|
}
|
this.assertModuleNodeAllowed(result);
|
return result;
|
}
|
default:
|
{
|
if (this.isAsyncFunction()) {
|
if (!allowDeclaration) {
|
this.raise(Errors.AsyncFunctionInSingleStatementContext, {
|
at: this.state.startLoc
|
});
|
}
|
this.next();
|
return this.parseFunctionStatement(node, true, !allowDeclaration && allowFunctionDeclaration);
|
}
|
}
|
}
|
const maybeName = this.state.value;
|
const expr = this.parseExpression();
|
if (tokenIsIdentifier(starttype) && expr.type === "Identifier" && this.eat(14)) {
|
return this.parseLabeledStatement(node, maybeName, expr, flags);
|
} else {
|
return this.parseExpressionStatement(node, expr, decorators);
|
}
|
}
|
assertModuleNodeAllowed(node) {
|
if (!this.options.allowImportExportEverywhere && !this.inModule) {
|
this.raise(Errors.ImportOutsideModule, {
|
at: node
|
});
|
}
|
}
|
decoratorsEnabledBeforeExport() {
|
if (this.hasPlugin("decorators-legacy")) return true;
|
return this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") !== false;
|
}
|
maybeTakeDecorators(maybeDecorators, classNode, exportNode) {
|
if (maybeDecorators) {
|
if (classNode.decorators && classNode.decorators.length > 0) {
|
if (typeof this.getPluginOption("decorators", "decoratorsBeforeExport") !== "boolean") {
|
this.raise(Errors.DecoratorsBeforeAfterExport, {
|
at: classNode.decorators[0]
|
});
|
}
|
classNode.decorators.unshift(...maybeDecorators);
|
} else {
|
classNode.decorators = maybeDecorators;
|
}
|
this.resetStartLocationFromNode(classNode, maybeDecorators[0]);
|
if (exportNode) this.resetStartLocationFromNode(exportNode, classNode);
|
}
|
return classNode;
|
}
|
canHaveLeadingDecorator() {
|
return this.match(80);
|
}
|
parseDecorators(allowExport) {
|
const decorators = [];
|
do {
|
decorators.push(this.parseDecorator());
|
} while (this.match(26));
|
if (this.match(82)) {
|
if (!allowExport) {
|
this.unexpected();
|
}
|
if (!this.decoratorsEnabledBeforeExport()) {
|
this.raise(Errors.DecoratorExportClass, {
|
at: this.state.startLoc
|
});
|
}
|
} else if (!this.canHaveLeadingDecorator()) {
|
throw this.raise(Errors.UnexpectedLeadingDecorator, {
|
at: this.state.startLoc
|
});
|
}
|
return decorators;
|
}
|
parseDecorator() {
|
this.expectOnePlugin(["decorators", "decorators-legacy"]);
|
const node = this.startNode();
|
this.next();
|
if (this.hasPlugin("decorators")) {
|
const startLoc = this.state.startLoc;
|
let expr;
|
if (this.match(10)) {
|
const startLoc = this.state.startLoc;
|
this.next();
|
expr = this.parseExpression();
|
this.expect(11);
|
expr = this.wrapParenthesis(startLoc, expr);
|
const paramsStartLoc = this.state.startLoc;
|
node.expression = this.parseMaybeDecoratorArguments(expr);
|
if (this.getPluginOption("decorators", "allowCallParenthesized") === false && node.expression !== expr) {
|
this.raise(Errors.DecoratorArgumentsOutsideParentheses, {
|
at: paramsStartLoc
|
});
|
}
|
} else {
|
expr = this.parseIdentifier(false);
|
while (this.eat(16)) {
|
const node = this.startNodeAt(startLoc);
|
node.object = expr;
|
if (this.match(136)) {
|
this.classScope.usePrivateName(this.state.value, this.state.startLoc);
|
node.property = this.parsePrivateName();
|
} else {
|
node.property = this.parseIdentifier(true);
|
}
|
node.computed = false;
|
expr = this.finishNode(node, "MemberExpression");
|
}
|
node.expression = this.parseMaybeDecoratorArguments(expr);
|
}
|
} else {
|
node.expression = this.parseExprSubscripts();
|
}
|
return this.finishNode(node, "Decorator");
|
}
|
parseMaybeDecoratorArguments(expr) {
|
if (this.eat(10)) {
|
const node = this.startNodeAtNode(expr);
|
node.callee = expr;
|
node.arguments = this.parseCallExpressionArguments(11, false);
|
this.toReferencedList(node.arguments);
|
return this.finishNode(node, "CallExpression");
|
}
|
return expr;
|
}
|
parseBreakContinueStatement(node, isBreak) {
|
this.next();
|
if (this.isLineTerminator()) {
|
node.label = null;
|
} else {
|
node.label = this.parseIdentifier();
|
this.semicolon();
|
}
|
this.verifyBreakContinue(node, isBreak);
|
return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
|
}
|
verifyBreakContinue(node, isBreak) {
|
let i;
|
for (i = 0; i < this.state.labels.length; ++i) {
|
const lab = this.state.labels[i];
|
if (node.label == null || lab.name === node.label.name) {
|
if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
|
if (node.label && isBreak) break;
|
}
|
}
|
if (i === this.state.labels.length) {
|
const type = isBreak ? "BreakStatement" : "ContinueStatement";
|
this.raise(Errors.IllegalBreakContinue, {
|
at: node,
|
type
|
});
|
}
|
}
|
parseDebuggerStatement(node) {
|
this.next();
|
this.semicolon();
|
return this.finishNode(node, "DebuggerStatement");
|
}
|
parseHeaderExpression() {
|
this.expect(10);
|
const val = this.parseExpression();
|
this.expect(11);
|
return val;
|
}
|
parseDoWhileStatement(node) {
|
this.next();
|
this.state.labels.push(loopLabel);
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
|
this.state.labels.pop();
|
this.expect(92);
|
node.test = this.parseHeaderExpression();
|
this.eat(13);
|
return this.finishNode(node, "DoWhileStatement");
|
}
|
parseForStatement(node) {
|
this.next();
|
this.state.labels.push(loopLabel);
|
let awaitAt = null;
|
if (this.isAwaitAllowed() && this.eatContextual(96)) {
|
awaitAt = this.state.lastTokStartLoc;
|
}
|
this.scope.enter(SCOPE_OTHER);
|
this.expect(10);
|
if (this.match(13)) {
|
if (awaitAt !== null) {
|
this.unexpected(awaitAt);
|
}
|
return this.parseFor(node, null);
|
}
|
const startsWithLet = this.isContextual(99);
|
const startsWithUsing = this.isContextual(105) && !this.hasFollowingLineBreak();
|
const isLetOrUsing = startsWithLet && this.hasFollowingBindingAtom() || startsWithUsing && this.hasFollowingBindingIdentifier() && this.startsUsingForOf();
|
if (this.match(74) || this.match(75) || isLetOrUsing) {
|
const initNode = this.startNode();
|
const kind = this.state.value;
|
this.next();
|
this.parseVar(initNode, true, kind);
|
const init = this.finishNode(initNode, "VariableDeclaration");
|
const isForIn = this.match(58);
|
if (isForIn && startsWithUsing) {
|
this.raise(Errors.ForInUsing, {
|
at: init
|
});
|
}
|
if ((isForIn || this.isContextual(101)) && init.declarations.length === 1) {
|
return this.parseForIn(node, init, awaitAt);
|
}
|
if (awaitAt !== null) {
|
this.unexpected(awaitAt);
|
}
|
return this.parseFor(node, init);
|
}
|
const startsWithAsync = this.isContextual(95);
|
const refExpressionErrors = new ExpressionErrors();
|
const init = this.parseExpression(true, refExpressionErrors);
|
const isForOf = this.isContextual(101);
|
if (isForOf) {
|
if (startsWithLet) {
|
this.raise(Errors.ForOfLet, {
|
at: init
|
});
|
}
|
if (awaitAt === null && startsWithAsync && init.type === "Identifier") {
|
this.raise(Errors.ForOfAsync, {
|
at: init
|
});
|
}
|
}
|
if (isForOf || this.match(58)) {
|
this.checkDestructuringPrivate(refExpressionErrors);
|
this.toAssignable(init, true);
|
const type = isForOf ? "ForOfStatement" : "ForInStatement";
|
this.checkLVal(init, {
|
in: {
|
type
|
}
|
});
|
return this.parseForIn(node, init, awaitAt);
|
} else {
|
this.checkExpressionErrors(refExpressionErrors, true);
|
}
|
if (awaitAt !== null) {
|
this.unexpected(awaitAt);
|
}
|
return this.parseFor(node, init);
|
}
|
parseFunctionStatement(node, isAsync, isHangingDeclaration) {
|
this.next();
|
return this.parseFunction(node, 1 | (isHangingDeclaration ? 2 : 0) | (isAsync ? 8 : 0));
|
}
|
parseIfStatement(node) {
|
this.next();
|
node.test = this.parseHeaderExpression();
|
node.consequent = this.parseStatementOrSloppyAnnexBFunctionDeclaration();
|
node.alternate = this.eat(66) ? this.parseStatementOrSloppyAnnexBFunctionDeclaration() : null;
|
return this.finishNode(node, "IfStatement");
|
}
|
parseReturnStatement(node) {
|
if (!this.prodParam.hasReturn && !this.options.allowReturnOutsideFunction) {
|
this.raise(Errors.IllegalReturn, {
|
at: this.state.startLoc
|
});
|
}
|
this.next();
|
if (this.isLineTerminator()) {
|
node.argument = null;
|
} else {
|
node.argument = this.parseExpression();
|
this.semicolon();
|
}
|
return this.finishNode(node, "ReturnStatement");
|
}
|
parseSwitchStatement(node) {
|
this.next();
|
node.discriminant = this.parseHeaderExpression();
|
const cases = node.cases = [];
|
this.expect(5);
|
this.state.labels.push(switchLabel);
|
this.scope.enter(SCOPE_OTHER);
|
let cur;
|
for (let sawDefault; !this.match(8);) {
|
if (this.match(61) || this.match(65)) {
|
const isCase = this.match(61);
|
if (cur) this.finishNode(cur, "SwitchCase");
|
cases.push(cur = this.startNode());
|
cur.consequent = [];
|
this.next();
|
if (isCase) {
|
cur.test = this.parseExpression();
|
} else {
|
if (sawDefault) {
|
this.raise(Errors.MultipleDefaultsInSwitch, {
|
at: this.state.lastTokStartLoc
|
});
|
}
|
sawDefault = true;
|
cur.test = null;
|
}
|
this.expect(14);
|
} else {
|
if (cur) {
|
cur.consequent.push(this.parseStatementListItem());
|
} else {
|
this.unexpected();
|
}
|
}
|
}
|
this.scope.exit();
|
if (cur) this.finishNode(cur, "SwitchCase");
|
this.next();
|
this.state.labels.pop();
|
return this.finishNode(node, "SwitchStatement");
|
}
|
parseThrowStatement(node) {
|
this.next();
|
if (this.hasPrecedingLineBreak()) {
|
this.raise(Errors.NewlineAfterThrow, {
|
at: this.state.lastTokEndLoc
|
});
|
}
|
node.argument = this.parseExpression();
|
this.semicolon();
|
return this.finishNode(node, "ThrowStatement");
|
}
|
parseCatchClauseParam() {
|
const param = this.parseBindingAtom();
|
this.scope.enter(this.options.annexB && param.type === "Identifier" ? SCOPE_SIMPLE_CATCH : 0);
|
this.checkLVal(param, {
|
in: {
|
type: "CatchClause"
|
},
|
binding: BIND_CATCH_PARAM
|
});
|
return param;
|
}
|
parseTryStatement(node) {
|
this.next();
|
node.block = this.parseBlock();
|
node.handler = null;
|
if (this.match(62)) {
|
const clause = this.startNode();
|
this.next();
|
if (this.match(10)) {
|
this.expect(10);
|
clause.param = this.parseCatchClauseParam();
|
this.expect(11);
|
} else {
|
clause.param = null;
|
this.scope.enter(SCOPE_OTHER);
|
}
|
clause.body = this.withSmartMixTopicForbiddingContext(() => this.parseBlock(false, false));
|
this.scope.exit();
|
node.handler = this.finishNode(clause, "CatchClause");
|
}
|
node.finalizer = this.eat(67) ? this.parseBlock() : null;
|
if (!node.handler && !node.finalizer) {
|
this.raise(Errors.NoCatchOrFinally, {
|
at: node
|
});
|
}
|
return this.finishNode(node, "TryStatement");
|
}
|
parseVarStatement(node, kind, allowMissingInitializer = false) {
|
this.next();
|
this.parseVar(node, false, kind, allowMissingInitializer);
|
this.semicolon();
|
return this.finishNode(node, "VariableDeclaration");
|
}
|
parseWhileStatement(node) {
|
this.next();
|
node.test = this.parseHeaderExpression();
|
this.state.labels.push(loopLabel);
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
|
this.state.labels.pop();
|
return this.finishNode(node, "WhileStatement");
|
}
|
parseWithStatement(node) {
|
if (this.state.strict) {
|
this.raise(Errors.StrictWith, {
|
at: this.state.startLoc
|
});
|
}
|
this.next();
|
node.object = this.parseHeaderExpression();
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
|
return this.finishNode(node, "WithStatement");
|
}
|
parseEmptyStatement(node) {
|
this.next();
|
return this.finishNode(node, "EmptyStatement");
|
}
|
parseLabeledStatement(node, maybeName, expr, flags) {
|
for (const label of this.state.labels) {
|
if (label.name === maybeName) {
|
this.raise(Errors.LabelRedeclaration, {
|
at: expr,
|
labelName: maybeName
|
});
|
}
|
}
|
const kind = tokenIsLoop(this.state.type) ? "loop" : this.match(71) ? "switch" : null;
|
for (let i = this.state.labels.length - 1; i >= 0; i--) {
|
const label = this.state.labels[i];
|
if (label.statementStart === node.start) {
|
label.statementStart = this.state.start;
|
label.kind = kind;
|
} else {
|
break;
|
}
|
}
|
this.state.labels.push({
|
name: maybeName,
|
kind: kind,
|
statementStart: this.state.start
|
});
|
node.body = flags & 8 ? this.parseStatementOrSloppyAnnexBFunctionDeclaration(true) : this.parseStatement();
|
this.state.labels.pop();
|
node.label = expr;
|
return this.finishNode(node, "LabeledStatement");
|
}
|
parseExpressionStatement(node, expr, decorators) {
|
node.expression = expr;
|
this.semicolon();
|
return this.finishNode(node, "ExpressionStatement");
|
}
|
parseBlock(allowDirectives = false, createNewLexicalScope = true, afterBlockParse) {
|
const node = this.startNode();
|
if (allowDirectives) {
|
this.state.strictErrors.clear();
|
}
|
this.expect(5);
|
if (createNewLexicalScope) {
|
this.scope.enter(SCOPE_OTHER);
|
}
|
this.parseBlockBody(node, allowDirectives, false, 8, afterBlockParse);
|
if (createNewLexicalScope) {
|
this.scope.exit();
|
}
|
return this.finishNode(node, "BlockStatement");
|
}
|
isValidDirective(stmt) {
|
return stmt.type === "ExpressionStatement" && stmt.expression.type === "StringLiteral" && !stmt.expression.extra.parenthesized;
|
}
|
parseBlockBody(node, allowDirectives, topLevel, end, afterBlockParse) {
|
const body = node.body = [];
|
const directives = node.directives = [];
|
this.parseBlockOrModuleBlockBody(body, allowDirectives ? directives : undefined, topLevel, end, afterBlockParse);
|
}
|
parseBlockOrModuleBlockBody(body, directives, topLevel, end, afterBlockParse) {
|
const oldStrict = this.state.strict;
|
let hasStrictModeDirective = false;
|
let parsedNonDirective = false;
|
while (!this.match(end)) {
|
const stmt = topLevel ? this.parseModuleItem() : this.parseStatementListItem();
|
if (directives && !parsedNonDirective) {
|
if (this.isValidDirective(stmt)) {
|
const directive = this.stmtToDirective(stmt);
|
directives.push(directive);
|
if (!hasStrictModeDirective && directive.value.value === "use strict") {
|
hasStrictModeDirective = true;
|
this.setStrict(true);
|
}
|
continue;
|
}
|
parsedNonDirective = true;
|
this.state.strictErrors.clear();
|
}
|
body.push(stmt);
|
}
|
if (afterBlockParse) {
|
afterBlockParse.call(this, hasStrictModeDirective);
|
}
|
if (!oldStrict) {
|
this.setStrict(false);
|
}
|
this.next();
|
}
|
parseFor(node, init) {
|
node.init = init;
|
this.semicolon(false);
|
node.test = this.match(13) ? null : this.parseExpression();
|
this.semicolon(false);
|
node.update = this.match(11) ? null : this.parseExpression();
|
this.expect(11);
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
|
this.scope.exit();
|
this.state.labels.pop();
|
return this.finishNode(node, "ForStatement");
|
}
|
parseForIn(node, init, awaitAt) {
|
const isForIn = this.match(58);
|
this.next();
|
if (isForIn) {
|
if (awaitAt !== null) this.unexpected(awaitAt);
|
} else {
|
node.await = awaitAt !== null;
|
}
|
if (init.type === "VariableDeclaration" && init.declarations[0].init != null && (!isForIn || !this.options.annexB || this.state.strict || init.kind !== "var" || init.declarations[0].id.type !== "Identifier")) {
|
this.raise(Errors.ForInOfLoopInitializer, {
|
at: init,
|
type: isForIn ? "ForInStatement" : "ForOfStatement"
|
});
|
}
|
if (init.type === "AssignmentPattern") {
|
this.raise(Errors.InvalidLhs, {
|
at: init,
|
ancestor: {
|
type: "ForStatement"
|
}
|
});
|
}
|
node.left = init;
|
node.right = isForIn ? this.parseExpression() : this.parseMaybeAssignAllowIn();
|
this.expect(11);
|
node.body = this.withSmartMixTopicForbiddingContext(() => this.parseStatement());
|
this.scope.exit();
|
this.state.labels.pop();
|
return this.finishNode(node, isForIn ? "ForInStatement" : "ForOfStatement");
|
}
|
parseVar(node, isFor, kind, allowMissingInitializer = false) {
|
const declarations = node.declarations = [];
|
node.kind = kind;
|
for (;;) {
|
const decl = this.startNode();
|
this.parseVarId(decl, kind);
|
decl.init = !this.eat(29) ? null : isFor ? this.parseMaybeAssignDisallowIn() : this.parseMaybeAssignAllowIn();
|
if (decl.init === null && !allowMissingInitializer) {
|
if (decl.id.type !== "Identifier" && !(isFor && (this.match(58) || this.isContextual(101)))) {
|
this.raise(Errors.DeclarationMissingInitializer, {
|
at: this.state.lastTokEndLoc,
|
kind: "destructuring"
|
});
|
} else if (kind === "const" && !(this.match(58) || this.isContextual(101))) {
|
this.raise(Errors.DeclarationMissingInitializer, {
|
at: this.state.lastTokEndLoc,
|
kind: "const"
|
});
|
}
|
}
|
declarations.push(this.finishNode(decl, "VariableDeclarator"));
|
if (!this.eat(12)) break;
|
}
|
return node;
|
}
|
parseVarId(decl, kind) {
|
if (kind === "using" && !this.inModule && this.match(96)) {
|
this.raise(Errors.AwaitInUsingBinding, {
|
at: this.state.startLoc
|
});
|
}
|
const id = this.parseBindingAtom();
|
this.checkLVal(id, {
|
in: {
|
type: "VariableDeclarator"
|
},
|
binding: kind === "var" ? BIND_VAR : BIND_LEXICAL
|
});
|
decl.id = id;
|
}
|
parseAsyncFunctionExpression(node) {
|
return this.parseFunction(node, 8);
|
}
|
parseFunction(node, flags = 0) {
|
const hangingDeclaration = flags & 2;
|
const isDeclaration = !!(flags & 1);
|
const requireId = isDeclaration && !(flags & 4);
|
const isAsync = !!(flags & 8);
|
this.initFunction(node, isAsync);
|
if (this.match(55)) {
|
if (hangingDeclaration) {
|
this.raise(Errors.GeneratorInSingleStatementContext, {
|
at: this.state.startLoc
|
});
|
}
|
this.next();
|
node.generator = true;
|
}
|
if (isDeclaration) {
|
node.id = this.parseFunctionId(requireId);
|
}
|
const oldMaybeInArrowParameters = this.state.maybeInArrowParameters;
|
this.state.maybeInArrowParameters = false;
|
this.scope.enter(SCOPE_FUNCTION);
|
this.prodParam.enter(functionFlags(isAsync, node.generator));
|
if (!isDeclaration) {
|
node.id = this.parseFunctionId();
|
}
|
this.parseFunctionParams(node, false);
|
this.withSmartMixTopicForbiddingContext(() => {
|
this.parseFunctionBodyAndFinish(node, isDeclaration ? "FunctionDeclaration" : "FunctionExpression");
|
});
|
this.prodParam.exit();
|
this.scope.exit();
|
if (isDeclaration && !hangingDeclaration) {
|
this.registerFunctionStatementId(node);
|
}
|
this.state.maybeInArrowParameters = oldMaybeInArrowParameters;
|
return node;
|
}
|
parseFunctionId(requireId) {
|
return requireId || tokenIsIdentifier(this.state.type) ? this.parseIdentifier() : null;
|
}
|
parseFunctionParams(node, isConstructor) {
|
this.expect(10);
|
this.expressionScope.enter(newParameterDeclarationScope());
|
node.params = this.parseBindingList(11, 41, 2 | (isConstructor ? 4 : 0));
|
this.expressionScope.exit();
|
}
|
registerFunctionStatementId(node) {
|
if (!node.id) return;
|
this.scope.declareName(node.id.name, !this.options.annexB || this.state.strict || node.generator || node.async ? this.scope.treatFunctionsAsVar ? BIND_VAR : BIND_LEXICAL : BIND_FUNCTION, node.id.loc.start);
|
}
|
parseClass(node, isStatement, optionalId) {
|
this.next();
|
const oldStrict = this.state.strict;
|
this.state.strict = true;
|
this.parseClassId(node, isStatement, optionalId);
|
this.parseClassSuper(node);
|
node.body = this.parseClassBody(!!node.superClass, oldStrict);
|
return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
|
}
|
isClassProperty() {
|
return this.match(29) || this.match(13) || this.match(8);
|
}
|
isClassMethod() {
|
return this.match(10);
|
}
|
isNonstaticConstructor(method) {
|
return !method.computed && !method.static && (method.key.name === "constructor" || method.key.value === "constructor");
|
}
|
parseClassBody(hadSuperClass, oldStrict) {
|
this.classScope.enter();
|
const state = {
|
hadConstructor: false,
|
hadSuperClass
|
};
|
let decorators = [];
|
const classBody = this.startNode();
|
classBody.body = [];
|
this.expect(5);
|
this.withSmartMixTopicForbiddingContext(() => {
|
while (!this.match(8)) {
|
if (this.eat(13)) {
|
if (decorators.length > 0) {
|
throw this.raise(Errors.DecoratorSemicolon, {
|
at: this.state.lastTokEndLoc
|
});
|
}
|
continue;
|
}
|
if (this.match(26)) {
|
decorators.push(this.parseDecorator());
|
continue;
|
}
|
const member = this.startNode();
|
if (decorators.length) {
|
member.decorators = decorators;
|
this.resetStartLocationFromNode(member, decorators[0]);
|
decorators = [];
|
}
|
this.parseClassMember(classBody, member, state);
|
if (member.kind === "constructor" && member.decorators && member.decorators.length > 0) {
|
this.raise(Errors.DecoratorConstructor, {
|
at: member
|
});
|
}
|
}
|
});
|
this.state.strict = oldStrict;
|
this.next();
|
if (decorators.length) {
|
throw this.raise(Errors.TrailingDecorator, {
|
at: this.state.startLoc
|
});
|
}
|
this.classScope.exit();
|
return this.finishNode(classBody, "ClassBody");
|
}
|
parseClassMemberFromModifier(classBody, member) {
|
const key = this.parseIdentifier(true);
|
if (this.isClassMethod()) {
|
const method = member;
|
method.kind = "method";
|
method.computed = false;
|
method.key = key;
|
method.static = false;
|
this.pushClassMethod(classBody, method, false, false, false, false);
|
return true;
|
} else if (this.isClassProperty()) {
|
const prop = member;
|
prop.computed = false;
|
prop.key = key;
|
prop.static = false;
|
classBody.body.push(this.parseClassProperty(prop));
|
return true;
|
}
|
this.resetPreviousNodeTrailingComments(key);
|
return false;
|
}
|
parseClassMember(classBody, member, state) {
|
const isStatic = this.isContextual(104);
|
if (isStatic) {
|
if (this.parseClassMemberFromModifier(classBody, member)) {
|
return;
|
}
|
if (this.eat(5)) {
|
this.parseClassStaticBlock(classBody, member);
|
return;
|
}
|
}
|
this.parseClassMemberWithIsStatic(classBody, member, state, isStatic);
|
}
|
parseClassMemberWithIsStatic(classBody, member, state, isStatic) {
|
const publicMethod = member;
|
const privateMethod = member;
|
const publicProp = member;
|
const privateProp = member;
|
const accessorProp = member;
|
const method = publicMethod;
|
const publicMember = publicMethod;
|
member.static = isStatic;
|
this.parsePropertyNamePrefixOperator(member);
|
if (this.eat(55)) {
|
method.kind = "method";
|
const isPrivateName = this.match(136);
|
this.parseClassElementName(method);
|
if (isPrivateName) {
|
this.pushClassPrivateMethod(classBody, privateMethod, true, false);
|
return;
|
}
|
if (this.isNonstaticConstructor(publicMethod)) {
|
this.raise(Errors.ConstructorIsGenerator, {
|
at: publicMethod.key
|
});
|
}
|
this.pushClassMethod(classBody, publicMethod, true, false, false, false);
|
return;
|
}
|
const isContextual = tokenIsIdentifier(this.state.type) && !this.state.containsEsc;
|
const isPrivate = this.match(136);
|
const key = this.parseClassElementName(member);
|
const maybeQuestionTokenStartLoc = this.state.startLoc;
|
this.parsePostMemberNameModifiers(publicMember);
|
if (this.isClassMethod()) {
|
method.kind = "method";
|
if (isPrivate) {
|
this.pushClassPrivateMethod(classBody, privateMethod, false, false);
|
return;
|
}
|
const isConstructor = this.isNonstaticConstructor(publicMethod);
|
let allowsDirectSuper = false;
|
if (isConstructor) {
|
publicMethod.kind = "constructor";
|
if (state.hadConstructor && !this.hasPlugin("typescript")) {
|
this.raise(Errors.DuplicateConstructor, {
|
at: key
|
});
|
}
|
if (isConstructor && this.hasPlugin("typescript") && member.override) {
|
this.raise(Errors.OverrideOnConstructor, {
|
at: key
|
});
|
}
|
state.hadConstructor = true;
|
allowsDirectSuper = state.hadSuperClass;
|
}
|
this.pushClassMethod(classBody, publicMethod, false, false, isConstructor, allowsDirectSuper);
|
} else if (this.isClassProperty()) {
|
if (isPrivate) {
|
this.pushClassPrivateProperty(classBody, privateProp);
|
} else {
|
this.pushClassProperty(classBody, publicProp);
|
}
|
} else if (isContextual && key.name === "async" && !this.isLineTerminator()) {
|
this.resetPreviousNodeTrailingComments(key);
|
const isGenerator = this.eat(55);
|
if (publicMember.optional) {
|
this.unexpected(maybeQuestionTokenStartLoc);
|
}
|
method.kind = "method";
|
const isPrivate = this.match(136);
|
this.parseClassElementName(method);
|
this.parsePostMemberNameModifiers(publicMember);
|
if (isPrivate) {
|
this.pushClassPrivateMethod(classBody, privateMethod, isGenerator, true);
|
} else {
|
if (this.isNonstaticConstructor(publicMethod)) {
|
this.raise(Errors.ConstructorIsAsync, {
|
at: publicMethod.key
|
});
|
}
|
this.pushClassMethod(classBody, publicMethod, isGenerator, true, false, false);
|
}
|
} else if (isContextual && (key.name === "get" || key.name === "set") && !(this.match(55) && this.isLineTerminator())) {
|
this.resetPreviousNodeTrailingComments(key);
|
method.kind = key.name;
|
const isPrivate = this.match(136);
|
this.parseClassElementName(publicMethod);
|
if (isPrivate) {
|
this.pushClassPrivateMethod(classBody, privateMethod, false, false);
|
} else {
|
if (this.isNonstaticConstructor(publicMethod)) {
|
this.raise(Errors.ConstructorIsAccessor, {
|
at: publicMethod.key
|
});
|
}
|
this.pushClassMethod(classBody, publicMethod, false, false, false, false);
|
}
|
this.checkGetterSetterParams(publicMethod);
|
} else if (isContextual && key.name === "accessor" && !this.isLineTerminator()) {
|
this.expectPlugin("decoratorAutoAccessors");
|
this.resetPreviousNodeTrailingComments(key);
|
const isPrivate = this.match(136);
|
this.parseClassElementName(publicProp);
|
this.pushClassAccessorProperty(classBody, accessorProp, isPrivate);
|
} else if (this.isLineTerminator()) {
|
if (isPrivate) {
|
this.pushClassPrivateProperty(classBody, privateProp);
|
} else {
|
this.pushClassProperty(classBody, publicProp);
|
}
|
} else {
|
this.unexpected();
|
}
|
}
|
parseClassElementName(member) {
|
const {
|
type,
|
value
|
} = this.state;
|
if ((type === 130 || type === 131) && member.static && value === "prototype") {
|
this.raise(Errors.StaticPrototype, {
|
at: this.state.startLoc
|
});
|
}
|
if (type === 136) {
|
if (value === "constructor") {
|
this.raise(Errors.ConstructorClassPrivateField, {
|
at: this.state.startLoc
|
});
|
}
|
const key = this.parsePrivateName();
|
member.key = key;
|
return key;
|
}
|
return this.parsePropertyName(member);
|
}
|
parseClassStaticBlock(classBody, member) {
|
var _member$decorators;
|
this.scope.enter(SCOPE_CLASS | SCOPE_STATIC_BLOCK | SCOPE_SUPER);
|
const oldLabels = this.state.labels;
|
this.state.labels = [];
|
this.prodParam.enter(PARAM);
|
const body = member.body = [];
|
this.parseBlockOrModuleBlockBody(body, undefined, false, 8);
|
this.prodParam.exit();
|
this.scope.exit();
|
this.state.labels = oldLabels;
|
classBody.body.push(this.finishNode(member, "StaticBlock"));
|
if ((_member$decorators = member.decorators) != null && _member$decorators.length) {
|
this.raise(Errors.DecoratorStaticBlock, {
|
at: member
|
});
|
}
|
}
|
pushClassProperty(classBody, prop) {
|
if (!prop.computed && (prop.key.name === "constructor" || prop.key.value === "constructor")) {
|
this.raise(Errors.ConstructorClassField, {
|
at: prop.key
|
});
|
}
|
classBody.body.push(this.parseClassProperty(prop));
|
}
|
pushClassPrivateProperty(classBody, prop) {
|
const node = this.parseClassPrivateProperty(prop);
|
classBody.body.push(node);
|
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start);
|
}
|
pushClassAccessorProperty(classBody, prop, isPrivate) {
|
if (!isPrivate && !prop.computed) {
|
const key = prop.key;
|
if (key.name === "constructor" || key.value === "constructor") {
|
this.raise(Errors.ConstructorClassField, {
|
at: key
|
});
|
}
|
}
|
const node = this.parseClassAccessorProperty(prop);
|
classBody.body.push(node);
|
if (isPrivate) {
|
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), CLASS_ELEMENT_OTHER, node.key.loc.start);
|
}
|
}
|
pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
|
classBody.body.push(this.parseMethod(method, isGenerator, isAsync, isConstructor, allowsDirectSuper, "ClassMethod", true));
|
}
|
pushClassPrivateMethod(classBody, method, isGenerator, isAsync) {
|
const node = this.parseMethod(method, isGenerator, isAsync, false, false, "ClassPrivateMethod", true);
|
classBody.body.push(node);
|
const kind = node.kind === "get" ? node.static ? CLASS_ELEMENT_STATIC_GETTER : CLASS_ELEMENT_INSTANCE_GETTER : node.kind === "set" ? node.static ? CLASS_ELEMENT_STATIC_SETTER : CLASS_ELEMENT_INSTANCE_SETTER : CLASS_ELEMENT_OTHER;
|
this.declareClassPrivateMethodInScope(node, kind);
|
}
|
declareClassPrivateMethodInScope(node, kind) {
|
this.classScope.declarePrivateName(this.getPrivateNameSV(node.key), kind, node.key.loc.start);
|
}
|
parsePostMemberNameModifiers(methodOrProp) {}
|
parseClassPrivateProperty(node) {
|
this.parseInitializer(node);
|
this.semicolon();
|
return this.finishNode(node, "ClassPrivateProperty");
|
}
|
parseClassProperty(node) {
|
this.parseInitializer(node);
|
this.semicolon();
|
return this.finishNode(node, "ClassProperty");
|
}
|
parseClassAccessorProperty(node) {
|
this.parseInitializer(node);
|
this.semicolon();
|
return this.finishNode(node, "ClassAccessorProperty");
|
}
|
parseInitializer(node) {
|
this.scope.enter(SCOPE_CLASS | SCOPE_SUPER);
|
this.expressionScope.enter(newExpressionScope());
|
this.prodParam.enter(PARAM);
|
node.value = this.eat(29) ? this.parseMaybeAssignAllowIn() : null;
|
this.expressionScope.exit();
|
this.prodParam.exit();
|
this.scope.exit();
|
}
|
parseClassId(node, isStatement, optionalId, bindingType = BIND_CLASS) {
|
if (tokenIsIdentifier(this.state.type)) {
|
node.id = this.parseIdentifier();
|
if (isStatement) {
|
this.declareNameFromIdentifier(node.id, bindingType);
|
}
|
} else {
|
if (optionalId || !isStatement) {
|
node.id = null;
|
} else {
|
throw this.raise(Errors.MissingClassName, {
|
at: this.state.startLoc
|
});
|
}
|
}
|
}
|
parseClassSuper(node) {
|
node.superClass = this.eat(81) ? this.parseExprSubscripts() : null;
|
}
|
parseExport(node, decorators) {
|
const hasDefault = this.maybeParseExportDefaultSpecifier(node);
|
const parseAfterDefault = !hasDefault || this.eat(12);
|
const hasStar = parseAfterDefault && this.eatExportStar(node);
|
const hasNamespace = hasStar && this.maybeParseExportNamespaceSpecifier(node);
|
const parseAfterNamespace = parseAfterDefault && (!hasNamespace || this.eat(12));
|
const isFromRequired = hasDefault || hasStar;
|
if (hasStar && !hasNamespace) {
|
if (hasDefault) this.unexpected();
|
if (decorators) {
|
throw this.raise(Errors.UnsupportedDecoratorExport, {
|
at: node
|
});
|
}
|
this.parseExportFrom(node, true);
|
return this.finishNode(node, "ExportAllDeclaration");
|
}
|
const hasSpecifiers = this.maybeParseExportNamedSpecifiers(node);
|
if (hasDefault && parseAfterDefault && !hasStar && !hasSpecifiers) {
|
this.unexpected(null, 5);
|
}
|
if (hasNamespace && parseAfterNamespace) {
|
this.unexpected(null, 97);
|
}
|
let hasDeclaration;
|
if (isFromRequired || hasSpecifiers) {
|
hasDeclaration = false;
|
if (decorators) {
|
throw this.raise(Errors.UnsupportedDecoratorExport, {
|
at: node
|
});
|
}
|
this.parseExportFrom(node, isFromRequired);
|
} else {
|
hasDeclaration = this.maybeParseExportDeclaration(node);
|
}
|
if (isFromRequired || hasSpecifiers || hasDeclaration) {
|
var _node2$declaration;
|
const node2 = node;
|
this.checkExport(node2, true, false, !!node2.source);
|
if (((_node2$declaration = node2.declaration) == null ? void 0 : _node2$declaration.type) === "ClassDeclaration") {
|
this.maybeTakeDecorators(decorators, node2.declaration, node2);
|
} else if (decorators) {
|
throw this.raise(Errors.UnsupportedDecoratorExport, {
|
at: node
|
});
|
}
|
return this.finishNode(node2, "ExportNamedDeclaration");
|
}
|
if (this.eat(65)) {
|
const node2 = node;
|
const decl = this.parseExportDefaultExpression();
|
node2.declaration = decl;
|
if (decl.type === "ClassDeclaration") {
|
this.maybeTakeDecorators(decorators, decl, node2);
|
} else if (decorators) {
|
throw this.raise(Errors.UnsupportedDecoratorExport, {
|
at: node
|
});
|
}
|
this.checkExport(node2, true, true);
|
return this.finishNode(node2, "ExportDefaultDeclaration");
|
}
|
this.unexpected(null, 5);
|
}
|
eatExportStar(node) {
|
return this.eat(55);
|
}
|
maybeParseExportDefaultSpecifier(node) {
|
if (this.isExportDefaultSpecifier()) {
|
this.expectPlugin("exportDefaultFrom");
|
const specifier = this.startNode();
|
specifier.exported = this.parseIdentifier(true);
|
node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")];
|
return true;
|
}
|
return false;
|
}
|
maybeParseExportNamespaceSpecifier(node) {
|
if (this.isContextual(93)) {
|
if (!node.specifiers) node.specifiers = [];
|
const specifier = this.startNodeAt(this.state.lastTokStartLoc);
|
this.next();
|
specifier.exported = this.parseModuleExportName();
|
node.specifiers.push(this.finishNode(specifier, "ExportNamespaceSpecifier"));
|
return true;
|
}
|
return false;
|
}
|
maybeParseExportNamedSpecifiers(node) {
|
if (this.match(5)) {
|
if (!node.specifiers) node.specifiers = [];
|
const isTypeExport = node.exportKind === "type";
|
node.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
|
node.source = null;
|
node.declaration = null;
|
if (this.hasPlugin("importAssertions")) {
|
node.assertions = [];
|
}
|
return true;
|
}
|
return false;
|
}
|
maybeParseExportDeclaration(node) {
|
if (this.shouldParseExportDeclaration()) {
|
node.specifiers = [];
|
node.source = null;
|
if (this.hasPlugin("importAssertions")) {
|
node.assertions = [];
|
}
|
node.declaration = this.parseExportDeclaration(node);
|
return true;
|
}
|
return false;
|
}
|
isAsyncFunction() {
|
if (!this.isContextual(95)) return false;
|
const next = this.nextTokenStart();
|
return !lineBreak.test(this.input.slice(this.state.pos, next)) && this.isUnparsedContextual(next, "function");
|
}
|
parseExportDefaultExpression() {
|
const expr = this.startNode();
|
if (this.match(68)) {
|
this.next();
|
return this.parseFunction(expr, 1 | 4);
|
} else if (this.isAsyncFunction()) {
|
this.next();
|
this.next();
|
return this.parseFunction(expr, 1 | 4 | 8);
|
}
|
if (this.match(80)) {
|
return this.parseClass(expr, true, true);
|
}
|
if (this.match(26)) {
|
if (this.hasPlugin("decorators") && this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
|
this.raise(Errors.DecoratorBeforeExport, {
|
at: this.state.startLoc
|
});
|
}
|
return this.parseClass(this.maybeTakeDecorators(this.parseDecorators(false), this.startNode()), true, true);
|
}
|
if (this.match(75) || this.match(74) || this.isLet()) {
|
throw this.raise(Errors.UnsupportedDefaultExport, {
|
at: this.state.startLoc
|
});
|
}
|
const res = this.parseMaybeAssignAllowIn();
|
this.semicolon();
|
return res;
|
}
|
parseExportDeclaration(node) {
|
if (this.match(80)) {
|
const node = this.parseClass(this.startNode(), true, false);
|
return node;
|
}
|
return this.parseStatementListItem();
|
}
|
isExportDefaultSpecifier() {
|
const {
|
type
|
} = this.state;
|
if (tokenIsIdentifier(type)) {
|
if (type === 95 && !this.state.containsEsc || type === 99) {
|
return false;
|
}
|
if ((type === 128 || type === 127) && !this.state.containsEsc) {
|
const {
|
type: nextType
|
} = this.lookahead();
|
if (tokenIsIdentifier(nextType) && nextType !== 97 || nextType === 5) {
|
this.expectOnePlugin(["flow", "typescript"]);
|
return false;
|
}
|
}
|
} else if (!this.match(65)) {
|
return false;
|
}
|
const next = this.nextTokenStart();
|
const hasFrom = this.isUnparsedContextual(next, "from");
|
if (this.input.charCodeAt(next) === 44 || tokenIsIdentifier(this.state.type) && hasFrom) {
|
return true;
|
}
|
if (this.match(65) && hasFrom) {
|
const nextAfterFrom = this.input.charCodeAt(this.nextTokenStartSince(next + 4));
|
return nextAfterFrom === 34 || nextAfterFrom === 39;
|
}
|
return false;
|
}
|
parseExportFrom(node, expect) {
|
if (this.eatContextual(97)) {
|
node.source = this.parseImportSource();
|
this.checkExport(node);
|
const assertions = this.maybeParseImportAssertions();
|
if (assertions) {
|
node.assertions = assertions;
|
this.checkJSONModuleImport(node);
|
}
|
} else if (expect) {
|
this.unexpected();
|
}
|
this.semicolon();
|
}
|
shouldParseExportDeclaration() {
|
const {
|
type
|
} = this.state;
|
if (type === 26) {
|
this.expectOnePlugin(["decorators", "decorators-legacy"]);
|
if (this.hasPlugin("decorators")) {
|
if (this.getPluginOption("decorators", "decoratorsBeforeExport") === true) {
|
this.raise(Errors.DecoratorBeforeExport, {
|
at: this.state.startLoc
|
});
|
}
|
return true;
|
}
|
}
|
return type === 74 || type === 75 || type === 68 || type === 80 || this.isLet() || this.isAsyncFunction();
|
}
|
checkExport(node, checkNames, isDefault, isFrom) {
|
if (checkNames) {
|
if (isDefault) {
|
this.checkDuplicateExports(node, "default");
|
if (this.hasPlugin("exportDefaultFrom")) {
|
var _declaration$extra;
|
const declaration = node.declaration;
|
if (declaration.type === "Identifier" && declaration.name === "from" && declaration.end - declaration.start === 4 && !((_declaration$extra = declaration.extra) != null && _declaration$extra.parenthesized)) {
|
this.raise(Errors.ExportDefaultFromAsIdentifier, {
|
at: declaration
|
});
|
}
|
}
|
} else if (node.specifiers && node.specifiers.length) {
|
for (const specifier of node.specifiers) {
|
const {
|
exported
|
} = specifier;
|
const exportName = exported.type === "Identifier" ? exported.name : exported.value;
|
this.checkDuplicateExports(specifier, exportName);
|
if (!isFrom && specifier.local) {
|
const {
|
local
|
} = specifier;
|
if (local.type !== "Identifier") {
|
this.raise(Errors.ExportBindingIsString, {
|
at: specifier,
|
localName: local.value,
|
exportName
|
});
|
} else {
|
this.checkReservedWord(local.name, local.loc.start, true, false);
|
this.scope.checkLocalExport(local);
|
}
|
}
|
}
|
} else if (node.declaration) {
|
if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
|
const id = node.declaration.id;
|
if (!id) throw new Error("Assertion failure");
|
this.checkDuplicateExports(node, id.name);
|
} else if (node.declaration.type === "VariableDeclaration") {
|
for (const declaration of node.declaration.declarations) {
|
this.checkDeclaration(declaration.id);
|
}
|
}
|
}
|
}
|
}
|
checkDeclaration(node) {
|
if (node.type === "Identifier") {
|
this.checkDuplicateExports(node, node.name);
|
} else if (node.type === "ObjectPattern") {
|
for (const prop of node.properties) {
|
this.checkDeclaration(prop);
|
}
|
} else if (node.type === "ArrayPattern") {
|
for (const elem of node.elements) {
|
if (elem) {
|
this.checkDeclaration(elem);
|
}
|
}
|
} else if (node.type === "ObjectProperty") {
|
this.checkDeclaration(node.value);
|
} else if (node.type === "RestElement") {
|
this.checkDeclaration(node.argument);
|
} else if (node.type === "AssignmentPattern") {
|
this.checkDeclaration(node.left);
|
}
|
}
|
checkDuplicateExports(node, exportName) {
|
if (this.exportedIdentifiers.has(exportName)) {
|
if (exportName === "default") {
|
this.raise(Errors.DuplicateDefaultExport, {
|
at: node
|
});
|
} else {
|
this.raise(Errors.DuplicateExport, {
|
at: node,
|
exportName
|
});
|
}
|
}
|
this.exportedIdentifiers.add(exportName);
|
}
|
parseExportSpecifiers(isInTypeExport) {
|
const nodes = [];
|
let first = true;
|
this.expect(5);
|
while (!this.eat(8)) {
|
if (first) {
|
first = false;
|
} else {
|
this.expect(12);
|
if (this.eat(8)) break;
|
}
|
const isMaybeTypeOnly = this.isContextual(128);
|
const isString = this.match(131);
|
const node = this.startNode();
|
node.local = this.parseModuleExportName();
|
nodes.push(this.parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly));
|
}
|
return nodes;
|
}
|
parseExportSpecifier(node, isString, isInTypeExport, isMaybeTypeOnly) {
|
if (this.eatContextual(93)) {
|
node.exported = this.parseModuleExportName();
|
} else if (isString) {
|
node.exported = cloneStringLiteral(node.local);
|
} else if (!node.exported) {
|
node.exported = cloneIdentifier(node.local);
|
}
|
return this.finishNode(node, "ExportSpecifier");
|
}
|
parseModuleExportName() {
|
if (this.match(131)) {
|
const result = this.parseStringLiteral(this.state.value);
|
const surrogate = result.value.match(loneSurrogate);
|
if (surrogate) {
|
this.raise(Errors.ModuleExportNameHasLoneSurrogate, {
|
at: result,
|
surrogateCharCode: surrogate[0].charCodeAt(0)
|
});
|
}
|
return result;
|
}
|
return this.parseIdentifier(true);
|
}
|
isJSONModuleImport(node) {
|
if (node.assertions != null) {
|
return node.assertions.some(({
|
key,
|
value
|
}) => {
|
return value.value === "json" && (key.type === "Identifier" ? key.name === "type" : key.value === "type");
|
});
|
}
|
return false;
|
}
|
checkImportReflection(node) {
|
if (node.module) {
|
var _node$assertions;
|
if (node.specifiers.length !== 1 || node.specifiers[0].type !== "ImportDefaultSpecifier") {
|
this.raise(Errors.ImportReflectionNotBinding, {
|
at: node.specifiers[0].loc.start
|
});
|
}
|
if (((_node$assertions = node.assertions) == null ? void 0 : _node$assertions.length) > 0) {
|
this.raise(Errors.ImportReflectionHasAssertion, {
|
at: node.specifiers[0].loc.start
|
});
|
}
|
}
|
}
|
checkJSONModuleImport(node) {
|
if (this.isJSONModuleImport(node) && node.type !== "ExportAllDeclaration") {
|
const {
|
specifiers
|
} = node;
|
if (specifiers != null) {
|
const nonDefaultNamedSpecifier = specifiers.find(specifier => {
|
let imported;
|
if (specifier.type === "ExportSpecifier") {
|
imported = specifier.local;
|
} else if (specifier.type === "ImportSpecifier") {
|
imported = specifier.imported;
|
}
|
if (imported !== undefined) {
|
return imported.type === "Identifier" ? imported.name !== "default" : imported.value !== "default";
|
}
|
});
|
if (nonDefaultNamedSpecifier !== undefined) {
|
this.raise(Errors.ImportJSONBindingNotDefault, {
|
at: nonDefaultNamedSpecifier.loc.start
|
});
|
}
|
}
|
}
|
}
|
parseMaybeImportReflection(node) {
|
let isImportReflection = false;
|
if (this.isContextual(125)) {
|
const lookahead = this.lookahead();
|
const nextType = lookahead.type;
|
if (tokenIsIdentifier(nextType)) {
|
if (nextType !== 97) {
|
isImportReflection = true;
|
} else {
|
const nextNextTokenFirstChar = this.input.charCodeAt(this.nextTokenStartSince(lookahead.end));
|
if (nextNextTokenFirstChar === 102) {
|
isImportReflection = true;
|
}
|
}
|
} else if (nextType !== 12) {
|
isImportReflection = true;
|
}
|
}
|
if (isImportReflection) {
|
this.expectPlugin("importReflection");
|
this.next();
|
node.module = true;
|
} else if (this.hasPlugin("importReflection")) {
|
node.module = false;
|
}
|
}
|
parseImport(node) {
|
node.specifiers = [];
|
if (!this.match(131)) {
|
this.parseMaybeImportReflection(node);
|
const hasDefault = this.maybeParseDefaultImportSpecifier(node);
|
const parseNext = !hasDefault || this.eat(12);
|
const hasStar = parseNext && this.maybeParseStarImportSpecifier(node);
|
if (parseNext && !hasStar) this.parseNamedImportSpecifiers(node);
|
this.expectContextual(97);
|
}
|
node.source = this.parseImportSource();
|
const assertions = this.maybeParseImportAssertions();
|
if (assertions) {
|
node.assertions = assertions;
|
} else {
|
const attributes = this.maybeParseModuleAttributes();
|
if (attributes) {
|
node.attributes = attributes;
|
}
|
}
|
this.checkImportReflection(node);
|
this.checkJSONModuleImport(node);
|
this.semicolon();
|
return this.finishNode(node, "ImportDeclaration");
|
}
|
parseImportSource() {
|
if (!this.match(131)) this.unexpected();
|
return this.parseExprAtom();
|
}
|
shouldParseDefaultImport(node) {
|
return tokenIsIdentifier(this.state.type);
|
}
|
parseImportSpecifierLocal(node, specifier, type) {
|
specifier.local = this.parseIdentifier();
|
node.specifiers.push(this.finishImportSpecifier(specifier, type));
|
}
|
finishImportSpecifier(specifier, type, bindingType = BIND_LEXICAL) {
|
this.checkLVal(specifier.local, {
|
in: {
|
type
|
},
|
binding: bindingType
|
});
|
return this.finishNode(specifier, type);
|
}
|
parseAssertEntries() {
|
const attrs = [];
|
const attrNames = new Set();
|
do {
|
if (this.match(8)) {
|
break;
|
}
|
const node = this.startNode();
|
const keyName = this.state.value;
|
if (attrNames.has(keyName)) {
|
this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
|
at: this.state.startLoc,
|
key: keyName
|
});
|
}
|
attrNames.add(keyName);
|
if (this.match(131)) {
|
node.key = this.parseStringLiteral(keyName);
|
} else {
|
node.key = this.parseIdentifier(true);
|
}
|
this.expect(14);
|
if (!this.match(131)) {
|
throw this.raise(Errors.ModuleAttributeInvalidValue, {
|
at: this.state.startLoc
|
});
|
}
|
node.value = this.parseStringLiteral(this.state.value);
|
attrs.push(this.finishNode(node, "ImportAttribute"));
|
} while (this.eat(12));
|
return attrs;
|
}
|
maybeParseModuleAttributes() {
|
if (this.match(76) && !this.hasPrecedingLineBreak()) {
|
this.expectPlugin("moduleAttributes");
|
this.next();
|
} else {
|
if (this.hasPlugin("moduleAttributes")) return [];
|
return null;
|
}
|
const attrs = [];
|
const attributes = new Set();
|
do {
|
const node = this.startNode();
|
node.key = this.parseIdentifier(true);
|
if (node.key.name !== "type") {
|
this.raise(Errors.ModuleAttributeDifferentFromType, {
|
at: node.key
|
});
|
}
|
if (attributes.has(node.key.name)) {
|
this.raise(Errors.ModuleAttributesWithDuplicateKeys, {
|
at: node.key,
|
key: node.key.name
|
});
|
}
|
attributes.add(node.key.name);
|
this.expect(14);
|
if (!this.match(131)) {
|
throw this.raise(Errors.ModuleAttributeInvalidValue, {
|
at: this.state.startLoc
|
});
|
}
|
node.value = this.parseStringLiteral(this.state.value);
|
this.finishNode(node, "ImportAttribute");
|
attrs.push(node);
|
} while (this.eat(12));
|
return attrs;
|
}
|
maybeParseImportAssertions() {
|
if (this.isContextual(94) && !this.hasPrecedingLineBreak()) {
|
this.expectPlugin("importAssertions");
|
this.next();
|
} else {
|
if (this.hasPlugin("importAssertions")) return [];
|
return null;
|
}
|
this.eat(5);
|
const attrs = this.parseAssertEntries();
|
this.eat(8);
|
return attrs;
|
}
|
maybeParseDefaultImportSpecifier(node) {
|
if (this.shouldParseDefaultImport(node)) {
|
this.parseImportSpecifierLocal(node, this.startNode(), "ImportDefaultSpecifier");
|
return true;
|
}
|
return false;
|
}
|
maybeParseStarImportSpecifier(node) {
|
if (this.match(55)) {
|
const specifier = this.startNode();
|
this.next();
|
this.expectContextual(93);
|
this.parseImportSpecifierLocal(node, specifier, "ImportNamespaceSpecifier");
|
return true;
|
}
|
return false;
|
}
|
parseNamedImportSpecifiers(node) {
|
let first = true;
|
this.expect(5);
|
while (!this.eat(8)) {
|
if (first) {
|
first = false;
|
} else {
|
if (this.eat(14)) {
|
throw this.raise(Errors.DestructureNamedImport, {
|
at: this.state.startLoc
|
});
|
}
|
this.expect(12);
|
if (this.eat(8)) break;
|
}
|
const specifier = this.startNode();
|
const importedIsString = this.match(131);
|
const isMaybeTypeOnly = this.isContextual(128);
|
specifier.imported = this.parseModuleExportName();
|
const importSpecifier = this.parseImportSpecifier(specifier, importedIsString, node.importKind === "type" || node.importKind === "typeof", isMaybeTypeOnly, undefined);
|
node.specifiers.push(importSpecifier);
|
}
|
}
|
parseImportSpecifier(specifier, importedIsString, isInTypeOnlyImport, isMaybeTypeOnly, bindingType) {
|
if (this.eatContextual(93)) {
|
specifier.local = this.parseIdentifier();
|
} else {
|
const {
|
imported
|
} = specifier;
|
if (importedIsString) {
|
throw this.raise(Errors.ImportBindingIsString, {
|
at: specifier,
|
importName: imported.value
|
});
|
}
|
this.checkReservedWord(imported.name, specifier.loc.start, true, true);
|
if (!specifier.local) {
|
specifier.local = cloneIdentifier(imported);
|
}
|
}
|
return this.finishImportSpecifier(specifier, "ImportSpecifier", bindingType);
|
}
|
isThisParam(param) {
|
return param.type === "Identifier" && param.name === "this";
|
}
|
}
|
let Parser$2 = class Parser extends StatementParser {
|
constructor(options, input) {
|
options = getOptions(options);
|
super(options, input);
|
this.options = options;
|
this.initializeScopes();
|
this.plugins = pluginsMap(this.options.plugins);
|
this.filename = options.sourceFilename;
|
}
|
getScopeHandler() {
|
return ScopeHandler;
|
}
|
parse() {
|
this.enterInitialScopes();
|
const file = this.startNode();
|
const program = this.startNode();
|
this.nextToken();
|
file.errors = null;
|
this.parseTopLevel(file, program);
|
file.errors = this.state.errors;
|
return file;
|
}
|
};
|
function pluginsMap(plugins) {
|
const pluginMap = new Map();
|
for (const plugin of plugins) {
|
const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
|
if (!pluginMap.has(name)) pluginMap.set(name, options || {});
|
}
|
return pluginMap;
|
}
|
function parse$9(input, options) {
|
var _options;
|
if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
|
options = Object.assign({}, options);
|
try {
|
options.sourceType = "module";
|
const parser = getParser(options, input);
|
const ast = parser.parse();
|
if (parser.sawUnambiguousESM) {
|
return ast;
|
}
|
if (parser.ambiguousScriptDifferentAst) {
|
try {
|
options.sourceType = "script";
|
return getParser(options, input).parse();
|
} catch (_unused) {}
|
} else {
|
ast.program.sourceType = "script";
|
}
|
return ast;
|
} catch (moduleError) {
|
try {
|
options.sourceType = "script";
|
return getParser(options, input).parse();
|
} catch (_unused2) {}
|
throw moduleError;
|
}
|
} else {
|
return getParser(options, input).parse();
|
}
|
}
|
function parseExpression(input, options) {
|
const parser = getParser(options, input);
|
if (parser.options.strictMode) {
|
parser.state.strict = true;
|
}
|
return parser.getExpression();
|
}
|
function generateExportedTokenTypes(internalTokenTypes) {
|
const tokenTypes = {};
|
for (const typeName of Object.keys(internalTokenTypes)) {
|
tokenTypes[typeName] = getExportedToken(internalTokenTypes[typeName]);
|
}
|
return tokenTypes;
|
}
|
const tokTypes = generateExportedTokenTypes(tt);
|
function getParser(options, input) {
|
let cls = Parser$2;
|
if (options != null && options.plugins) {
|
validatePlugins(options.plugins);
|
cls = getParserClass(options.plugins);
|
}
|
return new cls(options, input);
|
}
|
const parserClassCache = {};
|
function getParserClass(pluginsFromOptions) {
|
const pluginList = mixinPluginNames.filter(name => hasPlugin(pluginsFromOptions, name));
|
const key = pluginList.join("/");
|
let cls = parserClassCache[key];
|
if (!cls) {
|
cls = Parser$2;
|
for (const plugin of pluginList) {
|
cls = mixinPlugins[plugin](cls);
|
}
|
parserClassCache[key] = cls;
|
}
|
return cls;
|
}
|
var parse_1$1 = lib.parse = parse$9;
|
var parseExpression_1 = lib.parseExpression = parseExpression;
|
lib.tokTypes = tokTypes;
|
|
const isStaticExp = (p) => p.type === 4 && p.isStatic;
|
const isBuiltInType = (tag, expected) => tag === expected || tag === hyphenate(expected);
|
function isCoreComponent(tag) {
|
if (isBuiltInType(tag, "Teleport")) {
|
return TELEPORT;
|
} else if (isBuiltInType(tag, "Suspense")) {
|
return SUSPENSE;
|
} else if (isBuiltInType(tag, "KeepAlive")) {
|
return KEEP_ALIVE;
|
} else if (isBuiltInType(tag, "BaseTransition")) {
|
return BASE_TRANSITION;
|
}
|
}
|
const nonIdentifierRE = /^\d|[^\$\w]/;
|
const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
|
const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
|
const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
|
const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
|
const isMemberExpressionBrowser = (path) => {
|
path = path.trim().replace(whitespaceRE, (s) => s.trim());
|
let state = 0 /* inMemberExp */;
|
let stateStack = [];
|
let currentOpenBracketCount = 0;
|
let currentOpenParensCount = 0;
|
let currentStringType = null;
|
for (let i = 0; i < path.length; i++) {
|
const char = path.charAt(i);
|
switch (state) {
|
case 0 /* inMemberExp */:
|
if (char === "[") {
|
stateStack.push(state);
|
state = 1 /* inBrackets */;
|
currentOpenBracketCount++;
|
} else if (char === "(") {
|
stateStack.push(state);
|
state = 2 /* inParens */;
|
currentOpenParensCount++;
|
} else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
|
return false;
|
}
|
break;
|
case 1 /* inBrackets */:
|
if (char === `'` || char === `"` || char === "`") {
|
stateStack.push(state);
|
state = 3 /* inString */;
|
currentStringType = char;
|
} else if (char === `[`) {
|
currentOpenBracketCount++;
|
} else if (char === `]`) {
|
if (!--currentOpenBracketCount) {
|
state = stateStack.pop();
|
}
|
}
|
break;
|
case 2 /* inParens */:
|
if (char === `'` || char === `"` || char === "`") {
|
stateStack.push(state);
|
state = 3 /* inString */;
|
currentStringType = char;
|
} else if (char === `(`) {
|
currentOpenParensCount++;
|
} else if (char === `)`) {
|
if (i === path.length - 1) {
|
return false;
|
}
|
if (!--currentOpenParensCount) {
|
state = stateStack.pop();
|
}
|
}
|
break;
|
case 3 /* inString */:
|
if (char === currentStringType) {
|
state = stateStack.pop();
|
currentStringType = null;
|
}
|
break;
|
}
|
}
|
return !currentOpenBracketCount && !currentOpenParensCount;
|
};
|
const isMemberExpressionNode = (path, context) => {
|
try {
|
let ret = parseExpression_1(path, {
|
plugins: context.expressionPlugins
|
});
|
if (ret.type === "TSAsExpression" || ret.type === "TSTypeAssertion") {
|
ret = ret.expression;
|
}
|
return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier";
|
} catch (e) {
|
return false;
|
}
|
};
|
const isMemberExpression = isMemberExpressionNode;
|
function getInnerRange(loc, offset, length) {
|
const source = loc.source.slice(offset, offset + length);
|
const newLoc = {
|
source,
|
start: advancePositionWithClone(loc.start, loc.source, offset),
|
end: loc.end
|
};
|
if (length != null) {
|
newLoc.end = advancePositionWithClone(
|
loc.start,
|
loc.source,
|
offset + length
|
);
|
}
|
return newLoc;
|
}
|
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
|
return advancePositionWithMutation(
|
extend({}, pos),
|
source,
|
numberOfCharacters
|
);
|
}
|
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
|
let linesCount = 0;
|
let lastNewLinePos = -1;
|
for (let i = 0; i < numberOfCharacters; i++) {
|
if (source.charCodeAt(i) === 10) {
|
linesCount++;
|
lastNewLinePos = i;
|
}
|
}
|
pos.offset += numberOfCharacters;
|
pos.line += linesCount;
|
pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
|
return pos;
|
}
|
function assert(condition, msg) {
|
if (!condition) {
|
throw new Error(msg || `unexpected compiler condition`);
|
}
|
}
|
function findDir(node, name, allowEmpty = false) {
|
for (let i = 0; i < node.props.length; i++) {
|
const p = node.props[i];
|
if (p.type === 7 && (allowEmpty || p.exp) && (isString$2(name) ? p.name === name : name.test(p.name))) {
|
return p;
|
}
|
}
|
}
|
function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
|
for (let i = 0; i < node.props.length; i++) {
|
const p = node.props[i];
|
if (p.type === 6) {
|
if (dynamicOnly)
|
continue;
|
if (p.name === name && (p.value || allowEmpty)) {
|
return p;
|
}
|
} else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
|
return p;
|
}
|
}
|
}
|
function isStaticArgOf(arg, name) {
|
return !!(arg && isStaticExp(arg) && arg.content === name);
|
}
|
function hasDynamicKeyVBind(node) {
|
return node.props.some(
|
(p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
|
p.arg.type !== 4 || // v-bind:[_ctx.foo]
|
!p.arg.isStatic)
|
// v-bind:[foo]
|
);
|
}
|
function isText$1(node) {
|
return node.type === 5 || node.type === 2;
|
}
|
function isVSlot(p) {
|
return p.type === 7 && p.name === "slot";
|
}
|
function isTemplateNode(node) {
|
return node.type === 1 && node.tagType === 3;
|
}
|
function isSlotOutlet(node) {
|
return node.type === 1 && node.tagType === 2;
|
}
|
const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
|
function getUnnormalizedProps(props, callPath = []) {
|
if (props && !isString$2(props) && props.type === 14) {
|
const callee = props.callee;
|
if (!isString$2(callee) && propsHelperSet.has(callee)) {
|
return getUnnormalizedProps(
|
props.arguments[0],
|
callPath.concat(props)
|
);
|
}
|
}
|
return [props, callPath];
|
}
|
function injectProp(node, prop, context) {
|
let propsWithInjection;
|
let props = node.type === 13 ? node.props : node.arguments[2];
|
let callPath = [];
|
let parentCall;
|
if (props && !isString$2(props) && props.type === 14) {
|
const ret = getUnnormalizedProps(props);
|
props = ret[0];
|
callPath = ret[1];
|
parentCall = callPath[callPath.length - 1];
|
}
|
if (props == null || isString$2(props)) {
|
propsWithInjection = createObjectExpression([prop]);
|
} else if (props.type === 14) {
|
const first = props.arguments[0];
|
if (!isString$2(first) && first.type === 15) {
|
if (!hasProp(prop, first)) {
|
first.properties.unshift(prop);
|
}
|
} else {
|
if (props.callee === TO_HANDLERS) {
|
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
|
createObjectExpression([prop]),
|
props
|
]);
|
} else {
|
props.arguments.unshift(createObjectExpression([prop]));
|
}
|
}
|
!propsWithInjection && (propsWithInjection = props);
|
} else if (props.type === 15) {
|
if (!hasProp(prop, props)) {
|
props.properties.unshift(prop);
|
}
|
propsWithInjection = props;
|
} else {
|
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
|
createObjectExpression([prop]),
|
props
|
]);
|
if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
|
parentCall = callPath[callPath.length - 2];
|
}
|
}
|
if (node.type === 13) {
|
if (parentCall) {
|
parentCall.arguments[0] = propsWithInjection;
|
} else {
|
node.props = propsWithInjection;
|
}
|
} else {
|
if (parentCall) {
|
parentCall.arguments[0] = propsWithInjection;
|
} else {
|
node.arguments[2] = propsWithInjection;
|
}
|
}
|
}
|
function hasProp(prop, props) {
|
let result = false;
|
if (prop.key.type === 4) {
|
const propKeyName = prop.key.content;
|
result = props.properties.some(
|
(p) => p.key.type === 4 && p.key.content === propKeyName
|
);
|
}
|
return result;
|
}
|
function toValidAssetId(name, type) {
|
return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
|
return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
|
})}`;
|
}
|
function hasScopeRef(node, ids) {
|
if (!node || Object.keys(ids).length === 0) {
|
return false;
|
}
|
switch (node.type) {
|
case 1:
|
for (let i = 0; i < node.props.length; i++) {
|
const p = node.props[i];
|
if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {
|
return true;
|
}
|
}
|
return node.children.some((c) => hasScopeRef(c, ids));
|
case 11:
|
if (hasScopeRef(node.source, ids)) {
|
return true;
|
}
|
return node.children.some((c) => hasScopeRef(c, ids));
|
case 9:
|
return node.branches.some((b) => hasScopeRef(b, ids));
|
case 10:
|
if (hasScopeRef(node.condition, ids)) {
|
return true;
|
}
|
return node.children.some((c) => hasScopeRef(c, ids));
|
case 4:
|
return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
|
case 8:
|
return node.children.some((c) => isObject$2(c) && hasScopeRef(c, ids));
|
case 5:
|
case 12:
|
return hasScopeRef(node.content, ids);
|
case 2:
|
case 3:
|
return false;
|
default:
|
return false;
|
}
|
}
|
function getMemoedVNodeCall(node) {
|
if (node.type === 14 && node.callee === WITH_MEMO) {
|
return node.arguments[1].returns;
|
} else {
|
return node;
|
}
|
}
|
|
const deprecationData = {
|
["COMPILER_IS_ON_ELEMENT"]: {
|
message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
|
link: `https://v3-migration.vuejs.org/breaking-changes/custom-elements-interop.html`
|
},
|
["COMPILER_V_BIND_SYNC"]: {
|
message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
|
link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
|
},
|
["COMPILER_V_BIND_PROP"]: {
|
message: `.prop modifier for v-bind has been removed and no longer necessary. Vue 3 will automatically set a binding as DOM property when appropriate.`
|
},
|
["COMPILER_V_BIND_OBJECT_ORDER"]: {
|
message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
|
link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
|
},
|
["COMPILER_V_ON_NATIVE"]: {
|
message: `.native modifier for v-on has been removed as is no longer necessary.`,
|
link: `https://v3-migration.vuejs.org/breaking-changes/v-on-native-modifier-removed.html`
|
},
|
["COMPILER_V_IF_V_FOR_PRECEDENCE"]: {
|
message: `v-if / v-for precedence when used on the same element has changed in Vue 3: v-if now takes higher precedence and will no longer have access to v-for scope variables. It is best to avoid the ambiguity with <template> tags or use a computed property that filters v-for data source.`,
|
link: `https://v3-migration.vuejs.org/breaking-changes/v-if-v-for.html`
|
},
|
["COMPILER_NATIVE_TEMPLATE"]: {
|
message: `<template> with no special directives will render as a native template element instead of its inner content in Vue 3.`
|
},
|
["COMPILER_INLINE_TEMPLATE"]: {
|
message: `"inline-template" has been removed in Vue 3.`,
|
link: `https://v3-migration.vuejs.org/breaking-changes/inline-template-attribute.html`
|
},
|
["COMPILER_FILTER"]: {
|
message: `filters have been removed in Vue 3. The "|" symbol will be treated as native JavaScript bitwise OR operator. Use method calls or computed properties instead.`,
|
link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
|
}
|
};
|
function getCompatValue(key, context) {
|
const config = context.options ? context.options.compatConfig : context.compatConfig;
|
const value = config && config[key];
|
if (key === "MODE") {
|
return value || 3;
|
} else {
|
return value;
|
}
|
}
|
function isCompatEnabled(key, context) {
|
const mode = getCompatValue("MODE", context);
|
const value = getCompatValue(key, context);
|
return mode === 3 ? value === true : value !== false;
|
}
|
function checkCompatEnabled(key, context, loc, ...args) {
|
const enabled = isCompatEnabled(key, context);
|
if (enabled) {
|
warnDeprecation(key, context, loc, ...args);
|
}
|
return enabled;
|
}
|
function warnDeprecation(key, context, loc, ...args) {
|
const val = getCompatValue(key, context);
|
if (val === "suppress-warning") {
|
return;
|
}
|
const { message, link } = deprecationData[key];
|
const msg = `(deprecation ${key}) ${typeof message === "function" ? message(...args) : message}${link ? `
|
Details: ${link}` : ``}`;
|
const err = new SyntaxError(msg);
|
err.code = key;
|
if (loc)
|
err.loc = loc;
|
context.onWarn(err);
|
}
|
|
const decodeRE = /&(gt|lt|amp|apos|quot);/g;
|
const decodeMap = {
|
gt: ">",
|
lt: "<",
|
amp: "&",
|
apos: "'",
|
quot: '"'
|
};
|
const defaultParserOptions = {
|
delimiters: [`{{`, `}}`],
|
getNamespace: () => 0,
|
getTextMode: () => 0,
|
isVoidTag: NO,
|
isPreTag: NO,
|
isCustomElement: NO,
|
decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]),
|
onError: defaultOnError,
|
onWarn: defaultOnWarn,
|
comments: true
|
};
|
function baseParse(content, options = {}) {
|
const context = createParserContext(content, options);
|
const start = getCursor(context);
|
return createRoot(
|
parseChildren(context, 0, []),
|
getSelection(context, start)
|
);
|
}
|
function createParserContext(content, rawOptions) {
|
const options = extend({}, defaultParserOptions);
|
let key;
|
for (key in rawOptions) {
|
options[key] = rawOptions[key] === void 0 ? defaultParserOptions[key] : rawOptions[key];
|
}
|
return {
|
options,
|
column: 1,
|
line: 1,
|
offset: 0,
|
originalSource: content,
|
source: content,
|
inPre: false,
|
inVPre: false,
|
onWarn: options.onWarn
|
};
|
}
|
function parseChildren(context, mode, ancestors) {
|
const parent = last(ancestors);
|
const ns = parent ? parent.ns : 0;
|
const nodes = [];
|
while (!isEnd(context, mode, ancestors)) {
|
const s = context.source;
|
let node = void 0;
|
if (mode === 0 || mode === 1) {
|
if (!context.inVPre && startsWith(s, context.options.delimiters[0])) {
|
node = parseInterpolation(context, mode);
|
} else if (mode === 0 && s[0] === "<") {
|
if (s.length === 1) {
|
emitError(context, 5, 1);
|
} else if (s[1] === "!") {
|
if (startsWith(s, "<!--")) {
|
node = parseComment(context);
|
} else if (startsWith(s, "<!DOCTYPE")) {
|
node = parseBogusComment(context);
|
} else if (startsWith(s, "<![CDATA[")) {
|
if (ns !== 0) {
|
node = parseCDATA(context, ancestors);
|
} else {
|
emitError(context, 1);
|
node = parseBogusComment(context);
|
}
|
} else {
|
emitError(context, 11);
|
node = parseBogusComment(context);
|
}
|
} else if (s[1] === "/") {
|
if (s.length === 2) {
|
emitError(context, 5, 2);
|
} else if (s[2] === ">") {
|
emitError(context, 14, 2);
|
advanceBy(context, 3);
|
continue;
|
} else if (/[a-z]/i.test(s[2])) {
|
emitError(context, 23);
|
parseTag(context, TagType.End, parent);
|
continue;
|
} else {
|
emitError(
|
context,
|
12,
|
2
|
);
|
node = parseBogusComment(context);
|
}
|
} else if (/[a-z]/i.test(s[1])) {
|
node = parseElement(context, ancestors);
|
} else if (s[1] === "?") {
|
emitError(
|
context,
|
21,
|
1
|
);
|
node = parseBogusComment(context);
|
} else {
|
emitError(context, 12, 1);
|
}
|
}
|
}
|
if (!node) {
|
node = parseText(context, mode);
|
}
|
if (isArray$3(node)) {
|
for (let i = 0; i < node.length; i++) {
|
pushNode(nodes, node[i]);
|
}
|
} else {
|
pushNode(nodes, node);
|
}
|
}
|
let removedWhitespace = false;
|
if (mode !== 2 && mode !== 1) {
|
const shouldCondense = context.options.whitespace !== "preserve";
|
for (let i = 0; i < nodes.length; i++) {
|
const node = nodes[i];
|
if (node.type === 2) {
|
if (!context.inPre) {
|
if (!/[^\t\r\n\f ]/.test(node.content)) {
|
const prev = nodes[i - 1];
|
const next = nodes[i + 1];
|
if (!prev || !next || shouldCondense && (prev.type === 3 && next.type === 3 || prev.type === 3 && next.type === 1 || prev.type === 1 && next.type === 3 || prev.type === 1 && next.type === 1 && /[\r\n]/.test(node.content))) {
|
removedWhitespace = true;
|
nodes[i] = null;
|
} else {
|
node.content = " ";
|
}
|
} else if (shouldCondense) {
|
node.content = node.content.replace(/[\t\r\n\f ]+/g, " ");
|
}
|
} else {
|
node.content = node.content.replace(/\r\n/g, "\n");
|
}
|
} else if (node.type === 3 && !context.options.comments) {
|
removedWhitespace = true;
|
nodes[i] = null;
|
}
|
}
|
if (context.inPre && parent && context.options.isPreTag(parent.tag)) {
|
const first = nodes[0];
|
if (first && first.type === 2) {
|
first.content = first.content.replace(/^\r?\n/, "");
|
}
|
}
|
}
|
return removedWhitespace ? nodes.filter(Boolean) : nodes;
|
}
|
function pushNode(nodes, node) {
|
if (node.type === 2) {
|
const prev = last(nodes);
|
if (prev && prev.type === 2 && prev.loc.end.offset === node.loc.start.offset) {
|
prev.content += node.content;
|
prev.loc.end = node.loc.end;
|
prev.loc.source += node.loc.source;
|
return;
|
}
|
}
|
nodes.push(node);
|
}
|
function parseCDATA(context, ancestors) {
|
advanceBy(context, 9);
|
const nodes = parseChildren(context, 3, ancestors);
|
if (context.source.length === 0) {
|
emitError(context, 6);
|
} else {
|
advanceBy(context, 3);
|
}
|
return nodes;
|
}
|
function parseComment(context) {
|
const start = getCursor(context);
|
let content;
|
const match = /--(\!)?>/.exec(context.source);
|
if (!match) {
|
content = context.source.slice(4);
|
advanceBy(context, context.source.length);
|
emitError(context, 7);
|
} else {
|
if (match.index <= 3) {
|
emitError(context, 0);
|
}
|
if (match[1]) {
|
emitError(context, 10);
|
}
|
content = context.source.slice(4, match.index);
|
const s = context.source.slice(0, match.index);
|
let prevIndex = 1, nestedIndex = 0;
|
while ((nestedIndex = s.indexOf("<!--", prevIndex)) !== -1) {
|
advanceBy(context, nestedIndex - prevIndex + 1);
|
if (nestedIndex + 4 < s.length) {
|
emitError(context, 16);
|
}
|
prevIndex = nestedIndex + 1;
|
}
|
advanceBy(context, match.index + match[0].length - prevIndex + 1);
|
}
|
return {
|
type: 3,
|
content,
|
loc: getSelection(context, start)
|
};
|
}
|
function parseBogusComment(context) {
|
const start = getCursor(context);
|
const contentStart = context.source[1] === "?" ? 1 : 2;
|
let content;
|
const closeIndex = context.source.indexOf(">");
|
if (closeIndex === -1) {
|
content = context.source.slice(contentStart);
|
advanceBy(context, context.source.length);
|
} else {
|
content = context.source.slice(contentStart, closeIndex);
|
advanceBy(context, closeIndex + 1);
|
}
|
return {
|
type: 3,
|
content,
|
loc: getSelection(context, start)
|
};
|
}
|
function parseElement(context, ancestors) {
|
const wasInPre = context.inPre;
|
const wasInVPre = context.inVPre;
|
const parent = last(ancestors);
|
const element = parseTag(context, TagType.Start, parent);
|
const isPreBoundary = context.inPre && !wasInPre;
|
const isVPreBoundary = context.inVPre && !wasInVPre;
|
if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {
|
if (isPreBoundary) {
|
context.inPre = false;
|
}
|
if (isVPreBoundary) {
|
context.inVPre = false;
|
}
|
return element;
|
}
|
ancestors.push(element);
|
const mode = context.options.getTextMode(element, parent);
|
const children = parseChildren(context, mode, ancestors);
|
ancestors.pop();
|
element.children = children;
|
if (startsWithEndTagOpen(context.source, element.tag)) {
|
parseTag(context, TagType.End, parent);
|
} else {
|
emitError(context, 24, 0, element.loc.start);
|
if (context.source.length === 0 && element.tag.toLowerCase() === "script") {
|
const first = children[0];
|
if (first && startsWith(first.loc.source, "<!--")) {
|
emitError(context, 8);
|
}
|
}
|
}
|
element.loc = getSelection(context, element.loc.start);
|
if (isPreBoundary) {
|
context.inPre = false;
|
}
|
if (isVPreBoundary) {
|
context.inVPre = false;
|
}
|
return element;
|
}
|
var TagType = /* @__PURE__ */ ((TagType2) => {
|
TagType2[TagType2["Start"] = 0] = "Start";
|
TagType2[TagType2["End"] = 1] = "End";
|
return TagType2;
|
})(TagType || {});
|
const isSpecialTemplateDirective = /* @__PURE__ */ makeMap(
|
`if,else,else-if,for,slot`
|
);
|
function parseTag(context, type, parent) {
|
const start = getCursor(context);
|
const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source);
|
const tag = match[1];
|
const ns = context.options.getNamespace(tag, parent);
|
advanceBy(context, match[0].length);
|
advanceSpaces(context);
|
const cursor = getCursor(context);
|
const currentSource = context.source;
|
if (context.options.isPreTag(tag)) {
|
context.inPre = true;
|
}
|
let props = parseAttributes(context, type);
|
if (type === 0 /* Start */ && !context.inVPre && props.some((p) => p.type === 7 && p.name === "pre")) {
|
context.inVPre = true;
|
extend(context, cursor);
|
context.source = currentSource;
|
props = parseAttributes(context, type).filter((p) => p.name !== "v-pre");
|
}
|
let isSelfClosing = false;
|
if (context.source.length === 0) {
|
emitError(context, 9);
|
} else {
|
isSelfClosing = startsWith(context.source, "/>");
|
if (type === 1 /* End */ && isSelfClosing) {
|
emitError(context, 4);
|
}
|
advanceBy(context, isSelfClosing ? 2 : 1);
|
}
|
if (type === 1 /* End */) {
|
return;
|
}
|
let tagType = 0;
|
if (!context.inVPre) {
|
if (tag === "slot") {
|
tagType = 2;
|
} else if (tag === "template") {
|
if (props.some(
|
(p) => p.type === 7 && isSpecialTemplateDirective(p.name)
|
)) {
|
tagType = 3;
|
}
|
} else if (isComponent(tag, props, context)) {
|
tagType = 1;
|
}
|
}
|
return {
|
type: 1,
|
ns,
|
tag,
|
tagType,
|
props,
|
isSelfClosing,
|
children: [],
|
loc: getSelection(context, start),
|
codegenNode: void 0
|
// to be created during transform phase
|
};
|
}
|
function isComponent(tag, props, context) {
|
const options = context.options;
|
if (options.isCustomElement(tag)) {
|
return false;
|
}
|
if (tag === "component" || /^[A-Z]/.test(tag) || isCoreComponent(tag) || options.isBuiltInComponent && options.isBuiltInComponent(tag) || options.isNativeTag && !options.isNativeTag(tag)) {
|
return true;
|
}
|
for (let i = 0; i < props.length; i++) {
|
const p = props[i];
|
if (p.type === 6) {
|
if (p.name === "is" && p.value) {
|
if (p.value.content.startsWith("vue:")) {
|
return true;
|
}
|
}
|
} else {
|
if (p.name === "is") {
|
return true;
|
} else if (
|
// :is on plain element - only treat as component in compat mode
|
p.name === "bind" && isStaticArgOf(p.arg, "is") && false
|
) {
|
return true;
|
}
|
}
|
}
|
}
|
function parseAttributes(context, type) {
|
const props = [];
|
const attributeNames = /* @__PURE__ */ new Set();
|
while (context.source.length > 0 && !startsWith(context.source, ">") && !startsWith(context.source, "/>")) {
|
if (startsWith(context.source, "/")) {
|
emitError(context, 22);
|
advanceBy(context, 1);
|
advanceSpaces(context);
|
continue;
|
}
|
if (type === 1 /* End */) {
|
emitError(context, 3);
|
}
|
const attr = parseAttribute(context, attributeNames);
|
if (attr.type === 6 && attr.value && attr.name === "class") {
|
attr.value.content = attr.value.content.replace(/\s+/g, " ").trim();
|
}
|
if (type === 0 /* Start */) {
|
props.push(attr);
|
}
|
if (/^[^\t\r\n\f />]/.test(context.source)) {
|
emitError(context, 15);
|
}
|
advanceSpaces(context);
|
}
|
return props;
|
}
|
function parseAttribute(context, nameSet) {
|
var _a;
|
const start = getCursor(context);
|
const match = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(context.source);
|
const name = match[0];
|
if (nameSet.has(name)) {
|
emitError(context, 2);
|
}
|
nameSet.add(name);
|
if (name[0] === "=") {
|
emitError(context, 19);
|
}
|
{
|
const pattern = /["'<]/g;
|
let m;
|
while (m = pattern.exec(name)) {
|
emitError(
|
context,
|
17,
|
m.index
|
);
|
}
|
}
|
advanceBy(context, name.length);
|
let value = void 0;
|
if (/^[\t\r\n\f ]*=/.test(context.source)) {
|
advanceSpaces(context);
|
advanceBy(context, 1);
|
advanceSpaces(context);
|
value = parseAttributeValue(context);
|
if (!value) {
|
emitError(context, 13);
|
}
|
}
|
const loc = getSelection(context, start);
|
if (!context.inVPre && /^(v-[A-Za-z0-9-]|:|\.|@|#)/.test(name)) {
|
const match2 = /(?:^v-([a-z0-9-]+))?(?:(?::|^\.|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(
|
name
|
);
|
let isPropShorthand = startsWith(name, ".");
|
let dirName = match2[1] || (isPropShorthand || startsWith(name, ":") ? "bind" : startsWith(name, "@") ? "on" : "slot");
|
let arg;
|
if (match2[2]) {
|
const isSlot = dirName === "slot";
|
const startOffset = name.lastIndexOf(
|
match2[2],
|
name.length - (((_a = match2[3]) == null ? void 0 : _a.length) || 0)
|
);
|
const loc2 = getSelection(
|
context,
|
getNewPosition(context, start, startOffset),
|
getNewPosition(
|
context,
|
start,
|
startOffset + match2[2].length + (isSlot && match2[3] || "").length
|
)
|
);
|
let content = match2[2];
|
let isStatic = true;
|
if (content.startsWith("[")) {
|
isStatic = false;
|
if (!content.endsWith("]")) {
|
emitError(
|
context,
|
27
|
);
|
content = content.slice(1);
|
} else {
|
content = content.slice(1, content.length - 1);
|
}
|
} else if (isSlot) {
|
content += match2[3] || "";
|
}
|
arg = {
|
type: 4,
|
content,
|
isStatic,
|
constType: isStatic ? 3 : 0,
|
loc: loc2
|
};
|
}
|
if (value && value.isQuoted) {
|
const valueLoc = value.loc;
|
valueLoc.start.offset++;
|
valueLoc.start.column++;
|
valueLoc.end = advancePositionWithClone(valueLoc.start, value.content);
|
valueLoc.source = valueLoc.source.slice(1, -1);
|
}
|
const modifiers = match2[3] ? match2[3].slice(1).split(".") : [];
|
if (isPropShorthand)
|
modifiers.push("prop");
|
return {
|
type: 7,
|
name: dirName,
|
exp: value && {
|
type: 4,
|
content: value.content,
|
isStatic: false,
|
// Treat as non-constant by default. This can be potentially set to
|
// other values by `transformExpression` to make it eligible for hoisting.
|
constType: 0,
|
loc: value.loc
|
},
|
arg,
|
modifiers,
|
loc
|
};
|
}
|
if (!context.inVPre && startsWith(name, "v-")) {
|
emitError(context, 26);
|
}
|
return {
|
type: 6,
|
name,
|
value: value && {
|
type: 2,
|
content: value.content,
|
loc: value.loc
|
},
|
loc
|
};
|
}
|
function parseAttributeValue(context) {
|
const start = getCursor(context);
|
let content;
|
const quote = context.source[0];
|
const isQuoted = quote === `"` || quote === `'`;
|
if (isQuoted) {
|
advanceBy(context, 1);
|
const endIndex = context.source.indexOf(quote);
|
if (endIndex === -1) {
|
content = parseTextData(
|
context,
|
context.source.length,
|
4
|
);
|
} else {
|
content = parseTextData(context, endIndex, 4);
|
advanceBy(context, 1);
|
}
|
} else {
|
const match = /^[^\t\r\n\f >]+/.exec(context.source);
|
if (!match) {
|
return void 0;
|
}
|
const unexpectedChars = /["'<=`]/g;
|
let m;
|
while (m = unexpectedChars.exec(match[0])) {
|
emitError(
|
context,
|
18,
|
m.index
|
);
|
}
|
content = parseTextData(context, match[0].length, 4);
|
}
|
return { content, isQuoted, loc: getSelection(context, start) };
|
}
|
function parseInterpolation(context, mode) {
|
const [open, close] = context.options.delimiters;
|
const closeIndex = context.source.indexOf(close, open.length);
|
if (closeIndex === -1) {
|
emitError(context, 25);
|
return void 0;
|
}
|
const start = getCursor(context);
|
advanceBy(context, open.length);
|
const innerStart = getCursor(context);
|
const innerEnd = getCursor(context);
|
const rawContentLength = closeIndex - open.length;
|
const rawContent = context.source.slice(0, rawContentLength);
|
const preTrimContent = parseTextData(context, rawContentLength, mode);
|
const content = preTrimContent.trim();
|
const startOffset = preTrimContent.indexOf(content);
|
if (startOffset > 0) {
|
advancePositionWithMutation(innerStart, rawContent, startOffset);
|
}
|
const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset);
|
advancePositionWithMutation(innerEnd, rawContent, endOffset);
|
advanceBy(context, close.length);
|
return {
|
type: 5,
|
content: {
|
type: 4,
|
isStatic: false,
|
// Set `isConstant` to false by default and will decide in transformExpression
|
constType: 0,
|
content,
|
loc: getSelection(context, innerStart, innerEnd)
|
},
|
loc: getSelection(context, start)
|
};
|
}
|
function parseText(context, mode) {
|
const endTokens = mode === 3 ? ["]]>"] : ["<", context.options.delimiters[0]];
|
let endIndex = context.source.length;
|
for (let i = 0; i < endTokens.length; i++) {
|
const index = context.source.indexOf(endTokens[i], 1);
|
if (index !== -1 && endIndex > index) {
|
endIndex = index;
|
}
|
}
|
const start = getCursor(context);
|
const content = parseTextData(context, endIndex, mode);
|
return {
|
type: 2,
|
content,
|
loc: getSelection(context, start)
|
};
|
}
|
function parseTextData(context, length, mode) {
|
const rawText = context.source.slice(0, length);
|
advanceBy(context, length);
|
if (mode === 2 || mode === 3 || !rawText.includes("&")) {
|
return rawText;
|
} else {
|
return context.options.decodeEntities(
|
rawText,
|
mode === 4
|
);
|
}
|
}
|
function getCursor(context) {
|
const { column, line, offset } = context;
|
return { column, line, offset };
|
}
|
function getSelection(context, start, end) {
|
end = end || getCursor(context);
|
return {
|
start,
|
end,
|
source: context.originalSource.slice(start.offset, end.offset)
|
};
|
}
|
function last(xs) {
|
return xs[xs.length - 1];
|
}
|
function startsWith(source, searchString) {
|
return source.startsWith(searchString);
|
}
|
function advanceBy(context, numberOfCharacters) {
|
const { source } = context;
|
advancePositionWithMutation(context, source, numberOfCharacters);
|
context.source = source.slice(numberOfCharacters);
|
}
|
function advanceSpaces(context) {
|
const match = /^[\t\r\n\f ]+/.exec(context.source);
|
if (match) {
|
advanceBy(context, match[0].length);
|
}
|
}
|
function getNewPosition(context, start, numberOfCharacters) {
|
return advancePositionWithClone(
|
start,
|
context.originalSource.slice(start.offset, numberOfCharacters),
|
numberOfCharacters
|
);
|
}
|
function emitError(context, code, offset, loc = getCursor(context)) {
|
if (offset) {
|
loc.offset += offset;
|
loc.column += offset;
|
}
|
context.options.onError(
|
createCompilerError(code, {
|
start: loc,
|
end: loc,
|
source: ""
|
})
|
);
|
}
|
function isEnd(context, mode, ancestors) {
|
const s = context.source;
|
switch (mode) {
|
case 0:
|
if (startsWith(s, "</")) {
|
for (let i = ancestors.length - 1; i >= 0; --i) {
|
if (startsWithEndTagOpen(s, ancestors[i].tag)) {
|
return true;
|
}
|
}
|
}
|
break;
|
case 1:
|
case 2: {
|
const parent = last(ancestors);
|
if (parent && startsWithEndTagOpen(s, parent.tag)) {
|
return true;
|
}
|
break;
|
}
|
case 3:
|
if (startsWith(s, "]]>")) {
|
return true;
|
}
|
break;
|
}
|
return !s;
|
}
|
function startsWithEndTagOpen(source, tag) {
|
return startsWith(source, "</") && source.slice(2, 2 + tag.length).toLowerCase() === tag.toLowerCase() && /[\t\r\n\f />]/.test(source[2 + tag.length] || ">");
|
}
|
|
function hoistStatic(root, context) {
|
walk$2(
|
root,
|
context,
|
// Root node is unfortunately non-hoistable due to potential parent
|
// fallthrough attributes.
|
isSingleElementRoot(root, root.children[0])
|
);
|
}
|
function isSingleElementRoot(root, child) {
|
const { children } = root;
|
return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
|
}
|
function walk$2(node, context, doNotHoistNode = false) {
|
const { children } = node;
|
const originalCount = children.length;
|
let hoistedCount = 0;
|
for (let i = 0; i < children.length; i++) {
|
const child = children[i];
|
if (child.type === 1 && child.tagType === 0) {
|
const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
|
if (constantType > 0) {
|
if (constantType >= 2) {
|
child.codegenNode.patchFlag = -1 + (` /* HOISTED */` );
|
child.codegenNode = context.hoist(child.codegenNode);
|
hoistedCount++;
|
continue;
|
}
|
} else {
|
const codegenNode = child.codegenNode;
|
if (codegenNode.type === 13) {
|
const flag = getPatchFlag(codegenNode);
|
if ((!flag || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
|
const props = getNodeProps(child);
|
if (props) {
|
codegenNode.props = context.hoist(props);
|
}
|
}
|
if (codegenNode.dynamicProps) {
|
codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
|
}
|
}
|
}
|
}
|
if (child.type === 1) {
|
const isComponent = child.tagType === 1;
|
if (isComponent) {
|
context.scopes.vSlot++;
|
}
|
walk$2(child, context);
|
if (isComponent) {
|
context.scopes.vSlot--;
|
}
|
} else if (child.type === 11) {
|
walk$2(child, context, child.children.length === 1);
|
} else if (child.type === 9) {
|
for (let i2 = 0; i2 < child.branches.length; i2++) {
|
walk$2(
|
child.branches[i2],
|
context,
|
child.branches[i2].children.length === 1
|
);
|
}
|
}
|
}
|
if (hoistedCount && context.transformHoist) {
|
context.transformHoist(children, context, node);
|
}
|
if (hoistedCount && hoistedCount === originalCount && node.type === 1 && node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray$3(node.codegenNode.children)) {
|
node.codegenNode.children = context.hoist(
|
createArrayExpression(node.codegenNode.children)
|
);
|
}
|
}
|
function getConstantType(node, context) {
|
const { constantCache } = context;
|
switch (node.type) {
|
case 1:
|
if (node.tagType !== 0) {
|
return 0;
|
}
|
const cached = constantCache.get(node);
|
if (cached !== void 0) {
|
return cached;
|
}
|
const codegenNode = node.codegenNode;
|
if (codegenNode.type !== 13) {
|
return 0;
|
}
|
if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject") {
|
return 0;
|
}
|
const flag = getPatchFlag(codegenNode);
|
if (!flag) {
|
let returnType2 = 3;
|
const generatedPropsType = getGeneratedPropsConstantType(node, context);
|
if (generatedPropsType === 0) {
|
constantCache.set(node, 0);
|
return 0;
|
}
|
if (generatedPropsType < returnType2) {
|
returnType2 = generatedPropsType;
|
}
|
for (let i = 0; i < node.children.length; i++) {
|
const childType = getConstantType(node.children[i], context);
|
if (childType === 0) {
|
constantCache.set(node, 0);
|
return 0;
|
}
|
if (childType < returnType2) {
|
returnType2 = childType;
|
}
|
}
|
if (returnType2 > 1) {
|
for (let i = 0; i < node.props.length; i++) {
|
const p = node.props[i];
|
if (p.type === 7 && p.name === "bind" && p.exp) {
|
const expType = getConstantType(p.exp, context);
|
if (expType === 0) {
|
constantCache.set(node, 0);
|
return 0;
|
}
|
if (expType < returnType2) {
|
returnType2 = expType;
|
}
|
}
|
}
|
}
|
if (codegenNode.isBlock) {
|
for (let i = 0; i < node.props.length; i++) {
|
const p = node.props[i];
|
if (p.type === 7) {
|
constantCache.set(node, 0);
|
return 0;
|
}
|
}
|
context.removeHelper(OPEN_BLOCK);
|
context.removeHelper(
|
getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)
|
);
|
codegenNode.isBlock = false;
|
context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
|
}
|
constantCache.set(node, returnType2);
|
return returnType2;
|
} else {
|
constantCache.set(node, 0);
|
return 0;
|
}
|
case 2:
|
case 3:
|
return 3;
|
case 9:
|
case 11:
|
case 10:
|
return 0;
|
case 5:
|
case 12:
|
return getConstantType(node.content, context);
|
case 4:
|
return node.constType;
|
case 8:
|
let returnType = 3;
|
for (let i = 0; i < node.children.length; i++) {
|
const child = node.children[i];
|
if (isString$2(child) || isSymbol$1(child)) {
|
continue;
|
}
|
const childType = getConstantType(child, context);
|
if (childType === 0) {
|
return 0;
|
} else if (childType < returnType) {
|
returnType = childType;
|
}
|
}
|
return returnType;
|
default:
|
return 0;
|
}
|
}
|
const allowHoistedHelperSet = /* @__PURE__ */ new Set([
|
NORMALIZE_CLASS,
|
NORMALIZE_STYLE,
|
NORMALIZE_PROPS,
|
GUARD_REACTIVE_PROPS
|
]);
|
function getConstantTypeOfHelperCall(value, context) {
|
if (value.type === 14 && !isString$2(value.callee) && allowHoistedHelperSet.has(value.callee)) {
|
const arg = value.arguments[0];
|
if (arg.type === 4) {
|
return getConstantType(arg, context);
|
} else if (arg.type === 14) {
|
return getConstantTypeOfHelperCall(arg, context);
|
}
|
}
|
return 0;
|
}
|
function getGeneratedPropsConstantType(node, context) {
|
let returnType = 3;
|
const props = getNodeProps(node);
|
if (props && props.type === 15) {
|
const { properties } = props;
|
for (let i = 0; i < properties.length; i++) {
|
const { key, value } = properties[i];
|
const keyType = getConstantType(key, context);
|
if (keyType === 0) {
|
return keyType;
|
}
|
if (keyType < returnType) {
|
returnType = keyType;
|
}
|
let valueType;
|
if (value.type === 4) {
|
valueType = getConstantType(value, context);
|
} else if (value.type === 14) {
|
valueType = getConstantTypeOfHelperCall(value, context);
|
} else {
|
valueType = 0;
|
}
|
if (valueType === 0) {
|
return valueType;
|
}
|
if (valueType < returnType) {
|
returnType = valueType;
|
}
|
}
|
}
|
return returnType;
|
}
|
function getNodeProps(node) {
|
const codegenNode = node.codegenNode;
|
if (codegenNode.type === 13) {
|
return codegenNode.props;
|
}
|
}
|
function getPatchFlag(node) {
|
const flag = node.patchFlag;
|
return flag ? parseInt(flag, 10) : void 0;
|
}
|
|
function createTransformContext(root, {
|
filename = "",
|
prefixIdentifiers = false,
|
hoistStatic: hoistStatic2 = false,
|
cacheHandlers = false,
|
nodeTransforms = [],
|
directiveTransforms = {},
|
transformHoist = null,
|
isBuiltInComponent = NOOP,
|
isCustomElement = NOOP,
|
expressionPlugins = [],
|
scopeId = null,
|
slotted = true,
|
ssr = false,
|
inSSR = false,
|
ssrCssVars = ``,
|
bindingMetadata = EMPTY_OBJ,
|
inline = false,
|
isTS = false,
|
onError = defaultOnError,
|
onWarn = defaultOnWarn,
|
compatConfig
|
}) {
|
const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
|
const context = {
|
// options
|
selfName: nameMatch && capitalize$1(camelize(nameMatch[1])),
|
prefixIdentifiers,
|
hoistStatic: hoistStatic2,
|
cacheHandlers,
|
nodeTransforms,
|
directiveTransforms,
|
transformHoist,
|
isBuiltInComponent,
|
isCustomElement,
|
expressionPlugins,
|
scopeId,
|
slotted,
|
ssr,
|
inSSR,
|
ssrCssVars,
|
bindingMetadata,
|
inline,
|
isTS,
|
onError,
|
onWarn,
|
compatConfig,
|
// state
|
root,
|
helpers: /* @__PURE__ */ new Map(),
|
components: /* @__PURE__ */ new Set(),
|
directives: /* @__PURE__ */ new Set(),
|
hoists: [],
|
imports: [],
|
constantCache: /* @__PURE__ */ new Map(),
|
temps: 0,
|
cached: 0,
|
identifiers: /* @__PURE__ */ Object.create(null),
|
scopes: {
|
vFor: 0,
|
vSlot: 0,
|
vPre: 0,
|
vOnce: 0
|
},
|
parent: null,
|
currentNode: root,
|
childIndex: 0,
|
inVOnce: false,
|
// methods
|
helper(name) {
|
const count = context.helpers.get(name) || 0;
|
context.helpers.set(name, count + 1);
|
return name;
|
},
|
removeHelper(name) {
|
const count = context.helpers.get(name);
|
if (count) {
|
const currentCount = count - 1;
|
if (!currentCount) {
|
context.helpers.delete(name);
|
} else {
|
context.helpers.set(name, currentCount);
|
}
|
}
|
},
|
helperString(name) {
|
return `_${helperNameMap[context.helper(name)]}`;
|
},
|
replaceNode(node) {
|
{
|
if (!context.currentNode) {
|
throw new Error(`Node being replaced is already removed.`);
|
}
|
if (!context.parent) {
|
throw new Error(`Cannot replace root node.`);
|
}
|
}
|
context.parent.children[context.childIndex] = context.currentNode = node;
|
},
|
removeNode(node) {
|
if (!context.parent) {
|
throw new Error(`Cannot remove root node.`);
|
}
|
const list = context.parent.children;
|
const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
|
if (removalIndex < 0) {
|
throw new Error(`node being removed is not a child of current parent`);
|
}
|
if (!node || node === context.currentNode) {
|
context.currentNode = null;
|
context.onNodeRemoved();
|
} else {
|
if (context.childIndex > removalIndex) {
|
context.childIndex--;
|
context.onNodeRemoved();
|
}
|
}
|
context.parent.children.splice(removalIndex, 1);
|
},
|
onNodeRemoved: () => {
|
},
|
addIdentifiers(exp) {
|
{
|
if (isString$2(exp)) {
|
addId(exp);
|
} else if (exp.identifiers) {
|
exp.identifiers.forEach(addId);
|
} else if (exp.type === 4) {
|
addId(exp.content);
|
}
|
}
|
},
|
removeIdentifiers(exp) {
|
{
|
if (isString$2(exp)) {
|
removeId(exp);
|
} else if (exp.identifiers) {
|
exp.identifiers.forEach(removeId);
|
} else if (exp.type === 4) {
|
removeId(exp.content);
|
}
|
}
|
},
|
hoist(exp) {
|
if (isString$2(exp))
|
exp = createSimpleExpression(exp);
|
context.hoists.push(exp);
|
const identifier = createSimpleExpression(
|
`_hoisted_${context.hoists.length}`,
|
false,
|
exp.loc,
|
2
|
);
|
identifier.hoisted = exp;
|
return identifier;
|
},
|
cache(exp, isVNode = false) {
|
return createCacheExpression(context.cached++, exp, isVNode);
|
}
|
};
|
function addId(id) {
|
const { identifiers } = context;
|
if (identifiers[id] === void 0) {
|
identifiers[id] = 0;
|
}
|
identifiers[id]++;
|
}
|
function removeId(id) {
|
context.identifiers[id]--;
|
}
|
return context;
|
}
|
function transform$1(root, options) {
|
const context = createTransformContext(root, options);
|
traverseNode(root, context);
|
if (options.hoistStatic) {
|
hoistStatic(root, context);
|
}
|
if (!options.ssr) {
|
createRootCodegen(root, context);
|
}
|
root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
|
root.components = [...context.components];
|
root.directives = [...context.directives];
|
root.imports = context.imports;
|
root.hoists = context.hoists;
|
root.temps = context.temps;
|
root.cached = context.cached;
|
}
|
function createRootCodegen(root, context) {
|
const { helper } = context;
|
const { children } = root;
|
if (children.length === 1) {
|
const child = children[0];
|
if (isSingleElementRoot(root, child) && child.codegenNode) {
|
const codegenNode = child.codegenNode;
|
if (codegenNode.type === 13) {
|
convertToBlock(codegenNode, context);
|
}
|
root.codegenNode = codegenNode;
|
} else {
|
root.codegenNode = child;
|
}
|
} else if (children.length > 1) {
|
let patchFlag = 64;
|
let patchFlagText = PatchFlagNames[64];
|
if (children.filter((c) => c.type !== 3).length === 1) {
|
patchFlag |= 2048;
|
patchFlagText += `, ${PatchFlagNames[2048]}`;
|
}
|
root.codegenNode = createVNodeCall(
|
context,
|
helper(FRAGMENT),
|
void 0,
|
root.children,
|
patchFlag + (` /* ${patchFlagText} */` ),
|
void 0,
|
void 0,
|
true,
|
void 0,
|
false
|
/* isComponent */
|
);
|
} else ;
|
}
|
function traverseChildren(parent, context) {
|
let i = 0;
|
const nodeRemoved = () => {
|
i--;
|
};
|
for (; i < parent.children.length; i++) {
|
const child = parent.children[i];
|
if (isString$2(child))
|
continue;
|
context.parent = parent;
|
context.childIndex = i;
|
context.onNodeRemoved = nodeRemoved;
|
traverseNode(child, context);
|
}
|
}
|
function traverseNode(node, context) {
|
context.currentNode = node;
|
const { nodeTransforms } = context;
|
const exitFns = [];
|
for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
|
const onExit = nodeTransforms[i2](node, context);
|
if (onExit) {
|
if (isArray$3(onExit)) {
|
exitFns.push(...onExit);
|
} else {
|
exitFns.push(onExit);
|
}
|
}
|
if (!context.currentNode) {
|
return;
|
} else {
|
node = context.currentNode;
|
}
|
}
|
switch (node.type) {
|
case 3:
|
if (!context.ssr) {
|
context.helper(CREATE_COMMENT);
|
}
|
break;
|
case 5:
|
if (!context.ssr) {
|
context.helper(TO_DISPLAY_STRING);
|
}
|
break;
|
case 9:
|
for (let i2 = 0; i2 < node.branches.length; i2++) {
|
traverseNode(node.branches[i2], context);
|
}
|
break;
|
case 10:
|
case 11:
|
case 1:
|
case 0:
|
traverseChildren(node, context);
|
break;
|
}
|
context.currentNode = node;
|
let i = exitFns.length;
|
while (i--) {
|
exitFns[i]();
|
}
|
}
|
function createStructuralDirectiveTransform(name, fn) {
|
const matches = isString$2(name) ? (n) => n === name : (n) => name.test(n);
|
return (node, context) => {
|
if (node.type === 1) {
|
const { props } = node;
|
if (node.tagType === 3 && props.some(isVSlot)) {
|
return;
|
}
|
const exitFns = [];
|
for (let i = 0; i < props.length; i++) {
|
const prop = props[i];
|
if (prop.type === 7 && matches(prop.name)) {
|
props.splice(i, 1);
|
i--;
|
const onExit = fn(node, prop, context);
|
if (onExit)
|
exitFns.push(onExit);
|
}
|
}
|
return exitFns;
|
}
|
};
|
}
|
|
var sourceMap$2 = {};
|
|
var sourceMapGenerator$1 = {};
|
|
var base64Vlq$1 = {};
|
|
var base64$3 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var intToCharMap$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
|
|
/**
|
* Encode an integer in the range of 0 to 63 to a single base 64 digit.
|
*/
|
base64$3.encode = function (number) {
|
if (0 <= number && number < intToCharMap$1.length) {
|
return intToCharMap$1[number];
|
}
|
throw new TypeError("Must be between 0 and 63: " + number);
|
};
|
|
/**
|
* Decode a single base 64 character code digit to an integer. Returns -1 on
|
* failure.
|
*/
|
base64$3.decode = function (charCode) {
|
var bigA = 65; // 'A'
|
var bigZ = 90; // 'Z'
|
|
var littleA = 97; // 'a'
|
var littleZ = 122; // 'z'
|
|
var zero = 48; // '0'
|
var nine = 57; // '9'
|
|
var plus = 43; // '+'
|
var slash = 47; // '/'
|
|
var littleOffset = 26;
|
var numberOffset = 52;
|
|
// 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
|
if (bigA <= charCode && charCode <= bigZ) {
|
return (charCode - bigA);
|
}
|
|
// 26 - 51: abcdefghijklmnopqrstuvwxyz
|
if (littleA <= charCode && charCode <= littleZ) {
|
return (charCode - littleA + littleOffset);
|
}
|
|
// 52 - 61: 0123456789
|
if (zero <= charCode && charCode <= nine) {
|
return (charCode - zero + numberOffset);
|
}
|
|
// 62: +
|
if (charCode == plus) {
|
return 62;
|
}
|
|
// 63: /
|
if (charCode == slash) {
|
return 63;
|
}
|
|
// Invalid base64 digit.
|
return -1;
|
};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*
|
* Based on the Base 64 VLQ implementation in Closure Compiler:
|
* https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
|
*
|
* Copyright 2011 The Closure Compiler Authors. All rights reserved.
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are
|
* met:
|
*
|
* * Redistributions of source code must retain the above copyright
|
* notice, this list of conditions and the following disclaimer.
|
* * Redistributions in binary form must reproduce the above
|
* copyright notice, this list of conditions and the following
|
* disclaimer in the documentation and/or other materials provided
|
* with the distribution.
|
* * Neither the name of Google Inc. nor the names of its
|
* contributors may be used to endorse or promote products derived
|
* from this software without specific prior written permission.
|
*
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*/
|
|
var base64$2 = base64$3;
|
|
// A single base 64 digit can contain 6 bits of data. For the base 64 variable
|
// length quantities we use in the source map spec, the first bit is the sign,
|
// the next four bits are the actual value, and the 6th bit is the
|
// continuation bit. The continuation bit tells us whether there are more
|
// digits in this value following this digit.
|
//
|
// Continuation
|
// | Sign
|
// | |
|
// V V
|
// 101011
|
|
var VLQ_BASE_SHIFT$1 = 5;
|
|
// binary: 100000
|
var VLQ_BASE$1 = 1 << VLQ_BASE_SHIFT$1;
|
|
// binary: 011111
|
var VLQ_BASE_MASK$1 = VLQ_BASE$1 - 1;
|
|
// binary: 100000
|
var VLQ_CONTINUATION_BIT$1 = VLQ_BASE$1;
|
|
/**
|
* Converts from a two-complement value to a value where the sign bit is
|
* placed in the least significant bit. For example, as decimals:
|
* 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
|
* 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
|
*/
|
function toVLQSigned$1(aValue) {
|
return aValue < 0
|
? ((-aValue) << 1) + 1
|
: (aValue << 1) + 0;
|
}
|
|
/**
|
* Converts to a two-complement value from a value where the sign bit is
|
* placed in the least significant bit. For example, as decimals:
|
* 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
|
* 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
|
*/
|
function fromVLQSigned$1(aValue) {
|
var isNegative = (aValue & 1) === 1;
|
var shifted = aValue >> 1;
|
return isNegative
|
? -shifted
|
: shifted;
|
}
|
|
/**
|
* Returns the base 64 VLQ encoded value.
|
*/
|
base64Vlq$1.encode = function base64VLQ_encode(aValue) {
|
var encoded = "";
|
var digit;
|
|
var vlq = toVLQSigned$1(aValue);
|
|
do {
|
digit = vlq & VLQ_BASE_MASK$1;
|
vlq >>>= VLQ_BASE_SHIFT$1;
|
if (vlq > 0) {
|
// There are still more digits in this value, so we must make sure the
|
// continuation bit is marked.
|
digit |= VLQ_CONTINUATION_BIT$1;
|
}
|
encoded += base64$2.encode(digit);
|
} while (vlq > 0);
|
|
return encoded;
|
};
|
|
/**
|
* Decodes the next base 64 VLQ value from the given string and returns the
|
* value and the rest of the string via the out parameter.
|
*/
|
base64Vlq$1.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
|
var strLen = aStr.length;
|
var result = 0;
|
var shift = 0;
|
var continuation, digit;
|
|
do {
|
if (aIndex >= strLen) {
|
throw new Error("Expected more digits in base 64 VLQ value.");
|
}
|
|
digit = base64$2.decode(aStr.charCodeAt(aIndex++));
|
if (digit === -1) {
|
throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
|
}
|
|
continuation = !!(digit & VLQ_CONTINUATION_BIT$1);
|
digit &= VLQ_BASE_MASK$1;
|
result = result + (digit << shift);
|
shift += VLQ_BASE_SHIFT$1;
|
} while (continuation);
|
|
aOutParam.value = fromVLQSigned$1(result);
|
aOutParam.rest = aIndex;
|
};
|
|
var util$c = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
(function (exports) {
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
/**
|
* This is a helper function for getting values from parameter/options
|
* objects.
|
*
|
* @param args The object we are extracting values from
|
* @param name The name of the property we are getting.
|
* @param defaultValue An optional value to return if the property is missing
|
* from the object. If this is not specified and the property is missing, an
|
* error will be thrown.
|
*/
|
function getArg(aArgs, aName, aDefaultValue) {
|
if (aName in aArgs) {
|
return aArgs[aName];
|
} else if (arguments.length === 3) {
|
return aDefaultValue;
|
} else {
|
throw new Error('"' + aName + '" is a required argument.');
|
}
|
}
|
exports.getArg = getArg;
|
|
var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
|
var dataUrlRegexp = /^data:.+\,.+$/;
|
|
function urlParse(aUrl) {
|
var match = aUrl.match(urlRegexp);
|
if (!match) {
|
return null;
|
}
|
return {
|
scheme: match[1],
|
auth: match[2],
|
host: match[3],
|
port: match[4],
|
path: match[5]
|
};
|
}
|
exports.urlParse = urlParse;
|
|
function urlGenerate(aParsedUrl) {
|
var url = '';
|
if (aParsedUrl.scheme) {
|
url += aParsedUrl.scheme + ':';
|
}
|
url += '//';
|
if (aParsedUrl.auth) {
|
url += aParsedUrl.auth + '@';
|
}
|
if (aParsedUrl.host) {
|
url += aParsedUrl.host;
|
}
|
if (aParsedUrl.port) {
|
url += ":" + aParsedUrl.port;
|
}
|
if (aParsedUrl.path) {
|
url += aParsedUrl.path;
|
}
|
return url;
|
}
|
exports.urlGenerate = urlGenerate;
|
|
var MAX_CACHED_INPUTS = 32;
|
|
/**
|
* Takes some function `f(input) -> result` and returns a memoized version of
|
* `f`.
|
*
|
* We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
|
* memoization is a dumb-simple, linear least-recently-used cache.
|
*/
|
function lruMemoize(f) {
|
var cache = [];
|
|
return function(input) {
|
for (var i = 0; i < cache.length; i++) {
|
if (cache[i].input === input) {
|
var temp = cache[0];
|
cache[0] = cache[i];
|
cache[i] = temp;
|
return cache[0].result;
|
}
|
}
|
|
var result = f(input);
|
|
cache.unshift({
|
input,
|
result,
|
});
|
|
if (cache.length > MAX_CACHED_INPUTS) {
|
cache.pop();
|
}
|
|
return result;
|
};
|
}
|
|
/**
|
* Normalizes a path, or the path portion of a URL:
|
*
|
* - Replaces consecutive slashes with one slash.
|
* - Removes unnecessary '.' parts.
|
* - Removes unnecessary '<dir>/..' parts.
|
*
|
* Based on code in the Node.js 'path' core module.
|
*
|
* @param aPath The path or url to normalize.
|
*/
|
var normalize = lruMemoize(function normalize(aPath) {
|
var path = aPath;
|
var url = urlParse(aPath);
|
if (url) {
|
if (!url.path) {
|
return aPath;
|
}
|
path = url.path;
|
}
|
var isAbsolute = exports.isAbsolute(path);
|
// Split the path into parts between `/` characters. This is much faster than
|
// using `.split(/\/+/g)`.
|
var parts = [];
|
var start = 0;
|
var i = 0;
|
while (true) {
|
start = i;
|
i = path.indexOf("/", start);
|
if (i === -1) {
|
parts.push(path.slice(start));
|
break;
|
} else {
|
parts.push(path.slice(start, i));
|
while (i < path.length && path[i] === "/") {
|
i++;
|
}
|
}
|
}
|
|
for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
|
part = parts[i];
|
if (part === '.') {
|
parts.splice(i, 1);
|
} else if (part === '..') {
|
up++;
|
} else if (up > 0) {
|
if (part === '') {
|
// The first part is blank if the path is absolute. Trying to go
|
// above the root is a no-op. Therefore we can remove all '..' parts
|
// directly after the root.
|
parts.splice(i + 1, up);
|
up = 0;
|
} else {
|
parts.splice(i, 2);
|
up--;
|
}
|
}
|
}
|
path = parts.join('/');
|
|
if (path === '') {
|
path = isAbsolute ? '/' : '.';
|
}
|
|
if (url) {
|
url.path = path;
|
return urlGenerate(url);
|
}
|
return path;
|
});
|
exports.normalize = normalize;
|
|
/**
|
* Joins two paths/URLs.
|
*
|
* @param aRoot The root path or URL.
|
* @param aPath The path or URL to be joined with the root.
|
*
|
* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
|
* scheme-relative URL: Then the scheme of aRoot, if any, is prepended
|
* first.
|
* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
|
* is updated with the result and aRoot is returned. Otherwise the result
|
* is returned.
|
* - If aPath is absolute, the result is aPath.
|
* - Otherwise the two paths are joined with a slash.
|
* - Joining for example 'http://' and 'www.example.com' is also supported.
|
*/
|
function join(aRoot, aPath) {
|
if (aRoot === "") {
|
aRoot = ".";
|
}
|
if (aPath === "") {
|
aPath = ".";
|
}
|
var aPathUrl = urlParse(aPath);
|
var aRootUrl = urlParse(aRoot);
|
if (aRootUrl) {
|
aRoot = aRootUrl.path || '/';
|
}
|
|
// `join(foo, '//www.example.org')`
|
if (aPathUrl && !aPathUrl.scheme) {
|
if (aRootUrl) {
|
aPathUrl.scheme = aRootUrl.scheme;
|
}
|
return urlGenerate(aPathUrl);
|
}
|
|
if (aPathUrl || aPath.match(dataUrlRegexp)) {
|
return aPath;
|
}
|
|
// `join('http://', 'www.example.com')`
|
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
|
aRootUrl.host = aPath;
|
return urlGenerate(aRootUrl);
|
}
|
|
var joined = aPath.charAt(0) === '/'
|
? aPath
|
: normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
|
|
if (aRootUrl) {
|
aRootUrl.path = joined;
|
return urlGenerate(aRootUrl);
|
}
|
return joined;
|
}
|
exports.join = join;
|
|
exports.isAbsolute = function (aPath) {
|
return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
|
};
|
|
/**
|
* Make a path relative to a URL or another path.
|
*
|
* @param aRoot The root path or URL.
|
* @param aPath The path or URL to be made relative to aRoot.
|
*/
|
function relative(aRoot, aPath) {
|
if (aRoot === "") {
|
aRoot = ".";
|
}
|
|
aRoot = aRoot.replace(/\/$/, '');
|
|
// It is possible for the path to be above the root. In this case, simply
|
// checking whether the root is a prefix of the path won't work. Instead, we
|
// need to remove components from the root one by one, until either we find
|
// a prefix that fits, or we run out of components to remove.
|
var level = 0;
|
while (aPath.indexOf(aRoot + '/') !== 0) {
|
var index = aRoot.lastIndexOf("/");
|
if (index < 0) {
|
return aPath;
|
}
|
|
// If the only part of the root that is left is the scheme (i.e. http://,
|
// file:///, etc.), one or more slashes (/), or simply nothing at all, we
|
// have exhausted all components, so the path is not relative to the root.
|
aRoot = aRoot.slice(0, index);
|
if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
|
return aPath;
|
}
|
|
++level;
|
}
|
|
// Make sure we add a "../" for each component we removed from the root.
|
return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
|
}
|
exports.relative = relative;
|
|
var supportsNullProto = (function () {
|
var obj = Object.create(null);
|
return !('__proto__' in obj);
|
}());
|
|
function identity (s) {
|
return s;
|
}
|
|
/**
|
* Because behavior goes wacky when you set `__proto__` on objects, we
|
* have to prefix all the strings in our set with an arbitrary character.
|
*
|
* See https://github.com/mozilla/source-map/pull/31 and
|
* https://github.com/mozilla/source-map/issues/30
|
*
|
* @param String aStr
|
*/
|
function toSetString(aStr) {
|
if (isProtoString(aStr)) {
|
return '$' + aStr;
|
}
|
|
return aStr;
|
}
|
exports.toSetString = supportsNullProto ? identity : toSetString;
|
|
function fromSetString(aStr) {
|
if (isProtoString(aStr)) {
|
return aStr.slice(1);
|
}
|
|
return aStr;
|
}
|
exports.fromSetString = supportsNullProto ? identity : fromSetString;
|
|
function isProtoString(s) {
|
if (!s) {
|
return false;
|
}
|
|
var length = s.length;
|
|
if (length < 9 /* "__proto__".length */) {
|
return false;
|
}
|
|
if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||
|
s.charCodeAt(length - 2) !== 95 /* '_' */ ||
|
s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
|
s.charCodeAt(length - 4) !== 116 /* 't' */ ||
|
s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
|
s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
|
s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
|
s.charCodeAt(length - 8) !== 95 /* '_' */ ||
|
s.charCodeAt(length - 9) !== 95 /* '_' */) {
|
return false;
|
}
|
|
for (var i = length - 10; i >= 0; i--) {
|
if (s.charCodeAt(i) !== 36 /* '$' */) {
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
/**
|
* Comparator between two mappings where the original positions are compared.
|
*
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
* mappings with the same original source/line/column, but different generated
|
* line and column the same. Useful when searching for a mapping with a
|
* stubbed out mapping.
|
*/
|
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
|
var cmp = strcmp(mappingA.source, mappingB.source);
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0 || onlyCompareOriginal) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByOriginalPositions = compareByOriginalPositions;
|
|
function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
|
var cmp;
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0 || onlyCompareOriginal) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
|
|
/**
|
* Comparator between two mappings with deflated source and name indices where
|
* the generated positions are compared.
|
*
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
* mappings with the same generated line and column, but different
|
* source/name/original line and column the same. Useful when searching for a
|
* mapping with a stubbed out mapping.
|
*/
|
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
|
var cmp = mappingA.generatedLine - mappingB.generatedLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0 || onlyCompareGenerated) {
|
return cmp;
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
|
|
function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
|
var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0 || onlyCompareGenerated) {
|
return cmp;
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
|
|
function strcmp(aStr1, aStr2) {
|
if (aStr1 === aStr2) {
|
return 0;
|
}
|
|
if (aStr1 === null) {
|
return 1; // aStr2 !== null
|
}
|
|
if (aStr2 === null) {
|
return -1; // aStr1 !== null
|
}
|
|
if (aStr1 > aStr2) {
|
return 1;
|
}
|
|
return -1;
|
}
|
|
/**
|
* Comparator between two mappings with inflated source and name strings where
|
* the generated positions are compared.
|
*/
|
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
|
var cmp = mappingA.generatedLine - mappingB.generatedLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
|
|
/**
|
* Strip any JSON XSSI avoidance prefix from the string (as documented
|
* in the source maps specification), and then parse the string as
|
* JSON.
|
*/
|
function parseSourceMapInput(str) {
|
return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
|
}
|
exports.parseSourceMapInput = parseSourceMapInput;
|
|
/**
|
* Compute the URL of a source given the the source root, the source's
|
* URL, and the source map's URL.
|
*/
|
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
|
sourceURL = sourceURL || '';
|
|
if (sourceRoot) {
|
// This follows what Chrome does.
|
if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
|
sourceRoot += '/';
|
}
|
// The spec says:
|
// Line 4: An optional source root, useful for relocating source
|
// files on a server or removing repeated values in the
|
// “sources” entry. This value is prepended to the individual
|
// entries in the “source” field.
|
sourceURL = sourceRoot + sourceURL;
|
}
|
|
// Historically, SourceMapConsumer did not take the sourceMapURL as
|
// a parameter. This mode is still somewhat supported, which is why
|
// this code block is conditional. However, it's preferable to pass
|
// the source map URL to SourceMapConsumer, so that this function
|
// can implement the source URL resolution algorithm as outlined in
|
// the spec. This block is basically the equivalent of:
|
// new URL(sourceURL, sourceMapURL).toString()
|
// ... except it avoids using URL, which wasn't available in the
|
// older releases of node still supported by this library.
|
//
|
// The spec says:
|
// If the sources are not absolute URLs after prepending of the
|
// “sourceRoot”, the sources are resolved relative to the
|
// SourceMap (like resolving script src in a html document).
|
if (sourceMapURL) {
|
var parsed = urlParse(sourceMapURL);
|
if (!parsed) {
|
throw new Error("sourceMapURL could not be parsed");
|
}
|
if (parsed.path) {
|
// Strip the last path component, but keep the "/".
|
var index = parsed.path.lastIndexOf('/');
|
if (index >= 0) {
|
parsed.path = parsed.path.substring(0, index + 1);
|
}
|
}
|
sourceURL = join(urlGenerate(parsed), sourceURL);
|
}
|
|
return normalize(sourceURL);
|
}
|
exports.computeSourceURL = computeSourceURL;
|
} (util$c));
|
|
var arraySet$1 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var util$b = util$c;
|
var has$1 = Object.prototype.hasOwnProperty;
|
var hasNativeMap$1 = typeof Map !== "undefined";
|
|
/**
|
* A data structure which is a combination of an array and a set. Adding a new
|
* member is O(1), testing for membership is O(1), and finding the index of an
|
* element is O(1). Removing elements from the set is not supported. Only
|
* strings are supported for membership.
|
*/
|
function ArraySet$5() {
|
this._array = [];
|
this._set = hasNativeMap$1 ? new Map() : Object.create(null);
|
}
|
|
/**
|
* Static method for creating ArraySet instances from an existing array.
|
*/
|
ArraySet$5.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
|
var set = new ArraySet$5();
|
for (var i = 0, len = aArray.length; i < len; i++) {
|
set.add(aArray[i], aAllowDuplicates);
|
}
|
return set;
|
};
|
|
/**
|
* Return how many unique items are in this ArraySet. If duplicates have been
|
* added, than those do not count towards the size.
|
*
|
* @returns Number
|
*/
|
ArraySet$5.prototype.size = function ArraySet_size() {
|
return hasNativeMap$1 ? this._set.size : Object.getOwnPropertyNames(this._set).length;
|
};
|
|
/**
|
* Add the given string to this set.
|
*
|
* @param String aStr
|
*/
|
ArraySet$5.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
|
var sStr = hasNativeMap$1 ? aStr : util$b.toSetString(aStr);
|
var isDuplicate = hasNativeMap$1 ? this.has(aStr) : has$1.call(this._set, sStr);
|
var idx = this._array.length;
|
if (!isDuplicate || aAllowDuplicates) {
|
this._array.push(aStr);
|
}
|
if (!isDuplicate) {
|
if (hasNativeMap$1) {
|
this._set.set(aStr, idx);
|
} else {
|
this._set[sStr] = idx;
|
}
|
}
|
};
|
|
/**
|
* Is the given string a member of this set?
|
*
|
* @param String aStr
|
*/
|
ArraySet$5.prototype.has = function ArraySet_has(aStr) {
|
if (hasNativeMap$1) {
|
return this._set.has(aStr);
|
} else {
|
var sStr = util$b.toSetString(aStr);
|
return has$1.call(this._set, sStr);
|
}
|
};
|
|
/**
|
* What is the index of the given string in the array?
|
*
|
* @param String aStr
|
*/
|
ArraySet$5.prototype.indexOf = function ArraySet_indexOf(aStr) {
|
if (hasNativeMap$1) {
|
var idx = this._set.get(aStr);
|
if (idx >= 0) {
|
return idx;
|
}
|
} else {
|
var sStr = util$b.toSetString(aStr);
|
if (has$1.call(this._set, sStr)) {
|
return this._set[sStr];
|
}
|
}
|
|
throw new Error('"' + aStr + '" is not in the set.');
|
};
|
|
/**
|
* What is the element at the given index?
|
*
|
* @param Number aIdx
|
*/
|
ArraySet$5.prototype.at = function ArraySet_at(aIdx) {
|
if (aIdx >= 0 && aIdx < this._array.length) {
|
return this._array[aIdx];
|
}
|
throw new Error('No element indexed by ' + aIdx);
|
};
|
|
/**
|
* Returns the array representation of this set (which has the proper indices
|
* indicated by indexOf). Note that this is a copy of the internal array used
|
* for storing the members so that no one can mess with internal state.
|
*/
|
ArraySet$5.prototype.toArray = function ArraySet_toArray() {
|
return this._array.slice();
|
};
|
|
arraySet$1.ArraySet = ArraySet$5;
|
|
var mappingList$1 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2014 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var util$a = util$c;
|
|
/**
|
* Determine whether mappingB is after mappingA with respect to generated
|
* position.
|
*/
|
function generatedPositionAfter$1(mappingA, mappingB) {
|
// Optimized for most common case
|
var lineA = mappingA.generatedLine;
|
var lineB = mappingB.generatedLine;
|
var columnA = mappingA.generatedColumn;
|
var columnB = mappingB.generatedColumn;
|
return lineB > lineA || lineB == lineA && columnB >= columnA ||
|
util$a.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
|
}
|
|
/**
|
* A data structure to provide a sorted view of accumulated mappings in a
|
* performance conscious manner. It trades a neglibable overhead in general
|
* case for a large speedup in case of mappings being added in order.
|
*/
|
function MappingList$3() {
|
this._array = [];
|
this._sorted = true;
|
// Serves as infimum
|
this._last = {generatedLine: -1, generatedColumn: 0};
|
}
|
|
/**
|
* Iterate through internal items. This method takes the same arguments that
|
* `Array.prototype.forEach` takes.
|
*
|
* NOTE: The order of the mappings is NOT guaranteed.
|
*/
|
MappingList$3.prototype.unsortedForEach =
|
function MappingList_forEach(aCallback, aThisArg) {
|
this._array.forEach(aCallback, aThisArg);
|
};
|
|
/**
|
* Add the given source mapping.
|
*
|
* @param Object aMapping
|
*/
|
MappingList$3.prototype.add = function MappingList_add(aMapping) {
|
if (generatedPositionAfter$1(this._last, aMapping)) {
|
this._last = aMapping;
|
this._array.push(aMapping);
|
} else {
|
this._sorted = false;
|
this._array.push(aMapping);
|
}
|
};
|
|
/**
|
* Returns the flat, sorted array of mappings. The mappings are sorted by
|
* generated position.
|
*
|
* WARNING: This method returns internal data without copying, for
|
* performance. The return value must NOT be mutated, and should be treated as
|
* an immutable borrow. If you want to take ownership, you must make your own
|
* copy.
|
*/
|
MappingList$3.prototype.toArray = function MappingList_toArray() {
|
if (!this._sorted) {
|
this._array.sort(util$a.compareByGeneratedPositionsInflated);
|
this._sorted = true;
|
}
|
return this._array;
|
};
|
|
mappingList$1.MappingList = MappingList$3;
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var base64VLQ$3 = base64Vlq$1;
|
var util$9 = util$c;
|
var ArraySet$4 = arraySet$1.ArraySet;
|
var MappingList$2 = mappingList$1.MappingList;
|
|
/**
|
* An instance of the SourceMapGenerator represents a source map which is
|
* being built incrementally. You may pass an object with the following
|
* properties:
|
*
|
* - file: The filename of the generated source.
|
* - sourceRoot: A root for all relative URLs in this source map.
|
*/
|
function SourceMapGenerator$8(aArgs) {
|
if (!aArgs) {
|
aArgs = {};
|
}
|
this._file = util$9.getArg(aArgs, 'file', null);
|
this._sourceRoot = util$9.getArg(aArgs, 'sourceRoot', null);
|
this._skipValidation = util$9.getArg(aArgs, 'skipValidation', false);
|
this._sources = new ArraySet$4();
|
this._names = new ArraySet$4();
|
this._mappings = new MappingList$2();
|
this._sourcesContents = null;
|
}
|
|
SourceMapGenerator$8.prototype._version = 3;
|
|
/**
|
* Creates a new SourceMapGenerator based on a SourceMapConsumer
|
*
|
* @param aSourceMapConsumer The SourceMap.
|
*/
|
SourceMapGenerator$8.fromSourceMap =
|
function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
|
var sourceRoot = aSourceMapConsumer.sourceRoot;
|
var generator = new SourceMapGenerator$8({
|
file: aSourceMapConsumer.file,
|
sourceRoot: sourceRoot
|
});
|
aSourceMapConsumer.eachMapping(function (mapping) {
|
var newMapping = {
|
generated: {
|
line: mapping.generatedLine,
|
column: mapping.generatedColumn
|
}
|
};
|
|
if (mapping.source != null) {
|
newMapping.source = mapping.source;
|
if (sourceRoot != null) {
|
newMapping.source = util$9.relative(sourceRoot, newMapping.source);
|
}
|
|
newMapping.original = {
|
line: mapping.originalLine,
|
column: mapping.originalColumn
|
};
|
|
if (mapping.name != null) {
|
newMapping.name = mapping.name;
|
}
|
}
|
|
generator.addMapping(newMapping);
|
});
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
var sourceRelative = sourceFile;
|
if (sourceRoot !== null) {
|
sourceRelative = util$9.relative(sourceRoot, sourceFile);
|
}
|
|
if (!generator._sources.has(sourceRelative)) {
|
generator._sources.add(sourceRelative);
|
}
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
if (content != null) {
|
generator.setSourceContent(sourceFile, content);
|
}
|
});
|
return generator;
|
};
|
|
/**
|
* Add a single mapping from original source line and column to the generated
|
* source's line and column for this source map being created. The mapping
|
* object should have the following properties:
|
*
|
* - generated: An object with the generated line and column positions.
|
* - original: An object with the original line and column positions.
|
* - source: The original source file (relative to the sourceRoot).
|
* - name: An optional original token name for this mapping.
|
*/
|
SourceMapGenerator$8.prototype.addMapping =
|
function SourceMapGenerator_addMapping(aArgs) {
|
var generated = util$9.getArg(aArgs, 'generated');
|
var original = util$9.getArg(aArgs, 'original', null);
|
var source = util$9.getArg(aArgs, 'source', null);
|
var name = util$9.getArg(aArgs, 'name', null);
|
|
if (!this._skipValidation) {
|
this._validateMapping(generated, original, source, name);
|
}
|
|
if (source != null) {
|
source = String(source);
|
if (!this._sources.has(source)) {
|
this._sources.add(source);
|
}
|
}
|
|
if (name != null) {
|
name = String(name);
|
if (!this._names.has(name)) {
|
this._names.add(name);
|
}
|
}
|
|
this._mappings.add({
|
generatedLine: generated.line,
|
generatedColumn: generated.column,
|
originalLine: original != null && original.line,
|
originalColumn: original != null && original.column,
|
source: source,
|
name: name
|
});
|
};
|
|
/**
|
* Set the source content for a source file.
|
*/
|
SourceMapGenerator$8.prototype.setSourceContent =
|
function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
|
var source = aSourceFile;
|
if (this._sourceRoot != null) {
|
source = util$9.relative(this._sourceRoot, source);
|
}
|
|
if (aSourceContent != null) {
|
// Add the source content to the _sourcesContents map.
|
// Create a new _sourcesContents map if the property is null.
|
if (!this._sourcesContents) {
|
this._sourcesContents = Object.create(null);
|
}
|
this._sourcesContents[util$9.toSetString(source)] = aSourceContent;
|
} else if (this._sourcesContents) {
|
// Remove the source file from the _sourcesContents map.
|
// If the _sourcesContents map is empty, set the property to null.
|
delete this._sourcesContents[util$9.toSetString(source)];
|
if (Object.keys(this._sourcesContents).length === 0) {
|
this._sourcesContents = null;
|
}
|
}
|
};
|
|
/**
|
* Applies the mappings of a sub-source-map for a specific source file to the
|
* source map being generated. Each mapping to the supplied source file is
|
* rewritten using the supplied source map. Note: The resolution for the
|
* resulting mappings is the minimium of this map and the supplied map.
|
*
|
* @param aSourceMapConsumer The source map to be applied.
|
* @param aSourceFile Optional. The filename of the source file.
|
* If omitted, SourceMapConsumer's file property will be used.
|
* @param aSourceMapPath Optional. The dirname of the path to the source map
|
* to be applied. If relative, it is relative to the SourceMapConsumer.
|
* This parameter is needed when the two source maps aren't in the same
|
* directory, and the source map to be applied contains relative source
|
* paths. If so, those relative source paths need to be rewritten
|
* relative to the SourceMapGenerator.
|
*/
|
SourceMapGenerator$8.prototype.applySourceMap =
|
function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
|
var sourceFile = aSourceFile;
|
// If aSourceFile is omitted, we will use the file property of the SourceMap
|
if (aSourceFile == null) {
|
if (aSourceMapConsumer.file == null) {
|
throw new Error(
|
'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
|
'or the source map\'s "file" property. Both were omitted.'
|
);
|
}
|
sourceFile = aSourceMapConsumer.file;
|
}
|
var sourceRoot = this._sourceRoot;
|
// Make "sourceFile" relative if an absolute Url is passed.
|
if (sourceRoot != null) {
|
sourceFile = util$9.relative(sourceRoot, sourceFile);
|
}
|
// Applying the SourceMap can add and remove items from the sources and
|
// the names array.
|
var newSources = new ArraySet$4();
|
var newNames = new ArraySet$4();
|
|
// Find mappings for the "sourceFile"
|
this._mappings.unsortedForEach(function (mapping) {
|
if (mapping.source === sourceFile && mapping.originalLine != null) {
|
// Check if it can be mapped by the source map, then update the mapping.
|
var original = aSourceMapConsumer.originalPositionFor({
|
line: mapping.originalLine,
|
column: mapping.originalColumn
|
});
|
if (original.source != null) {
|
// Copy mapping
|
mapping.source = original.source;
|
if (aSourceMapPath != null) {
|
mapping.source = util$9.join(aSourceMapPath, mapping.source);
|
}
|
if (sourceRoot != null) {
|
mapping.source = util$9.relative(sourceRoot, mapping.source);
|
}
|
mapping.originalLine = original.line;
|
mapping.originalColumn = original.column;
|
if (original.name != null) {
|
mapping.name = original.name;
|
}
|
}
|
}
|
|
var source = mapping.source;
|
if (source != null && !newSources.has(source)) {
|
newSources.add(source);
|
}
|
|
var name = mapping.name;
|
if (name != null && !newNames.has(name)) {
|
newNames.add(name);
|
}
|
|
}, this);
|
this._sources = newSources;
|
this._names = newNames;
|
|
// Copy sourcesContents of applied map.
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
if (content != null) {
|
if (aSourceMapPath != null) {
|
sourceFile = util$9.join(aSourceMapPath, sourceFile);
|
}
|
if (sourceRoot != null) {
|
sourceFile = util$9.relative(sourceRoot, sourceFile);
|
}
|
this.setSourceContent(sourceFile, content);
|
}
|
}, this);
|
};
|
|
/**
|
* A mapping can have one of the three levels of data:
|
*
|
* 1. Just the generated position.
|
* 2. The Generated position, original position, and original source.
|
* 3. Generated and original position, original source, as well as a name
|
* token.
|
*
|
* To maintain consistency, we validate that any new mapping being added falls
|
* in to one of these categories.
|
*/
|
SourceMapGenerator$8.prototype._validateMapping =
|
function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
|
aName) {
|
// When aOriginal is truthy but has empty values for .line and .column,
|
// it is most likely a programmer error. In this case we throw a very
|
// specific error message to try to guide them the right way.
|
// For example: https://github.com/Polymer/polymer-bundler/pull/519
|
if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
|
throw new Error(
|
'original.line and original.column are not numbers -- you probably meant to omit ' +
|
'the original mapping entirely and only map the generated position. If so, pass ' +
|
'null for the original mapping instead of an object with empty or null values.'
|
);
|
}
|
|
if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
|
&& aGenerated.line > 0 && aGenerated.column >= 0
|
&& !aOriginal && !aSource && !aName) {
|
// Case 1.
|
return;
|
}
|
else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
|
&& aOriginal && 'line' in aOriginal && 'column' in aOriginal
|
&& aGenerated.line > 0 && aGenerated.column >= 0
|
&& aOriginal.line > 0 && aOriginal.column >= 0
|
&& aSource) {
|
// Cases 2 and 3.
|
return;
|
}
|
else {
|
throw new Error('Invalid mapping: ' + JSON.stringify({
|
generated: aGenerated,
|
source: aSource,
|
original: aOriginal,
|
name: aName
|
}));
|
}
|
};
|
|
/**
|
* Serialize the accumulated mappings in to the stream of base 64 VLQs
|
* specified by the source map format.
|
*/
|
SourceMapGenerator$8.prototype._serializeMappings =
|
function SourceMapGenerator_serializeMappings() {
|
var previousGeneratedColumn = 0;
|
var previousGeneratedLine = 1;
|
var previousOriginalColumn = 0;
|
var previousOriginalLine = 0;
|
var previousName = 0;
|
var previousSource = 0;
|
var result = '';
|
var next;
|
var mapping;
|
var nameIdx;
|
var sourceIdx;
|
|
var mappings = this._mappings.toArray();
|
for (var i = 0, len = mappings.length; i < len; i++) {
|
mapping = mappings[i];
|
next = '';
|
|
if (mapping.generatedLine !== previousGeneratedLine) {
|
previousGeneratedColumn = 0;
|
while (mapping.generatedLine !== previousGeneratedLine) {
|
next += ';';
|
previousGeneratedLine++;
|
}
|
}
|
else {
|
if (i > 0) {
|
if (!util$9.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
|
continue;
|
}
|
next += ',';
|
}
|
}
|
|
next += base64VLQ$3.encode(mapping.generatedColumn
|
- previousGeneratedColumn);
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
if (mapping.source != null) {
|
sourceIdx = this._sources.indexOf(mapping.source);
|
next += base64VLQ$3.encode(sourceIdx - previousSource);
|
previousSource = sourceIdx;
|
|
// lines are stored 0-based in SourceMap spec version 3
|
next += base64VLQ$3.encode(mapping.originalLine - 1
|
- previousOriginalLine);
|
previousOriginalLine = mapping.originalLine - 1;
|
|
next += base64VLQ$3.encode(mapping.originalColumn
|
- previousOriginalColumn);
|
previousOriginalColumn = mapping.originalColumn;
|
|
if (mapping.name != null) {
|
nameIdx = this._names.indexOf(mapping.name);
|
next += base64VLQ$3.encode(nameIdx - previousName);
|
previousName = nameIdx;
|
}
|
}
|
|
result += next;
|
}
|
|
return result;
|
};
|
|
SourceMapGenerator$8.prototype._generateSourcesContent =
|
function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
|
return aSources.map(function (source) {
|
if (!this._sourcesContents) {
|
return null;
|
}
|
if (aSourceRoot != null) {
|
source = util$9.relative(aSourceRoot, source);
|
}
|
var key = util$9.toSetString(source);
|
return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
|
? this._sourcesContents[key]
|
: null;
|
}, this);
|
};
|
|
/**
|
* Externalize the source map.
|
*/
|
SourceMapGenerator$8.prototype.toJSON =
|
function SourceMapGenerator_toJSON() {
|
var map = {
|
version: this._version,
|
sources: this._sources.toArray(),
|
names: this._names.toArray(),
|
mappings: this._serializeMappings()
|
};
|
if (this._file != null) {
|
map.file = this._file;
|
}
|
if (this._sourceRoot != null) {
|
map.sourceRoot = this._sourceRoot;
|
}
|
if (this._sourcesContents) {
|
map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
|
}
|
|
return map;
|
};
|
|
/**
|
* Render the source map being generated to a string.
|
*/
|
SourceMapGenerator$8.prototype.toString =
|
function SourceMapGenerator_toString() {
|
return JSON.stringify(this.toJSON());
|
};
|
|
sourceMapGenerator$1.SourceMapGenerator = SourceMapGenerator$8;
|
|
var sourceMapConsumer$1 = {};
|
|
var binarySearch$3 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
(function (exports) {
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
exports.GREATEST_LOWER_BOUND = 1;
|
exports.LEAST_UPPER_BOUND = 2;
|
|
/**
|
* Recursive implementation of binary search.
|
*
|
* @param aLow Indices here and lower do not contain the needle.
|
* @param aHigh Indices here and higher do not contain the needle.
|
* @param aNeedle The element being searched for.
|
* @param aHaystack The non-empty array being searched.
|
* @param aCompare Function which takes two elements and returns -1, 0, or 1.
|
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
|
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
*/
|
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
|
// This function terminates when one of the following is true:
|
//
|
// 1. We find the exact element we are looking for.
|
//
|
// 2. We did not find the exact element, but we can return the index of
|
// the next-closest element.
|
//
|
// 3. We did not find the exact element, and there is no next-closest
|
// element than the one we are searching for, so we return -1.
|
var mid = Math.floor((aHigh - aLow) / 2) + aLow;
|
var cmp = aCompare(aNeedle, aHaystack[mid], true);
|
if (cmp === 0) {
|
// Found the element we are looking for.
|
return mid;
|
}
|
else if (cmp > 0) {
|
// Our needle is greater than aHaystack[mid].
|
if (aHigh - mid > 1) {
|
// The element is in the upper half.
|
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
|
}
|
|
// The exact needle element was not found in this haystack. Determine if
|
// we are in termination case (3) or (2) and return the appropriate thing.
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
return aHigh < aHaystack.length ? aHigh : -1;
|
} else {
|
return mid;
|
}
|
}
|
else {
|
// Our needle is less than aHaystack[mid].
|
if (mid - aLow > 1) {
|
// The element is in the lower half.
|
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
|
}
|
|
// we are in termination case (3) or (2) and return the appropriate thing.
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
return mid;
|
} else {
|
return aLow < 0 ? -1 : aLow;
|
}
|
}
|
}
|
|
/**
|
* This is an implementation of binary search which will always try and return
|
* the index of the closest element if there is no exact hit. This is because
|
* mappings between original and generated line/col pairs are single points,
|
* and there is an implicit region between each of them, so a miss just means
|
* that you aren't on the very start of a region.
|
*
|
* @param aNeedle The element you are looking for.
|
* @param aHaystack The array that is being searched.
|
* @param aCompare A function which takes the needle and an element in the
|
* array and returns -1, 0, or 1 depending on whether the needle is less
|
* than, equal to, or greater than the element, respectively.
|
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
|
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
* Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
|
*/
|
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
|
if (aHaystack.length === 0) {
|
return -1;
|
}
|
|
var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
|
aCompare, aBias || exports.GREATEST_LOWER_BOUND);
|
if (index < 0) {
|
return -1;
|
}
|
|
// We have found either the exact element, or the next-closest element than
|
// the one we are searching for. However, there may be more than one such
|
// element. Make sure we always return the smallest of these.
|
while (index - 1 >= 0) {
|
if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
|
break;
|
}
|
--index;
|
}
|
|
return index;
|
};
|
} (binarySearch$3));
|
|
var quickSort$3 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
// It turns out that some (most?) JavaScript engines don't self-host
|
// `Array.prototype.sort`. This makes sense because C++ will likely remain
|
// faster than JS when doing raw CPU-intensive sorting. However, when using a
|
// custom comparator function, calling back and forth between the VM's C++ and
|
// JIT'd JS is rather slow *and* loses JIT type information, resulting in
|
// worse generated code for the comparator function than would be optimal. In
|
// fact, when sorting with a comparator, these costs outweigh the benefits of
|
// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
|
// a ~3500ms mean speed-up in `bench/bench.html`.
|
|
function SortTemplate(comparator) {
|
|
/**
|
* Swap the elements indexed by `x` and `y` in the array `ary`.
|
*
|
* @param {Array} ary
|
* The array.
|
* @param {Number} x
|
* The index of the first item.
|
* @param {Number} y
|
* The index of the second item.
|
*/
|
function swap(ary, x, y) {
|
var temp = ary[x];
|
ary[x] = ary[y];
|
ary[y] = temp;
|
}
|
|
/**
|
* Returns a random integer within the range `low .. high` inclusive.
|
*
|
* @param {Number} low
|
* The lower bound on the range.
|
* @param {Number} high
|
* The upper bound on the range.
|
*/
|
function randomIntInRange(low, high) {
|
return Math.round(low + (Math.random() * (high - low)));
|
}
|
|
/**
|
* The Quick Sort algorithm.
|
*
|
* @param {Array} ary
|
* An array to sort.
|
* @param {function} comparator
|
* Function to use to compare two items.
|
* @param {Number} p
|
* Start index of the array
|
* @param {Number} r
|
* End index of the array
|
*/
|
function doQuickSort(ary, comparator, p, r) {
|
// If our lower bound is less than our upper bound, we (1) partition the
|
// array into two pieces and (2) recurse on each half. If it is not, this is
|
// the empty array and our base case.
|
|
if (p < r) {
|
// (1) Partitioning.
|
//
|
// The partitioning chooses a pivot between `p` and `r` and moves all
|
// elements that are less than or equal to the pivot to the before it, and
|
// all the elements that are greater than it after it. The effect is that
|
// once partition is done, the pivot is in the exact place it will be when
|
// the array is put in sorted order, and it will not need to be moved
|
// again. This runs in O(n) time.
|
|
// Always choose a random pivot so that an input array which is reverse
|
// sorted does not cause O(n^2) running time.
|
var pivotIndex = randomIntInRange(p, r);
|
var i = p - 1;
|
|
swap(ary, pivotIndex, r);
|
var pivot = ary[r];
|
|
// Immediately after `j` is incremented in this loop, the following hold
|
// true:
|
//
|
// * Every element in `ary[p .. i]` is less than or equal to the pivot.
|
//
|
// * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
|
for (var j = p; j < r; j++) {
|
if (comparator(ary[j], pivot, false) <= 0) {
|
i += 1;
|
swap(ary, i, j);
|
}
|
}
|
|
swap(ary, i + 1, j);
|
var q = i + 1;
|
|
// (2) Recurse on each half.
|
|
doQuickSort(ary, comparator, p, q - 1);
|
doQuickSort(ary, comparator, q + 1, r);
|
}
|
}
|
|
return doQuickSort;
|
}
|
|
function cloneSort(comparator) {
|
let template = SortTemplate.toString();
|
let templateFn = new Function(`return ${template}`)();
|
return templateFn(comparator);
|
}
|
|
/**
|
* Sort the given array in-place with the given comparator function.
|
*
|
* @param {Array} ary
|
* An array to sort.
|
* @param {function} comparator
|
* Function to use to compare two items.
|
*/
|
|
let sortCache = new WeakMap();
|
quickSort$3.quickSort = function (ary, comparator, start = 0) {
|
let doQuickSort = sortCache.get(comparator);
|
if (doQuickSort === void 0) {
|
doQuickSort = cloneSort(comparator);
|
sortCache.set(comparator, doQuickSort);
|
}
|
doQuickSort(ary, comparator, start, ary.length - 1);
|
};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var util$8 = util$c;
|
var binarySearch$2 = binarySearch$3;
|
var ArraySet$3 = arraySet$1.ArraySet;
|
var base64VLQ$2 = base64Vlq$1;
|
var quickSort$2 = quickSort$3.quickSort;
|
|
function SourceMapConsumer$6(aSourceMap, aSourceMapURL) {
|
var sourceMap = aSourceMap;
|
if (typeof aSourceMap === 'string') {
|
sourceMap = util$8.parseSourceMapInput(aSourceMap);
|
}
|
|
return sourceMap.sections != null
|
? new IndexedSourceMapConsumer$1(sourceMap, aSourceMapURL)
|
: new BasicSourceMapConsumer$1(sourceMap, aSourceMapURL);
|
}
|
|
SourceMapConsumer$6.fromSourceMap = function(aSourceMap, aSourceMapURL) {
|
return BasicSourceMapConsumer$1.fromSourceMap(aSourceMap, aSourceMapURL);
|
};
|
|
/**
|
* The version of the source mapping spec that we are consuming.
|
*/
|
SourceMapConsumer$6.prototype._version = 3;
|
|
// `__generatedMappings` and `__originalMappings` are arrays that hold the
|
// parsed mapping coordinates from the source map's "mappings" attribute. They
|
// are lazily instantiated, accessed via the `_generatedMappings` and
|
// `_originalMappings` getters respectively, and we only parse the mappings
|
// and create these arrays once queried for a source location. We jump through
|
// these hoops because there can be many thousands of mappings, and parsing
|
// them is expensive, so we only want to do it if we must.
|
//
|
// Each object in the arrays is of the form:
|
//
|
// {
|
// generatedLine: The line number in the generated code,
|
// generatedColumn: The column number in the generated code,
|
// source: The path to the original source file that generated this
|
// chunk of code,
|
// originalLine: The line number in the original source that
|
// corresponds to this chunk of generated code,
|
// originalColumn: The column number in the original source that
|
// corresponds to this chunk of generated code,
|
// name: The name of the original symbol which generated this chunk of
|
// code.
|
// }
|
//
|
// All properties except for `generatedLine` and `generatedColumn` can be
|
// `null`.
|
//
|
// `_generatedMappings` is ordered by the generated positions.
|
//
|
// `_originalMappings` is ordered by the original positions.
|
|
SourceMapConsumer$6.prototype.__generatedMappings = null;
|
Object.defineProperty(SourceMapConsumer$6.prototype, '_generatedMappings', {
|
configurable: true,
|
enumerable: true,
|
get: function () {
|
if (!this.__generatedMappings) {
|
this._parseMappings(this._mappings, this.sourceRoot);
|
}
|
|
return this.__generatedMappings;
|
}
|
});
|
|
SourceMapConsumer$6.prototype.__originalMappings = null;
|
Object.defineProperty(SourceMapConsumer$6.prototype, '_originalMappings', {
|
configurable: true,
|
enumerable: true,
|
get: function () {
|
if (!this.__originalMappings) {
|
this._parseMappings(this._mappings, this.sourceRoot);
|
}
|
|
return this.__originalMappings;
|
}
|
});
|
|
SourceMapConsumer$6.prototype._charIsMappingSeparator =
|
function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
|
var c = aStr.charAt(index);
|
return c === ";" || c === ",";
|
};
|
|
/**
|
* Parse the mappings in a string in to a data structure which we can easily
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
* `this.__originalMappings` properties).
|
*/
|
SourceMapConsumer$6.prototype._parseMappings =
|
function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
throw new Error("Subclasses must implement _parseMappings");
|
};
|
|
SourceMapConsumer$6.GENERATED_ORDER = 1;
|
SourceMapConsumer$6.ORIGINAL_ORDER = 2;
|
|
SourceMapConsumer$6.GREATEST_LOWER_BOUND = 1;
|
SourceMapConsumer$6.LEAST_UPPER_BOUND = 2;
|
|
/**
|
* Iterate over each mapping between an original source/line/column and a
|
* generated line/column in this source map.
|
*
|
* @param Function aCallback
|
* The function that is called with each mapping.
|
* @param Object aContext
|
* Optional. If specified, this object will be the value of `this` every
|
* time that `aCallback` is called.
|
* @param aOrder
|
* Either `SourceMapConsumer.GENERATED_ORDER` or
|
* `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
|
* iterate over the mappings sorted by the generated file's line/column
|
* order or the original's source/line/column order, respectively. Defaults to
|
* `SourceMapConsumer.GENERATED_ORDER`.
|
*/
|
SourceMapConsumer$6.prototype.eachMapping =
|
function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
|
var context = aContext || null;
|
var order = aOrder || SourceMapConsumer$6.GENERATED_ORDER;
|
|
var mappings;
|
switch (order) {
|
case SourceMapConsumer$6.GENERATED_ORDER:
|
mappings = this._generatedMappings;
|
break;
|
case SourceMapConsumer$6.ORIGINAL_ORDER:
|
mappings = this._originalMappings;
|
break;
|
default:
|
throw new Error("Unknown order of iteration.");
|
}
|
|
var sourceRoot = this.sourceRoot;
|
var boundCallback = aCallback.bind(context);
|
var names = this._names;
|
var sources = this._sources;
|
var sourceMapURL = this._sourceMapURL;
|
|
for (var i = 0, n = mappings.length; i < n; i++) {
|
var mapping = mappings[i];
|
var source = mapping.source === null ? null : sources.at(mapping.source);
|
source = util$8.computeSourceURL(sourceRoot, source, sourceMapURL);
|
boundCallback({
|
source: source,
|
generatedLine: mapping.generatedLine,
|
generatedColumn: mapping.generatedColumn,
|
originalLine: mapping.originalLine,
|
originalColumn: mapping.originalColumn,
|
name: mapping.name === null ? null : names.at(mapping.name)
|
});
|
}
|
};
|
|
/**
|
* Returns all generated line and column information for the original source,
|
* line, and column provided. If no column is provided, returns all mappings
|
* corresponding to a either the line we are searching for or the next
|
* closest line that has any mappings. Otherwise, returns all mappings
|
* corresponding to the given line and either the column we are searching for
|
* or the next closest column that has any offsets.
|
*
|
* The only argument is an object with the following properties:
|
*
|
* - source: The filename of the original source.
|
* - line: The line number in the original source. The line number is 1-based.
|
* - column: Optional. the column number in the original source.
|
* The column number is 0-based.
|
*
|
* and an array of objects is returned, each with the following properties:
|
*
|
* - line: The line number in the generated source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the generated source, or null.
|
* The column number is 0-based.
|
*/
|
SourceMapConsumer$6.prototype.allGeneratedPositionsFor =
|
function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
|
var line = util$8.getArg(aArgs, 'line');
|
|
// When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
|
// returns the index of the closest mapping less than the needle. By
|
// setting needle.originalColumn to 0, we thus find the last mapping for
|
// the given line, provided such a mapping exists.
|
var needle = {
|
source: util$8.getArg(aArgs, 'source'),
|
originalLine: line,
|
originalColumn: util$8.getArg(aArgs, 'column', 0)
|
};
|
|
needle.source = this._findSourceIndex(needle.source);
|
if (needle.source < 0) {
|
return [];
|
}
|
|
var mappings = [];
|
|
var index = this._findMapping(needle,
|
this._originalMappings,
|
"originalLine",
|
"originalColumn",
|
util$8.compareByOriginalPositions,
|
binarySearch$2.LEAST_UPPER_BOUND);
|
if (index >= 0) {
|
var mapping = this._originalMappings[index];
|
|
if (aArgs.column === undefined) {
|
var originalLine = mapping.originalLine;
|
|
// Iterate until either we run out of mappings, or we run into
|
// a mapping for a different line than the one we found. Since
|
// mappings are sorted, this is guaranteed to find all mappings for
|
// the line we found.
|
while (mapping && mapping.originalLine === originalLine) {
|
mappings.push({
|
line: util$8.getArg(mapping, 'generatedLine', null),
|
column: util$8.getArg(mapping, 'generatedColumn', null),
|
lastColumn: util$8.getArg(mapping, 'lastGeneratedColumn', null)
|
});
|
|
mapping = this._originalMappings[++index];
|
}
|
} else {
|
var originalColumn = mapping.originalColumn;
|
|
// Iterate until either we run out of mappings, or we run into
|
// a mapping for a different line than the one we were searching for.
|
// Since mappings are sorted, this is guaranteed to find all mappings for
|
// the line we are searching for.
|
while (mapping &&
|
mapping.originalLine === line &&
|
mapping.originalColumn == originalColumn) {
|
mappings.push({
|
line: util$8.getArg(mapping, 'generatedLine', null),
|
column: util$8.getArg(mapping, 'generatedColumn', null),
|
lastColumn: util$8.getArg(mapping, 'lastGeneratedColumn', null)
|
});
|
|
mapping = this._originalMappings[++index];
|
}
|
}
|
}
|
|
return mappings;
|
};
|
|
sourceMapConsumer$1.SourceMapConsumer = SourceMapConsumer$6;
|
|
/**
|
* A BasicSourceMapConsumer instance represents a parsed source map which we can
|
* query for information about the original file positions by giving it a file
|
* position in the generated source.
|
*
|
* The first parameter is the raw source map (either as a JSON string, or
|
* already parsed to an object). According to the spec, source maps have the
|
* following attributes:
|
*
|
* - version: Which version of the source map spec this map is following.
|
* - sources: An array of URLs to the original source files.
|
* - names: An array of identifiers which can be referrenced by individual mappings.
|
* - sourceRoot: Optional. The URL root from which all sources are relative.
|
* - sourcesContent: Optional. An array of contents of the original source files.
|
* - mappings: A string of base64 VLQs which contain the actual mappings.
|
* - file: Optional. The generated file this source map is associated with.
|
*
|
* Here is an example source map, taken from the source map spec[0]:
|
*
|
* {
|
* version : 3,
|
* file: "out.js",
|
* sourceRoot : "",
|
* sources: ["foo.js", "bar.js"],
|
* names: ["src", "maps", "are", "fun"],
|
* mappings: "AA,AB;;ABCDE;"
|
* }
|
*
|
* The second parameter, if given, is a string whose value is the URL
|
* at which the source map was found. This URL is used to compute the
|
* sources array.
|
*
|
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
|
*/
|
function BasicSourceMapConsumer$1(aSourceMap, aSourceMapURL) {
|
var sourceMap = aSourceMap;
|
if (typeof aSourceMap === 'string') {
|
sourceMap = util$8.parseSourceMapInput(aSourceMap);
|
}
|
|
var version = util$8.getArg(sourceMap, 'version');
|
var sources = util$8.getArg(sourceMap, 'sources');
|
// Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
|
// requires the array) to play nice here.
|
var names = util$8.getArg(sourceMap, 'names', []);
|
var sourceRoot = util$8.getArg(sourceMap, 'sourceRoot', null);
|
var sourcesContent = util$8.getArg(sourceMap, 'sourcesContent', null);
|
var mappings = util$8.getArg(sourceMap, 'mappings');
|
var file = util$8.getArg(sourceMap, 'file', null);
|
|
// Once again, Sass deviates from the spec and supplies the version as a
|
// string rather than a number, so we use loose equality checking here.
|
if (version != this._version) {
|
throw new Error('Unsupported version: ' + version);
|
}
|
|
if (sourceRoot) {
|
sourceRoot = util$8.normalize(sourceRoot);
|
}
|
|
sources = sources
|
.map(String)
|
// Some source maps produce relative source paths like "./foo.js" instead of
|
// "foo.js". Normalize these first so that future comparisons will succeed.
|
// See bugzil.la/1090768.
|
.map(util$8.normalize)
|
// Always ensure that absolute sources are internally stored relative to
|
// the source root, if the source root is absolute. Not doing this would
|
// be particularly problematic when the source root is a prefix of the
|
// source (valid, but why??). See github issue #199 and bugzil.la/1188982.
|
.map(function (source) {
|
return sourceRoot && util$8.isAbsolute(sourceRoot) && util$8.isAbsolute(source)
|
? util$8.relative(sourceRoot, source)
|
: source;
|
});
|
|
// Pass `true` below to allow duplicate names and sources. While source maps
|
// are intended to be compressed and deduplicated, the TypeScript compiler
|
// sometimes generates source maps with duplicates in them. See Github issue
|
// #72 and bugzil.la/889492.
|
this._names = ArraySet$3.fromArray(names.map(String), true);
|
this._sources = ArraySet$3.fromArray(sources, true);
|
|
this._absoluteSources = this._sources.toArray().map(function (s) {
|
return util$8.computeSourceURL(sourceRoot, s, aSourceMapURL);
|
});
|
|
this.sourceRoot = sourceRoot;
|
this.sourcesContent = sourcesContent;
|
this._mappings = mappings;
|
this._sourceMapURL = aSourceMapURL;
|
this.file = file;
|
}
|
|
BasicSourceMapConsumer$1.prototype = Object.create(SourceMapConsumer$6.prototype);
|
BasicSourceMapConsumer$1.prototype.consumer = SourceMapConsumer$6;
|
|
/**
|
* Utility function to find the index of a source. Returns -1 if not
|
* found.
|
*/
|
BasicSourceMapConsumer$1.prototype._findSourceIndex = function(aSource) {
|
var relativeSource = aSource;
|
if (this.sourceRoot != null) {
|
relativeSource = util$8.relative(this.sourceRoot, relativeSource);
|
}
|
|
if (this._sources.has(relativeSource)) {
|
return this._sources.indexOf(relativeSource);
|
}
|
|
// Maybe aSource is an absolute URL as returned by |sources|. In
|
// this case we can't simply undo the transform.
|
var i;
|
for (i = 0; i < this._absoluteSources.length; ++i) {
|
if (this._absoluteSources[i] == aSource) {
|
return i;
|
}
|
}
|
|
return -1;
|
};
|
|
/**
|
* Create a BasicSourceMapConsumer from a SourceMapGenerator.
|
*
|
* @param SourceMapGenerator aSourceMap
|
* The source map that will be consumed.
|
* @param String aSourceMapURL
|
* The URL at which the source map can be found (optional)
|
* @returns BasicSourceMapConsumer
|
*/
|
BasicSourceMapConsumer$1.fromSourceMap =
|
function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
|
var smc = Object.create(BasicSourceMapConsumer$1.prototype);
|
|
var names = smc._names = ArraySet$3.fromArray(aSourceMap._names.toArray(), true);
|
var sources = smc._sources = ArraySet$3.fromArray(aSourceMap._sources.toArray(), true);
|
smc.sourceRoot = aSourceMap._sourceRoot;
|
smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
|
smc.sourceRoot);
|
smc.file = aSourceMap._file;
|
smc._sourceMapURL = aSourceMapURL;
|
smc._absoluteSources = smc._sources.toArray().map(function (s) {
|
return util$8.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
|
});
|
|
// Because we are modifying the entries (by converting string sources and
|
// names to indices into the sources and names ArraySets), we have to make
|
// a copy of the entry or else bad things happen. Shared mutable state
|
// strikes again! See github issue #191.
|
|
var generatedMappings = aSourceMap._mappings.toArray().slice();
|
var destGeneratedMappings = smc.__generatedMappings = [];
|
var destOriginalMappings = smc.__originalMappings = [];
|
|
for (var i = 0, length = generatedMappings.length; i < length; i++) {
|
var srcMapping = generatedMappings[i];
|
var destMapping = new Mapping$1;
|
destMapping.generatedLine = srcMapping.generatedLine;
|
destMapping.generatedColumn = srcMapping.generatedColumn;
|
|
if (srcMapping.source) {
|
destMapping.source = sources.indexOf(srcMapping.source);
|
destMapping.originalLine = srcMapping.originalLine;
|
destMapping.originalColumn = srcMapping.originalColumn;
|
|
if (srcMapping.name) {
|
destMapping.name = names.indexOf(srcMapping.name);
|
}
|
|
destOriginalMappings.push(destMapping);
|
}
|
|
destGeneratedMappings.push(destMapping);
|
}
|
|
quickSort$2(smc.__originalMappings, util$8.compareByOriginalPositions);
|
|
return smc;
|
};
|
|
/**
|
* The version of the source mapping spec that we are consuming.
|
*/
|
BasicSourceMapConsumer$1.prototype._version = 3;
|
|
/**
|
* The list of original sources.
|
*/
|
Object.defineProperty(BasicSourceMapConsumer$1.prototype, 'sources', {
|
get: function () {
|
return this._absoluteSources.slice();
|
}
|
});
|
|
/**
|
* Provide the JIT with a nice shape / hidden class.
|
*/
|
function Mapping$1() {
|
this.generatedLine = 0;
|
this.generatedColumn = 0;
|
this.source = null;
|
this.originalLine = null;
|
this.originalColumn = null;
|
this.name = null;
|
}
|
|
/**
|
* Parse the mappings in a string in to a data structure which we can easily
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
* `this.__originalMappings` properties).
|
*/
|
|
const compareGenerated = util$8.compareByGeneratedPositionsDeflatedNoLine;
|
function sortGenerated(array, start) {
|
let l = array.length;
|
let n = array.length - start;
|
if (n <= 1) {
|
return;
|
} else if (n == 2) {
|
let a = array[start];
|
let b = array[start + 1];
|
if (compareGenerated(a, b) > 0) {
|
array[start] = b;
|
array[start + 1] = a;
|
}
|
} else if (n < 20) {
|
for (let i = start; i < l; i++) {
|
for (let j = i; j > start; j--) {
|
let a = array[j - 1];
|
let b = array[j];
|
if (compareGenerated(a, b) <= 0) {
|
break;
|
}
|
array[j - 1] = b;
|
array[j] = a;
|
}
|
}
|
} else {
|
quickSort$2(array, compareGenerated, start);
|
}
|
}
|
BasicSourceMapConsumer$1.prototype._parseMappings =
|
function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
var generatedLine = 1;
|
var previousGeneratedColumn = 0;
|
var previousOriginalLine = 0;
|
var previousOriginalColumn = 0;
|
var previousSource = 0;
|
var previousName = 0;
|
var length = aStr.length;
|
var index = 0;
|
var temp = {};
|
var originalMappings = [];
|
var generatedMappings = [];
|
var mapping, segment, end, value;
|
|
let subarrayStart = 0;
|
while (index < length) {
|
if (aStr.charAt(index) === ';') {
|
generatedLine++;
|
index++;
|
previousGeneratedColumn = 0;
|
|
sortGenerated(generatedMappings, subarrayStart);
|
subarrayStart = generatedMappings.length;
|
}
|
else if (aStr.charAt(index) === ',') {
|
index++;
|
}
|
else {
|
mapping = new Mapping$1();
|
mapping.generatedLine = generatedLine;
|
|
for (end = index; end < length; end++) {
|
if (this._charIsMappingSeparator(aStr, end)) {
|
break;
|
}
|
}
|
aStr.slice(index, end);
|
|
segment = [];
|
while (index < end) {
|
base64VLQ$2.decode(aStr, index, temp);
|
value = temp.value;
|
index = temp.rest;
|
segment.push(value);
|
}
|
|
if (segment.length === 2) {
|
throw new Error('Found a source, but no line and column');
|
}
|
|
if (segment.length === 3) {
|
throw new Error('Found a source and line, but no column');
|
}
|
|
// Generated column.
|
mapping.generatedColumn = previousGeneratedColumn + segment[0];
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
if (segment.length > 1) {
|
// Original source.
|
mapping.source = previousSource + segment[1];
|
previousSource += segment[1];
|
|
// Original line.
|
mapping.originalLine = previousOriginalLine + segment[2];
|
previousOriginalLine = mapping.originalLine;
|
// Lines are stored 0-based
|
mapping.originalLine += 1;
|
|
// Original column.
|
mapping.originalColumn = previousOriginalColumn + segment[3];
|
previousOriginalColumn = mapping.originalColumn;
|
|
if (segment.length > 4) {
|
// Original name.
|
mapping.name = previousName + segment[4];
|
previousName += segment[4];
|
}
|
}
|
|
generatedMappings.push(mapping);
|
if (typeof mapping.originalLine === 'number') {
|
let currentSource = mapping.source;
|
while (originalMappings.length <= currentSource) {
|
originalMappings.push(null);
|
}
|
if (originalMappings[currentSource] === null) {
|
originalMappings[currentSource] = [];
|
}
|
originalMappings[currentSource].push(mapping);
|
}
|
}
|
}
|
|
sortGenerated(generatedMappings, subarrayStart);
|
this.__generatedMappings = generatedMappings;
|
|
for (var i = 0; i < originalMappings.length; i++) {
|
if (originalMappings[i] != null) {
|
quickSort$2(originalMappings[i], util$8.compareByOriginalPositionsNoSource);
|
}
|
}
|
this.__originalMappings = [].concat(...originalMappings);
|
};
|
|
/**
|
* Find the mapping that best matches the hypothetical "needle" mapping that
|
* we are searching for in the given "haystack" of mappings.
|
*/
|
BasicSourceMapConsumer$1.prototype._findMapping =
|
function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
|
aColumnName, aComparator, aBias) {
|
// To return the position we are searching for, we must first find the
|
// mapping for the given position and then return the opposite position it
|
// points to. Because the mappings are sorted, we can use binary search to
|
// find the best mapping.
|
|
if (aNeedle[aLineName] <= 0) {
|
throw new TypeError('Line must be greater than or equal to 1, got '
|
+ aNeedle[aLineName]);
|
}
|
if (aNeedle[aColumnName] < 0) {
|
throw new TypeError('Column must be greater than or equal to 0, got '
|
+ aNeedle[aColumnName]);
|
}
|
|
return binarySearch$2.search(aNeedle, aMappings, aComparator, aBias);
|
};
|
|
/**
|
* Compute the last column for each generated mapping. The last column is
|
* inclusive.
|
*/
|
BasicSourceMapConsumer$1.prototype.computeColumnSpans =
|
function SourceMapConsumer_computeColumnSpans() {
|
for (var index = 0; index < this._generatedMappings.length; ++index) {
|
var mapping = this._generatedMappings[index];
|
|
// Mappings do not contain a field for the last generated columnt. We
|
// can come up with an optimistic estimate, however, by assuming that
|
// mappings are contiguous (i.e. given two consecutive mappings, the
|
// first mapping ends where the second one starts).
|
if (index + 1 < this._generatedMappings.length) {
|
var nextMapping = this._generatedMappings[index + 1];
|
|
if (mapping.generatedLine === nextMapping.generatedLine) {
|
mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
|
continue;
|
}
|
}
|
|
// The last mapping for each line spans the entire line.
|
mapping.lastGeneratedColumn = Infinity;
|
}
|
};
|
|
/**
|
* Returns the original source, line, and column information for the generated
|
* source's line and column positions provided. The only argument is an object
|
* with the following properties:
|
*
|
* - line: The line number in the generated source. The line number
|
* is 1-based.
|
* - column: The column number in the generated source. The column
|
* number is 0-based.
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - source: The original source file, or null.
|
* - line: The line number in the original source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the original source, or null. The
|
* column number is 0-based.
|
* - name: The original identifier, or null.
|
*/
|
BasicSourceMapConsumer$1.prototype.originalPositionFor =
|
function SourceMapConsumer_originalPositionFor(aArgs) {
|
var needle = {
|
generatedLine: util$8.getArg(aArgs, 'line'),
|
generatedColumn: util$8.getArg(aArgs, 'column')
|
};
|
|
var index = this._findMapping(
|
needle,
|
this._generatedMappings,
|
"generatedLine",
|
"generatedColumn",
|
util$8.compareByGeneratedPositionsDeflated,
|
util$8.getArg(aArgs, 'bias', SourceMapConsumer$6.GREATEST_LOWER_BOUND)
|
);
|
|
if (index >= 0) {
|
var mapping = this._generatedMappings[index];
|
|
if (mapping.generatedLine === needle.generatedLine) {
|
var source = util$8.getArg(mapping, 'source', null);
|
if (source !== null) {
|
source = this._sources.at(source);
|
source = util$8.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
|
}
|
var name = util$8.getArg(mapping, 'name', null);
|
if (name !== null) {
|
name = this._names.at(name);
|
}
|
return {
|
source: source,
|
line: util$8.getArg(mapping, 'originalLine', null),
|
column: util$8.getArg(mapping, 'originalColumn', null),
|
name: name
|
};
|
}
|
}
|
|
return {
|
source: null,
|
line: null,
|
column: null,
|
name: null
|
};
|
};
|
|
/**
|
* Return true if we have the source content for every source in the source
|
* map, false otherwise.
|
*/
|
BasicSourceMapConsumer$1.prototype.hasContentsOfAllSources =
|
function BasicSourceMapConsumer_hasContentsOfAllSources() {
|
if (!this.sourcesContent) {
|
return false;
|
}
|
return this.sourcesContent.length >= this._sources.size() &&
|
!this.sourcesContent.some(function (sc) { return sc == null; });
|
};
|
|
/**
|
* Returns the original source content. The only argument is the url of the
|
* original source file. Returns null if no original source content is
|
* available.
|
*/
|
BasicSourceMapConsumer$1.prototype.sourceContentFor =
|
function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
|
if (!this.sourcesContent) {
|
return null;
|
}
|
|
var index = this._findSourceIndex(aSource);
|
if (index >= 0) {
|
return this.sourcesContent[index];
|
}
|
|
var relativeSource = aSource;
|
if (this.sourceRoot != null) {
|
relativeSource = util$8.relative(this.sourceRoot, relativeSource);
|
}
|
|
var url;
|
if (this.sourceRoot != null
|
&& (url = util$8.urlParse(this.sourceRoot))) {
|
// XXX: file:// URIs and absolute paths lead to unexpected behavior for
|
// many users. We can help them out when they expect file:// URIs to
|
// behave like it would if they were running a local HTTP server. See
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
|
var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
|
if (url.scheme == "file"
|
&& this._sources.has(fileUriAbsPath)) {
|
return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
|
}
|
|
if ((!url.path || url.path == "/")
|
&& this._sources.has("/" + relativeSource)) {
|
return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
|
}
|
}
|
|
// This function is used recursively from
|
// IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
|
// don't want to throw if we can't find the source - we just want to
|
// return null, so we provide a flag to exit gracefully.
|
if (nullOnMissing) {
|
return null;
|
}
|
else {
|
throw new Error('"' + relativeSource + '" is not in the SourceMap.');
|
}
|
};
|
|
/**
|
* Returns the generated line and column information for the original source,
|
* line, and column positions provided. The only argument is an object with
|
* the following properties:
|
*
|
* - source: The filename of the original source.
|
* - line: The line number in the original source. The line number
|
* is 1-based.
|
* - column: The column number in the original source. The column
|
* number is 0-based.
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - line: The line number in the generated source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the generated source, or null.
|
* The column number is 0-based.
|
*/
|
BasicSourceMapConsumer$1.prototype.generatedPositionFor =
|
function SourceMapConsumer_generatedPositionFor(aArgs) {
|
var source = util$8.getArg(aArgs, 'source');
|
source = this._findSourceIndex(source);
|
if (source < 0) {
|
return {
|
line: null,
|
column: null,
|
lastColumn: null
|
};
|
}
|
|
var needle = {
|
source: source,
|
originalLine: util$8.getArg(aArgs, 'line'),
|
originalColumn: util$8.getArg(aArgs, 'column')
|
};
|
|
var index = this._findMapping(
|
needle,
|
this._originalMappings,
|
"originalLine",
|
"originalColumn",
|
util$8.compareByOriginalPositions,
|
util$8.getArg(aArgs, 'bias', SourceMapConsumer$6.GREATEST_LOWER_BOUND)
|
);
|
|
if (index >= 0) {
|
var mapping = this._originalMappings[index];
|
|
if (mapping.source === needle.source) {
|
return {
|
line: util$8.getArg(mapping, 'generatedLine', null),
|
column: util$8.getArg(mapping, 'generatedColumn', null),
|
lastColumn: util$8.getArg(mapping, 'lastGeneratedColumn', null)
|
};
|
}
|
}
|
|
return {
|
line: null,
|
column: null,
|
lastColumn: null
|
};
|
};
|
|
sourceMapConsumer$1.BasicSourceMapConsumer = BasicSourceMapConsumer$1;
|
|
/**
|
* An IndexedSourceMapConsumer instance represents a parsed source map which
|
* we can query for information. It differs from BasicSourceMapConsumer in
|
* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
|
* input.
|
*
|
* The first parameter is a raw source map (either as a JSON string, or already
|
* parsed to an object). According to the spec for indexed source maps, they
|
* have the following attributes:
|
*
|
* - version: Which version of the source map spec this map is following.
|
* - file: Optional. The generated file this source map is associated with.
|
* - sections: A list of section definitions.
|
*
|
* Each value under the "sections" field has two fields:
|
* - offset: The offset into the original specified at which this section
|
* begins to apply, defined as an object with a "line" and "column"
|
* field.
|
* - map: A source map definition. This source map could also be indexed,
|
* but doesn't have to be.
|
*
|
* Instead of the "map" field, it's also possible to have a "url" field
|
* specifying a URL to retrieve a source map from, but that's currently
|
* unsupported.
|
*
|
* Here's an example source map, taken from the source map spec[0], but
|
* modified to omit a section which uses the "url" field.
|
*
|
* {
|
* version : 3,
|
* file: "app.js",
|
* sections: [{
|
* offset: {line:100, column:10},
|
* map: {
|
* version : 3,
|
* file: "section.js",
|
* sources: ["foo.js", "bar.js"],
|
* names: ["src", "maps", "are", "fun"],
|
* mappings: "AAAA,E;;ABCDE;"
|
* }
|
* }],
|
* }
|
*
|
* The second parameter, if given, is a string whose value is the URL
|
* at which the source map was found. This URL is used to compute the
|
* sources array.
|
*
|
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
|
*/
|
function IndexedSourceMapConsumer$1(aSourceMap, aSourceMapURL) {
|
var sourceMap = aSourceMap;
|
if (typeof aSourceMap === 'string') {
|
sourceMap = util$8.parseSourceMapInput(aSourceMap);
|
}
|
|
var version = util$8.getArg(sourceMap, 'version');
|
var sections = util$8.getArg(sourceMap, 'sections');
|
|
if (version != this._version) {
|
throw new Error('Unsupported version: ' + version);
|
}
|
|
this._sources = new ArraySet$3();
|
this._names = new ArraySet$3();
|
|
var lastOffset = {
|
line: -1,
|
column: 0
|
};
|
this._sections = sections.map(function (s) {
|
if (s.url) {
|
// The url field will require support for asynchronicity.
|
// See https://github.com/mozilla/source-map/issues/16
|
throw new Error('Support for url field in sections not implemented.');
|
}
|
var offset = util$8.getArg(s, 'offset');
|
var offsetLine = util$8.getArg(offset, 'line');
|
var offsetColumn = util$8.getArg(offset, 'column');
|
|
if (offsetLine < lastOffset.line ||
|
(offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
|
throw new Error('Section offsets must be ordered and non-overlapping.');
|
}
|
lastOffset = offset;
|
|
return {
|
generatedOffset: {
|
// The offset fields are 0-based, but we use 1-based indices when
|
// encoding/decoding from VLQ.
|
generatedLine: offsetLine + 1,
|
generatedColumn: offsetColumn + 1
|
},
|
consumer: new SourceMapConsumer$6(util$8.getArg(s, 'map'), aSourceMapURL)
|
}
|
});
|
}
|
|
IndexedSourceMapConsumer$1.prototype = Object.create(SourceMapConsumer$6.prototype);
|
IndexedSourceMapConsumer$1.prototype.constructor = SourceMapConsumer$6;
|
|
/**
|
* The version of the source mapping spec that we are consuming.
|
*/
|
IndexedSourceMapConsumer$1.prototype._version = 3;
|
|
/**
|
* The list of original sources.
|
*/
|
Object.defineProperty(IndexedSourceMapConsumer$1.prototype, 'sources', {
|
get: function () {
|
var sources = [];
|
for (var i = 0; i < this._sections.length; i++) {
|
for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
|
sources.push(this._sections[i].consumer.sources[j]);
|
}
|
}
|
return sources;
|
}
|
});
|
|
/**
|
* Returns the original source, line, and column information for the generated
|
* source's line and column positions provided. The only argument is an object
|
* with the following properties:
|
*
|
* - line: The line number in the generated source. The line number
|
* is 1-based.
|
* - column: The column number in the generated source. The column
|
* number is 0-based.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - source: The original source file, or null.
|
* - line: The line number in the original source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the original source, or null. The
|
* column number is 0-based.
|
* - name: The original identifier, or null.
|
*/
|
IndexedSourceMapConsumer$1.prototype.originalPositionFor =
|
function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
|
var needle = {
|
generatedLine: util$8.getArg(aArgs, 'line'),
|
generatedColumn: util$8.getArg(aArgs, 'column')
|
};
|
|
// Find the section containing the generated position we're trying to map
|
// to an original position.
|
var sectionIndex = binarySearch$2.search(needle, this._sections,
|
function(needle, section) {
|
var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
|
if (cmp) {
|
return cmp;
|
}
|
|
return (needle.generatedColumn -
|
section.generatedOffset.generatedColumn);
|
});
|
var section = this._sections[sectionIndex];
|
|
if (!section) {
|
return {
|
source: null,
|
line: null,
|
column: null,
|
name: null
|
};
|
}
|
|
return section.consumer.originalPositionFor({
|
line: needle.generatedLine -
|
(section.generatedOffset.generatedLine - 1),
|
column: needle.generatedColumn -
|
(section.generatedOffset.generatedLine === needle.generatedLine
|
? section.generatedOffset.generatedColumn - 1
|
: 0),
|
bias: aArgs.bias
|
});
|
};
|
|
/**
|
* Return true if we have the source content for every source in the source
|
* map, false otherwise.
|
*/
|
IndexedSourceMapConsumer$1.prototype.hasContentsOfAllSources =
|
function IndexedSourceMapConsumer_hasContentsOfAllSources() {
|
return this._sections.every(function (s) {
|
return s.consumer.hasContentsOfAllSources();
|
});
|
};
|
|
/**
|
* Returns the original source content. The only argument is the url of the
|
* original source file. Returns null if no original source content is
|
* available.
|
*/
|
IndexedSourceMapConsumer$1.prototype.sourceContentFor =
|
function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
|
for (var i = 0; i < this._sections.length; i++) {
|
var section = this._sections[i];
|
|
var content = section.consumer.sourceContentFor(aSource, true);
|
if (content) {
|
return content;
|
}
|
}
|
if (nullOnMissing) {
|
return null;
|
}
|
else {
|
throw new Error('"' + aSource + '" is not in the SourceMap.');
|
}
|
};
|
|
/**
|
* Returns the generated line and column information for the original source,
|
* line, and column positions provided. The only argument is an object with
|
* the following properties:
|
*
|
* - source: The filename of the original source.
|
* - line: The line number in the original source. The line number
|
* is 1-based.
|
* - column: The column number in the original source. The column
|
* number is 0-based.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - line: The line number in the generated source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the generated source, or null.
|
* The column number is 0-based.
|
*/
|
IndexedSourceMapConsumer$1.prototype.generatedPositionFor =
|
function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
|
for (var i = 0; i < this._sections.length; i++) {
|
var section = this._sections[i];
|
|
// Only consider this section if the requested source is in the list of
|
// sources of the consumer.
|
if (section.consumer._findSourceIndex(util$8.getArg(aArgs, 'source')) === -1) {
|
continue;
|
}
|
var generatedPosition = section.consumer.generatedPositionFor(aArgs);
|
if (generatedPosition) {
|
var ret = {
|
line: generatedPosition.line +
|
(section.generatedOffset.generatedLine - 1),
|
column: generatedPosition.column +
|
(section.generatedOffset.generatedLine === generatedPosition.line
|
? section.generatedOffset.generatedColumn - 1
|
: 0)
|
};
|
return ret;
|
}
|
}
|
|
return {
|
line: null,
|
column: null
|
};
|
};
|
|
/**
|
* Parse the mappings in a string in to a data structure which we can easily
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
* `this.__originalMappings` properties).
|
*/
|
IndexedSourceMapConsumer$1.prototype._parseMappings =
|
function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
this.__generatedMappings = [];
|
this.__originalMappings = [];
|
for (var i = 0; i < this._sections.length; i++) {
|
var section = this._sections[i];
|
var sectionMappings = section.consumer._generatedMappings;
|
for (var j = 0; j < sectionMappings.length; j++) {
|
var mapping = sectionMappings[j];
|
|
var source = section.consumer._sources.at(mapping.source);
|
source = util$8.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
|
this._sources.add(source);
|
source = this._sources.indexOf(source);
|
|
var name = null;
|
if (mapping.name) {
|
name = section.consumer._names.at(mapping.name);
|
this._names.add(name);
|
name = this._names.indexOf(name);
|
}
|
|
// The mappings coming from the consumer for the section have
|
// generated positions relative to the start of the section, so we
|
// need to offset them to be relative to the start of the concatenated
|
// generated file.
|
var adjustedMapping = {
|
source: source,
|
generatedLine: mapping.generatedLine +
|
(section.generatedOffset.generatedLine - 1),
|
generatedColumn: mapping.generatedColumn +
|
(section.generatedOffset.generatedLine === mapping.generatedLine
|
? section.generatedOffset.generatedColumn - 1
|
: 0),
|
originalLine: mapping.originalLine,
|
originalColumn: mapping.originalColumn,
|
name: name
|
};
|
|
this.__generatedMappings.push(adjustedMapping);
|
if (typeof adjustedMapping.originalLine === 'number') {
|
this.__originalMappings.push(adjustedMapping);
|
}
|
}
|
}
|
|
quickSort$2(this.__generatedMappings, util$8.compareByGeneratedPositionsDeflated);
|
quickSort$2(this.__originalMappings, util$8.compareByOriginalPositions);
|
};
|
|
sourceMapConsumer$1.IndexedSourceMapConsumer = IndexedSourceMapConsumer$1;
|
|
var sourceNode$1 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var SourceMapGenerator$7 = sourceMapGenerator$1.SourceMapGenerator;
|
var util$7 = util$c;
|
|
// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
|
// operating systems these days (capturing the result).
|
var REGEX_NEWLINE$1 = /(\r?\n)/;
|
|
// Newline character code for charCodeAt() comparisons
|
var NEWLINE_CODE$1 = 10;
|
|
// Private symbol for identifying `SourceNode`s when multiple versions of
|
// the source-map library are loaded. This MUST NOT CHANGE across
|
// versions!
|
var isSourceNode$1 = "$$$isSourceNode$$$";
|
|
/**
|
* SourceNodes provide a way to abstract over interpolating/concatenating
|
* snippets of generated JavaScript source code while maintaining the line and
|
* column information associated with the original source code.
|
*
|
* @param aLine The original line number.
|
* @param aColumn The original column number.
|
* @param aSource The original source's filename.
|
* @param aChunks Optional. An array of strings which are snippets of
|
* generated JS, or other SourceNodes.
|
* @param aName The original identifier.
|
*/
|
function SourceNode$1(aLine, aColumn, aSource, aChunks, aName) {
|
this.children = [];
|
this.sourceContents = {};
|
this.line = aLine == null ? null : aLine;
|
this.column = aColumn == null ? null : aColumn;
|
this.source = aSource == null ? null : aSource;
|
this.name = aName == null ? null : aName;
|
this[isSourceNode$1] = true;
|
if (aChunks != null) this.add(aChunks);
|
}
|
|
/**
|
* Creates a SourceNode from generated code and a SourceMapConsumer.
|
*
|
* @param aGeneratedCode The generated code
|
* @param aSourceMapConsumer The SourceMap for the generated code
|
* @param aRelativePath Optional. The path that relative sources in the
|
* SourceMapConsumer should be relative to.
|
*/
|
SourceNode$1.fromStringWithSourceMap =
|
function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
|
// The SourceNode we want to fill with the generated code
|
// and the SourceMap
|
var node = new SourceNode$1();
|
|
// All even indices of this array are one line of the generated code,
|
// while all odd indices are the newlines between two adjacent lines
|
// (since `REGEX_NEWLINE` captures its match).
|
// Processed fragments are accessed by calling `shiftNextLine`.
|
var remainingLines = aGeneratedCode.split(REGEX_NEWLINE$1);
|
var remainingLinesIndex = 0;
|
var shiftNextLine = function() {
|
var lineContents = getNextLine();
|
// The last line of a file might not have a newline.
|
var newLine = getNextLine() || "";
|
return lineContents + newLine;
|
|
function getNextLine() {
|
return remainingLinesIndex < remainingLines.length ?
|
remainingLines[remainingLinesIndex++] : undefined;
|
}
|
};
|
|
// We need to remember the position of "remainingLines"
|
var lastGeneratedLine = 1, lastGeneratedColumn = 0;
|
|
// The generate SourceNodes we need a code range.
|
// To extract it current and last mapping is used.
|
// Here we store the last mapping.
|
var lastMapping = null;
|
|
aSourceMapConsumer.eachMapping(function (mapping) {
|
if (lastMapping !== null) {
|
// We add the code from "lastMapping" to "mapping":
|
// First check if there is a new line in between.
|
if (lastGeneratedLine < mapping.generatedLine) {
|
// Associate first line with "lastMapping"
|
addMappingWithCode(lastMapping, shiftNextLine());
|
lastGeneratedLine++;
|
lastGeneratedColumn = 0;
|
// The remaining code is added without mapping
|
} else {
|
// There is no new line in between.
|
// Associate the code between "lastGeneratedColumn" and
|
// "mapping.generatedColumn" with "lastMapping"
|
var nextLine = remainingLines[remainingLinesIndex] || '';
|
var code = nextLine.substr(0, mapping.generatedColumn -
|
lastGeneratedColumn);
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
|
lastGeneratedColumn);
|
lastGeneratedColumn = mapping.generatedColumn;
|
addMappingWithCode(lastMapping, code);
|
// No more remaining code, continue
|
lastMapping = mapping;
|
return;
|
}
|
}
|
// We add the generated code until the first mapping
|
// to the SourceNode without any mapping.
|
// Each line is added as separate string.
|
while (lastGeneratedLine < mapping.generatedLine) {
|
node.add(shiftNextLine());
|
lastGeneratedLine++;
|
}
|
if (lastGeneratedColumn < mapping.generatedColumn) {
|
var nextLine = remainingLines[remainingLinesIndex] || '';
|
node.add(nextLine.substr(0, mapping.generatedColumn));
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
|
lastGeneratedColumn = mapping.generatedColumn;
|
}
|
lastMapping = mapping;
|
}, this);
|
// We have processed all mappings.
|
if (remainingLinesIndex < remainingLines.length) {
|
if (lastMapping) {
|
// Associate the remaining code in the current line with "lastMapping"
|
addMappingWithCode(lastMapping, shiftNextLine());
|
}
|
// and add the remaining lines without any mapping
|
node.add(remainingLines.splice(remainingLinesIndex).join(""));
|
}
|
|
// Copy sourcesContent into SourceNode
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
if (content != null) {
|
if (aRelativePath != null) {
|
sourceFile = util$7.join(aRelativePath, sourceFile);
|
}
|
node.setSourceContent(sourceFile, content);
|
}
|
});
|
|
return node;
|
|
function addMappingWithCode(mapping, code) {
|
if (mapping === null || mapping.source === undefined) {
|
node.add(code);
|
} else {
|
var source = aRelativePath
|
? util$7.join(aRelativePath, mapping.source)
|
: mapping.source;
|
node.add(new SourceNode$1(mapping.originalLine,
|
mapping.originalColumn,
|
source,
|
code,
|
mapping.name));
|
}
|
}
|
};
|
|
/**
|
* Add a chunk of generated JS to this source node.
|
*
|
* @param aChunk A string snippet of generated JS code, another instance of
|
* SourceNode, or an array where each member is one of those things.
|
*/
|
SourceNode$1.prototype.add = function SourceNode_add(aChunk) {
|
if (Array.isArray(aChunk)) {
|
aChunk.forEach(function (chunk) {
|
this.add(chunk);
|
}, this);
|
}
|
else if (aChunk[isSourceNode$1] || typeof aChunk === "string") {
|
if (aChunk) {
|
this.children.push(aChunk);
|
}
|
}
|
else {
|
throw new TypeError(
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
);
|
}
|
return this;
|
};
|
|
/**
|
* Add a chunk of generated JS to the beginning of this source node.
|
*
|
* @param aChunk A string snippet of generated JS code, another instance of
|
* SourceNode, or an array where each member is one of those things.
|
*/
|
SourceNode$1.prototype.prepend = function SourceNode_prepend(aChunk) {
|
if (Array.isArray(aChunk)) {
|
for (var i = aChunk.length-1; i >= 0; i--) {
|
this.prepend(aChunk[i]);
|
}
|
}
|
else if (aChunk[isSourceNode$1] || typeof aChunk === "string") {
|
this.children.unshift(aChunk);
|
}
|
else {
|
throw new TypeError(
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
);
|
}
|
return this;
|
};
|
|
/**
|
* Walk over the tree of JS snippets in this node and its children. The
|
* walking function is called once for each snippet of JS and is passed that
|
* snippet and the its original associated source's line/column location.
|
*
|
* @param aFn The traversal function.
|
*/
|
SourceNode$1.prototype.walk = function SourceNode_walk(aFn) {
|
var chunk;
|
for (var i = 0, len = this.children.length; i < len; i++) {
|
chunk = this.children[i];
|
if (chunk[isSourceNode$1]) {
|
chunk.walk(aFn);
|
}
|
else {
|
if (chunk !== '') {
|
aFn(chunk, { source: this.source,
|
line: this.line,
|
column: this.column,
|
name: this.name });
|
}
|
}
|
}
|
};
|
|
/**
|
* Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
|
* each of `this.children`.
|
*
|
* @param aSep The separator.
|
*/
|
SourceNode$1.prototype.join = function SourceNode_join(aSep) {
|
var newChildren;
|
var i;
|
var len = this.children.length;
|
if (len > 0) {
|
newChildren = [];
|
for (i = 0; i < len-1; i++) {
|
newChildren.push(this.children[i]);
|
newChildren.push(aSep);
|
}
|
newChildren.push(this.children[i]);
|
this.children = newChildren;
|
}
|
return this;
|
};
|
|
/**
|
* Call String.prototype.replace on the very right-most source snippet. Useful
|
* for trimming whitespace from the end of a source node, etc.
|
*
|
* @param aPattern The pattern to replace.
|
* @param aReplacement The thing to replace the pattern with.
|
*/
|
SourceNode$1.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
|
var lastChild = this.children[this.children.length - 1];
|
if (lastChild[isSourceNode$1]) {
|
lastChild.replaceRight(aPattern, aReplacement);
|
}
|
else if (typeof lastChild === 'string') {
|
this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
|
}
|
else {
|
this.children.push(''.replace(aPattern, aReplacement));
|
}
|
return this;
|
};
|
|
/**
|
* Set the source content for a source file. This will be added to the SourceMapGenerator
|
* in the sourcesContent field.
|
*
|
* @param aSourceFile The filename of the source file
|
* @param aSourceContent The content of the source file
|
*/
|
SourceNode$1.prototype.setSourceContent =
|
function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
|
this.sourceContents[util$7.toSetString(aSourceFile)] = aSourceContent;
|
};
|
|
/**
|
* Walk over the tree of SourceNodes. The walking function is called for each
|
* source file content and is passed the filename and source content.
|
*
|
* @param aFn The traversal function.
|
*/
|
SourceNode$1.prototype.walkSourceContents =
|
function SourceNode_walkSourceContents(aFn) {
|
for (var i = 0, len = this.children.length; i < len; i++) {
|
if (this.children[i][isSourceNode$1]) {
|
this.children[i].walkSourceContents(aFn);
|
}
|
}
|
|
var sources = Object.keys(this.sourceContents);
|
for (var i = 0, len = sources.length; i < len; i++) {
|
aFn(util$7.fromSetString(sources[i]), this.sourceContents[sources[i]]);
|
}
|
};
|
|
/**
|
* Return the string representation of this source node. Walks over the tree
|
* and concatenates all the various snippets together to one string.
|
*/
|
SourceNode$1.prototype.toString = function SourceNode_toString() {
|
var str = "";
|
this.walk(function (chunk) {
|
str += chunk;
|
});
|
return str;
|
};
|
|
/**
|
* Returns the string representation of this source node along with a source
|
* map.
|
*/
|
SourceNode$1.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
|
var generated = {
|
code: "",
|
line: 1,
|
column: 0
|
};
|
var map = new SourceMapGenerator$7(aArgs);
|
var sourceMappingActive = false;
|
var lastOriginalSource = null;
|
var lastOriginalLine = null;
|
var lastOriginalColumn = null;
|
var lastOriginalName = null;
|
this.walk(function (chunk, original) {
|
generated.code += chunk;
|
if (original.source !== null
|
&& original.line !== null
|
&& original.column !== null) {
|
if(lastOriginalSource !== original.source
|
|| lastOriginalLine !== original.line
|
|| lastOriginalColumn !== original.column
|
|| lastOriginalName !== original.name) {
|
map.addMapping({
|
source: original.source,
|
original: {
|
line: original.line,
|
column: original.column
|
},
|
generated: {
|
line: generated.line,
|
column: generated.column
|
},
|
name: original.name
|
});
|
}
|
lastOriginalSource = original.source;
|
lastOriginalLine = original.line;
|
lastOriginalColumn = original.column;
|
lastOriginalName = original.name;
|
sourceMappingActive = true;
|
} else if (sourceMappingActive) {
|
map.addMapping({
|
generated: {
|
line: generated.line,
|
column: generated.column
|
}
|
});
|
lastOriginalSource = null;
|
sourceMappingActive = false;
|
}
|
for (var idx = 0, length = chunk.length; idx < length; idx++) {
|
if (chunk.charCodeAt(idx) === NEWLINE_CODE$1) {
|
generated.line++;
|
generated.column = 0;
|
// Mappings end at eol
|
if (idx + 1 === length) {
|
lastOriginalSource = null;
|
sourceMappingActive = false;
|
} else if (sourceMappingActive) {
|
map.addMapping({
|
source: original.source,
|
original: {
|
line: original.line,
|
column: original.column
|
},
|
generated: {
|
line: generated.line,
|
column: generated.column
|
},
|
name: original.name
|
});
|
}
|
} else {
|
generated.column++;
|
}
|
}
|
});
|
this.walkSourceContents(function (sourceFile, sourceContent) {
|
map.setSourceContent(sourceFile, sourceContent);
|
});
|
|
return { code: generated.code, map: map };
|
};
|
|
sourceNode$1.SourceNode = SourceNode$1;
|
|
/*
|
* Copyright 2009-2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE.txt or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var SourceMapGenerator$6 = sourceMap$2.SourceMapGenerator = sourceMapGenerator$1.SourceMapGenerator;
|
var SourceMapConsumer$5 = sourceMap$2.SourceMapConsumer = sourceMapConsumer$1.SourceMapConsumer;
|
sourceMap$2.SourceNode = sourceNode$1.SourceNode;
|
|
const PURE_ANNOTATION = `/*#__PURE__*/`;
|
const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
|
function createCodegenContext(ast, {
|
mode = "function",
|
prefixIdentifiers = mode === "module",
|
sourceMap = false,
|
filename = `template.vue.html`,
|
scopeId = null,
|
optimizeImports = false,
|
runtimeGlobalName = `Vue`,
|
runtimeModuleName = `vue`,
|
ssrRuntimeModuleName = "vue/server-renderer",
|
ssr = false,
|
isTS = false,
|
inSSR = false
|
}) {
|
const context = {
|
mode,
|
prefixIdentifiers,
|
sourceMap,
|
filename,
|
scopeId,
|
optimizeImports,
|
runtimeGlobalName,
|
runtimeModuleName,
|
ssrRuntimeModuleName,
|
ssr,
|
isTS,
|
inSSR,
|
source: ast.loc.source,
|
code: ``,
|
column: 1,
|
line: 1,
|
offset: 0,
|
indentLevel: 0,
|
pure: false,
|
map: void 0,
|
helper(key) {
|
return `_${helperNameMap[key]}`;
|
},
|
push(code, node) {
|
context.code += code;
|
if (context.map) {
|
if (node) {
|
let name;
|
if (node.type === 4 && !node.isStatic) {
|
const content = node.content.replace(/^_ctx\./, "");
|
if (content !== node.content && isSimpleIdentifier(content)) {
|
name = content;
|
}
|
}
|
addMapping(node.loc.start, name);
|
}
|
advancePositionWithMutation(context, code);
|
if (node && node.loc !== locStub) {
|
addMapping(node.loc.end);
|
}
|
}
|
},
|
indent() {
|
newline(++context.indentLevel);
|
},
|
deindent(withoutNewLine = false) {
|
if (withoutNewLine) {
|
--context.indentLevel;
|
} else {
|
newline(--context.indentLevel);
|
}
|
},
|
newline() {
|
newline(context.indentLevel);
|
}
|
};
|
function newline(n) {
|
context.push("\n" + ` `.repeat(n));
|
}
|
function addMapping(loc, name) {
|
context.map.addMapping({
|
name,
|
source: context.filename,
|
original: {
|
line: loc.line,
|
column: loc.column - 1
|
// source-map column is 0 based
|
},
|
generated: {
|
line: context.line,
|
column: context.column - 1
|
}
|
});
|
}
|
if (sourceMap) {
|
context.map = new SourceMapGenerator$6();
|
context.map.setSourceContent(filename, context.source);
|
}
|
return context;
|
}
|
function generate(ast, options = {}) {
|
const context = createCodegenContext(ast, options);
|
if (options.onContextCreated)
|
options.onContextCreated(context);
|
const {
|
mode,
|
push,
|
prefixIdentifiers,
|
indent,
|
deindent,
|
newline,
|
scopeId,
|
ssr
|
} = context;
|
const helpers = Array.from(ast.helpers);
|
const hasHelpers = helpers.length > 0;
|
const useWithBlock = !prefixIdentifiers && mode !== "module";
|
const genScopeId = scopeId != null && mode === "module";
|
const isSetupInlined = !!options.inline;
|
const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;
|
if (mode === "module") {
|
genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);
|
} else {
|
genFunctionPreamble(ast, preambleContext);
|
}
|
const functionName = ssr ? `ssrRender` : `render`;
|
const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
|
if (options.bindingMetadata && !options.inline) {
|
args.push("$props", "$setup", "$data", "$options");
|
}
|
const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", ");
|
if (isSetupInlined) {
|
push(`(${signature}) => {`);
|
} else {
|
push(`function ${functionName}(${signature}) {`);
|
}
|
indent();
|
if (useWithBlock) {
|
push(`with (_ctx) {`);
|
indent();
|
if (hasHelpers) {
|
push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue`);
|
push(`
|
`);
|
newline();
|
}
|
}
|
if (ast.components.length) {
|
genAssets(ast.components, "component", context);
|
if (ast.directives.length || ast.temps > 0) {
|
newline();
|
}
|
}
|
if (ast.directives.length) {
|
genAssets(ast.directives, "directive", context);
|
if (ast.temps > 0) {
|
newline();
|
}
|
}
|
if (ast.temps > 0) {
|
push(`let `);
|
for (let i = 0; i < ast.temps; i++) {
|
push(`${i > 0 ? `, ` : ``}_temp${i}`);
|
}
|
}
|
if (ast.components.length || ast.directives.length || ast.temps) {
|
push(`
|
`);
|
newline();
|
}
|
if (!ssr) {
|
push(`return `);
|
}
|
if (ast.codegenNode) {
|
genNode(ast.codegenNode, context);
|
} else {
|
push(`null`);
|
}
|
if (useWithBlock) {
|
deindent();
|
push(`}`);
|
}
|
deindent();
|
push(`}`);
|
return {
|
ast,
|
code: context.code,
|
preamble: isSetupInlined ? preambleContext.code : ``,
|
// SourceMapGenerator does have toJSON() method but it's not in the types
|
map: context.map ? context.map.toJSON() : void 0
|
};
|
}
|
function genFunctionPreamble(ast, context) {
|
const {
|
ssr,
|
prefixIdentifiers,
|
push,
|
newline,
|
runtimeModuleName,
|
runtimeGlobalName,
|
ssrRuntimeModuleName
|
} = context;
|
const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;
|
const helpers = Array.from(ast.helpers);
|
if (helpers.length > 0) {
|
if (prefixIdentifiers) {
|
push(`const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding}
|
`);
|
} else {
|
push(`const _Vue = ${VueBinding}
|
`);
|
if (ast.hoists.length) {
|
const staticHelpers = [
|
CREATE_VNODE,
|
CREATE_ELEMENT_VNODE,
|
CREATE_COMMENT,
|
CREATE_TEXT,
|
CREATE_STATIC
|
].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
|
push(`const { ${staticHelpers} } = _Vue
|
`);
|
}
|
}
|
}
|
if (ast.ssrHelpers && ast.ssrHelpers.length) {
|
push(
|
`const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}")
|
`
|
);
|
}
|
genHoists(ast.hoists, context);
|
newline();
|
push(`return `);
|
}
|
function genModulePreamble(ast, context, genScopeId, inline) {
|
const {
|
push,
|
newline,
|
optimizeImports,
|
runtimeModuleName,
|
ssrRuntimeModuleName
|
} = context;
|
if (genScopeId && ast.hoists.length) {
|
ast.helpers.add(PUSH_SCOPE_ID);
|
ast.helpers.add(POP_SCOPE_ID);
|
}
|
if (ast.helpers.size) {
|
const helpers = Array.from(ast.helpers);
|
if (optimizeImports) {
|
push(
|
`import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
|
`
|
);
|
push(
|
`
|
// Binding optimization for webpack code-split
|
const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")}
|
`
|
);
|
} else {
|
push(
|
`import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
|
`
|
);
|
}
|
}
|
if (ast.ssrHelpers && ast.ssrHelpers.length) {
|
push(
|
`import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}"
|
`
|
);
|
}
|
if (ast.imports.length) {
|
genImports(ast.imports, context);
|
newline();
|
}
|
genHoists(ast.hoists, context);
|
newline();
|
if (!inline) {
|
push(`export `);
|
}
|
}
|
function genAssets(assets, type, { helper, push, newline, isTS }) {
|
const resolver = helper(
|
type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
|
);
|
for (let i = 0; i < assets.length; i++) {
|
let id = assets[i];
|
const maybeSelfReference = id.endsWith("__self");
|
if (maybeSelfReference) {
|
id = id.slice(0, -6);
|
}
|
push(
|
`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`
|
);
|
if (i < assets.length - 1) {
|
newline();
|
}
|
}
|
}
|
function genHoists(hoists, context) {
|
if (!hoists.length) {
|
return;
|
}
|
context.pure = true;
|
const { push, newline, helper, scopeId, mode } = context;
|
const genScopeId = scopeId != null && mode !== "function";
|
newline();
|
if (genScopeId) {
|
push(
|
`const _withScopeId = n => (${helper(
|
PUSH_SCOPE_ID
|
)}("${scopeId}"),n=n(),${helper(POP_SCOPE_ID)}(),n)`
|
);
|
newline();
|
}
|
for (let i = 0; i < hoists.length; i++) {
|
const exp = hoists[i];
|
if (exp) {
|
const needScopeIdWrapper = genScopeId && exp.type === 13;
|
push(
|
`const _hoisted_${i + 1} = ${needScopeIdWrapper ? `${PURE_ANNOTATION} _withScopeId(() => ` : ``}`
|
);
|
genNode(exp, context);
|
if (needScopeIdWrapper) {
|
push(`)`);
|
}
|
newline();
|
}
|
}
|
context.pure = false;
|
}
|
function genImports(importsOptions, context) {
|
if (!importsOptions.length) {
|
return;
|
}
|
importsOptions.forEach((imports) => {
|
context.push(`import `);
|
genNode(imports.exp, context);
|
context.push(` from '${imports.path}'`);
|
context.newline();
|
});
|
}
|
function isText(n) {
|
return isString$2(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
|
}
|
function genNodeListAsArray(nodes, context) {
|
const multilines = nodes.length > 3 || nodes.some((n) => isArray$3(n) || !isText(n));
|
context.push(`[`);
|
multilines && context.indent();
|
genNodeList(nodes, context, multilines);
|
multilines && context.deindent();
|
context.push(`]`);
|
}
|
function genNodeList(nodes, context, multilines = false, comma = true) {
|
const { push, newline } = context;
|
for (let i = 0; i < nodes.length; i++) {
|
const node = nodes[i];
|
if (isString$2(node)) {
|
push(node);
|
} else if (isArray$3(node)) {
|
genNodeListAsArray(node, context);
|
} else {
|
genNode(node, context);
|
}
|
if (i < nodes.length - 1) {
|
if (multilines) {
|
comma && push(",");
|
newline();
|
} else {
|
comma && push(", ");
|
}
|
}
|
}
|
}
|
function genNode(node, context) {
|
if (isString$2(node)) {
|
context.push(node);
|
return;
|
}
|
if (isSymbol$1(node)) {
|
context.push(context.helper(node));
|
return;
|
}
|
switch (node.type) {
|
case 1:
|
case 9:
|
case 11:
|
assert(
|
node.codegenNode != null,
|
`Codegen node is missing for element/if/for node. Apply appropriate transforms first.`
|
);
|
genNode(node.codegenNode, context);
|
break;
|
case 2:
|
genText(node, context);
|
break;
|
case 4:
|
genExpression(node, context);
|
break;
|
case 5:
|
genInterpolation(node, context);
|
break;
|
case 12:
|
genNode(node.codegenNode, context);
|
break;
|
case 8:
|
genCompoundExpression(node, context);
|
break;
|
case 3:
|
genComment(node, context);
|
break;
|
case 13:
|
genVNodeCall(node, context);
|
break;
|
case 14:
|
genCallExpression(node, context);
|
break;
|
case 15:
|
genObjectExpression(node, context);
|
break;
|
case 17:
|
genArrayExpression(node, context);
|
break;
|
case 18:
|
genFunctionExpression(node, context);
|
break;
|
case 19:
|
genConditionalExpression(node, context);
|
break;
|
case 20:
|
genCacheExpression(node, context);
|
break;
|
case 21:
|
genNodeList(node.body, context, true, false);
|
break;
|
case 22:
|
genTemplateLiteral(node, context);
|
break;
|
case 23:
|
genIfStatement(node, context);
|
break;
|
case 24:
|
genAssignmentExpression(node, context);
|
break;
|
case 25:
|
genSequenceExpression(node, context);
|
break;
|
case 26:
|
genReturnStatement(node, context);
|
break;
|
case 10:
|
break;
|
default:
|
{
|
assert(false, `unhandled codegen node type: ${node.type}`);
|
const exhaustiveCheck = node;
|
return exhaustiveCheck;
|
}
|
}
|
}
|
function genText(node, context) {
|
context.push(JSON.stringify(node.content), node);
|
}
|
function genExpression(node, context) {
|
const { content, isStatic } = node;
|
context.push(isStatic ? JSON.stringify(content) : content, node);
|
}
|
function genInterpolation(node, context) {
|
const { push, helper, pure } = context;
|
if (pure)
|
push(PURE_ANNOTATION);
|
push(`${helper(TO_DISPLAY_STRING)}(`);
|
genNode(node.content, context);
|
push(`)`);
|
}
|
function genCompoundExpression(node, context) {
|
for (let i = 0; i < node.children.length; i++) {
|
const child = node.children[i];
|
if (isString$2(child)) {
|
context.push(child);
|
} else {
|
genNode(child, context);
|
}
|
}
|
}
|
function genExpressionAsPropertyKey(node, context) {
|
const { push } = context;
|
if (node.type === 8) {
|
push(`[`);
|
genCompoundExpression(node, context);
|
push(`]`);
|
} else if (node.isStatic) {
|
const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
|
push(text, node);
|
} else {
|
push(`[${node.content}]`, node);
|
}
|
}
|
function genComment(node, context) {
|
const { push, helper, pure } = context;
|
if (pure) {
|
push(PURE_ANNOTATION);
|
}
|
push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);
|
}
|
function genVNodeCall(node, context) {
|
const { push, helper, pure } = context;
|
const {
|
tag,
|
props,
|
children,
|
patchFlag,
|
dynamicProps,
|
directives,
|
isBlock,
|
disableTracking,
|
isComponent
|
} = node;
|
if (directives) {
|
push(helper(WITH_DIRECTIVES) + `(`);
|
}
|
if (isBlock) {
|
push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
|
}
|
if (pure) {
|
push(PURE_ANNOTATION);
|
}
|
const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
|
push(helper(callHelper) + `(`, node);
|
genNodeList(
|
genNullableArgs([tag, props, children, patchFlag, dynamicProps]),
|
context
|
);
|
push(`)`);
|
if (isBlock) {
|
push(`)`);
|
}
|
if (directives) {
|
push(`, `);
|
genNode(directives, context);
|
push(`)`);
|
}
|
}
|
function genNullableArgs(args) {
|
let i = args.length;
|
while (i--) {
|
if (args[i] != null)
|
break;
|
}
|
return args.slice(0, i + 1).map((arg) => arg || `null`);
|
}
|
function genCallExpression(node, context) {
|
const { push, helper, pure } = context;
|
const callee = isString$2(node.callee) ? node.callee : helper(node.callee);
|
if (pure) {
|
push(PURE_ANNOTATION);
|
}
|
push(callee + `(`, node);
|
genNodeList(node.arguments, context);
|
push(`)`);
|
}
|
function genObjectExpression(node, context) {
|
const { push, indent, deindent, newline } = context;
|
const { properties } = node;
|
if (!properties.length) {
|
push(`{}`, node);
|
return;
|
}
|
const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
|
push(multilines ? `{` : `{ `);
|
multilines && indent();
|
for (let i = 0; i < properties.length; i++) {
|
const { key, value } = properties[i];
|
genExpressionAsPropertyKey(key, context);
|
push(`: `);
|
genNode(value, context);
|
if (i < properties.length - 1) {
|
push(`,`);
|
newline();
|
}
|
}
|
multilines && deindent();
|
push(multilines ? `}` : ` }`);
|
}
|
function genArrayExpression(node, context) {
|
genNodeListAsArray(node.elements, context);
|
}
|
function genFunctionExpression(node, context) {
|
const { push, indent, deindent } = context;
|
const { params, returns, body, newline, isSlot } = node;
|
if (isSlot) {
|
push(`_${helperNameMap[WITH_CTX]}(`);
|
}
|
push(`(`, node);
|
if (isArray$3(params)) {
|
genNodeList(params, context);
|
} else if (params) {
|
genNode(params, context);
|
}
|
push(`) => `);
|
if (newline || body) {
|
push(`{`);
|
indent();
|
}
|
if (returns) {
|
if (newline) {
|
push(`return `);
|
}
|
if (isArray$3(returns)) {
|
genNodeListAsArray(returns, context);
|
} else {
|
genNode(returns, context);
|
}
|
} else if (body) {
|
genNode(body, context);
|
}
|
if (newline || body) {
|
deindent();
|
push(`}`);
|
}
|
if (isSlot) {
|
push(`)`);
|
}
|
}
|
function genConditionalExpression(node, context) {
|
const { test, consequent, alternate, newline: needNewline } = node;
|
const { push, indent, deindent, newline } = context;
|
if (test.type === 4) {
|
const needsParens = !isSimpleIdentifier(test.content);
|
needsParens && push(`(`);
|
genExpression(test, context);
|
needsParens && push(`)`);
|
} else {
|
push(`(`);
|
genNode(test, context);
|
push(`)`);
|
}
|
needNewline && indent();
|
context.indentLevel++;
|
needNewline || push(` `);
|
push(`? `);
|
genNode(consequent, context);
|
context.indentLevel--;
|
needNewline && newline();
|
needNewline || push(` `);
|
push(`: `);
|
const isNested = alternate.type === 19;
|
if (!isNested) {
|
context.indentLevel++;
|
}
|
genNode(alternate, context);
|
if (!isNested) {
|
context.indentLevel--;
|
}
|
needNewline && deindent(
|
true
|
/* without newline */
|
);
|
}
|
function genCacheExpression(node, context) {
|
const { push, helper, indent, deindent, newline } = context;
|
push(`_cache[${node.index}] || (`);
|
if (node.isVNode) {
|
indent();
|
push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
|
newline();
|
}
|
push(`_cache[${node.index}] = `);
|
genNode(node.value, context);
|
if (node.isVNode) {
|
push(`,`);
|
newline();
|
push(`${helper(SET_BLOCK_TRACKING)}(1),`);
|
newline();
|
push(`_cache[${node.index}]`);
|
deindent();
|
}
|
push(`)`);
|
}
|
function genTemplateLiteral(node, context) {
|
const { push, indent, deindent } = context;
|
push("`");
|
const l = node.elements.length;
|
const multilines = l > 3;
|
for (let i = 0; i < l; i++) {
|
const e = node.elements[i];
|
if (isString$2(e)) {
|
push(e.replace(/(`|\$|\\)/g, "\\$1"));
|
} else {
|
push("${");
|
if (multilines)
|
indent();
|
genNode(e, context);
|
if (multilines)
|
deindent();
|
push("}");
|
}
|
}
|
push("`");
|
}
|
function genIfStatement(node, context) {
|
const { push, indent, deindent } = context;
|
const { test, consequent, alternate } = node;
|
push(`if (`);
|
genNode(test, context);
|
push(`) {`);
|
indent();
|
genNode(consequent, context);
|
deindent();
|
push(`}`);
|
if (alternate) {
|
push(` else `);
|
if (alternate.type === 23) {
|
genIfStatement(alternate, context);
|
} else {
|
push(`{`);
|
indent();
|
genNode(alternate, context);
|
deindent();
|
push(`}`);
|
}
|
}
|
}
|
function genAssignmentExpression(node, context) {
|
genNode(node.left, context);
|
context.push(` = `);
|
genNode(node.right, context);
|
}
|
function genSequenceExpression(node, context) {
|
context.push(`(`);
|
genNodeList(node.expressions, context);
|
context.push(`)`);
|
}
|
function genReturnStatement({ returns }, context) {
|
context.push(`return `);
|
if (isArray$3(returns)) {
|
genNodeListAsArray(returns, context);
|
} else {
|
genNode(returns, context);
|
}
|
}
|
|
// @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);
|
}
|
|
function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ 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") && !TS_NODE_TYPES.includes(parent.type)) {
|
return this.skip();
|
}
|
if (node.type === "Identifier") {
|
const isLocal = !!knownIds[node.name];
|
const isRefed = isReferencedIdentifier(node, parent, parentStack);
|
if (includeAll || isRefed && !isLocal) {
|
onIdentifier(node, parent, parentStack, isRefed, isLocal);
|
}
|
} else if (node.type === "ObjectProperty" && parent.type === "ObjectPattern") {
|
node.inPattern = true;
|
} else if (isFunctionType(node)) {
|
walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
|
} else if (node.type === "BlockStatement") {
|
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;
|
}
|
if (id.name === "arguments") {
|
return false;
|
}
|
if (isReferenced(id, parent)) {
|
return true;
|
}
|
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 = /* @__PURE__ */ 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;
|
const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
|
function isReferenced(node, parent, grandparent) {
|
switch (parent.type) {
|
case "MemberExpression":
|
case "OptionalMemberExpression":
|
if (parent.property === node) {
|
return !!parent.computed;
|
}
|
return parent.object === node;
|
case "JSXMemberExpression":
|
return parent.object === node;
|
case "VariableDeclarator":
|
return parent.init === node;
|
case "ArrowFunctionExpression":
|
return parent.body === node;
|
case "PrivateName":
|
return false;
|
case "ClassMethod":
|
case "ClassPrivateMethod":
|
case "ObjectMethod":
|
if (parent.key === node) {
|
return !!parent.computed;
|
}
|
return false;
|
case "ObjectProperty":
|
if (parent.key === node) {
|
return !!parent.computed;
|
}
|
return !grandparent || grandparent.type !== "ObjectPattern";
|
case "ClassProperty":
|
if (parent.key === node) {
|
return !!parent.computed;
|
}
|
return true;
|
case "ClassPrivateProperty":
|
return parent.key !== node;
|
case "ClassDeclaration":
|
case "ClassExpression":
|
return parent.superClass === node;
|
case "AssignmentExpression":
|
return parent.right === node;
|
case "AssignmentPattern":
|
return parent.right === node;
|
case "LabeledStatement":
|
return false;
|
case "CatchClause":
|
return false;
|
case "RestElement":
|
return false;
|
case "BreakStatement":
|
case "ContinueStatement":
|
return false;
|
case "FunctionDeclaration":
|
case "FunctionExpression":
|
return false;
|
case "ExportNamespaceSpecifier":
|
case "ExportDefaultSpecifier":
|
return false;
|
case "ExportSpecifier":
|
if (grandparent == null ? void 0 : grandparent.source) {
|
return false;
|
}
|
return parent.local === node;
|
case "ImportDefaultSpecifier":
|
case "ImportNamespaceSpecifier":
|
case "ImportSpecifier":
|
return false;
|
case "ImportAttribute":
|
return false;
|
case "JSXAttribute":
|
return false;
|
case "ObjectPattern":
|
case "ArrayPattern":
|
return false;
|
case "MetaProperty":
|
return false;
|
case "ObjectTypeProperty":
|
return parent.key !== node;
|
case "TSEnumMember":
|
return parent.id !== node;
|
case "TSPropertySignature":
|
if (parent.key === node) {
|
return !!parent.computed;
|
}
|
return true;
|
}
|
return true;
|
}
|
const TS_NODE_TYPES = [
|
"TSAsExpression",
|
// foo as number
|
"TSTypeAssertion",
|
// (<number>foo)
|
"TSNonNullExpression",
|
// foo!
|
"TSInstantiationExpression",
|
// foo<string>
|
"TSSatisfiesExpression"
|
// foo satisfies T
|
];
|
|
const isLiteralWhitelisted = /* @__PURE__ */ makeMap("true,false,null,this");
|
const constantBailRE = /\w\s*\(|\.[^\d]/;
|
const transformExpression = (node, context) => {
|
if (node.type === 5) {
|
node.content = processExpression(
|
node.content,
|
context
|
);
|
} else if (node.type === 1) {
|
for (let i = 0; i < node.props.length; i++) {
|
const dir = node.props[i];
|
if (dir.type === 7 && dir.name !== "for") {
|
const exp = dir.exp;
|
const arg = dir.arg;
|
if (exp && exp.type === 4 && !(dir.name === "on" && arg)) {
|
dir.exp = processExpression(
|
exp,
|
context,
|
// slot args must be processed as function params
|
dir.name === "slot"
|
);
|
}
|
if (arg && arg.type === 4 && !arg.isStatic) {
|
dir.arg = processExpression(arg, context);
|
}
|
}
|
}
|
}
|
};
|
function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
|
if (!context.prefixIdentifiers || !node.content.trim()) {
|
return node;
|
}
|
const { inline, bindingMetadata } = context;
|
const rewriteIdentifier = (raw, parent, id) => {
|
const type = hasOwn(bindingMetadata, raw) && bindingMetadata[raw];
|
if (inline) {
|
const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
|
const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
|
const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);
|
if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) {
|
return raw;
|
} else if (type === "setup-ref") {
|
return `${raw}.value`;
|
} else if (type === "setup-maybe-ref") {
|
return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : `${context.helperString(UNREF)}(${raw})`;
|
} else if (type === "setup-let") {
|
if (isAssignmentLVal) {
|
const { right: rVal, operator } = parent;
|
const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);
|
const rExpString = stringifyExpression(
|
processExpression(
|
createSimpleExpression(rExp, false),
|
context,
|
false,
|
false,
|
knownIds
|
)
|
);
|
return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
|
` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
|
} else if (isUpdateArg) {
|
id.start = parent.start;
|
id.end = parent.end;
|
const { prefix: isPrefix, operator } = parent;
|
const prefix = isPrefix ? operator : ``;
|
const postfix = isPrefix ? `` : operator;
|
return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
|
` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;
|
} else if (isDestructureAssignment) {
|
return raw;
|
} else {
|
return `${context.helperString(UNREF)}(${raw})`;
|
}
|
} else if (type === "props") {
|
return genPropsAccessExp(raw);
|
} else if (type === "props-aliased") {
|
return genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
|
}
|
} else {
|
if (type && type.startsWith("setup") || type === "literal-const") {
|
return `$setup.${raw}`;
|
} else if (type === "props-aliased") {
|
return `$props['${bindingMetadata.__propsAliases[raw]}']`;
|
} else if (type) {
|
return `$${type}.${raw}`;
|
}
|
}
|
return `_ctx.${raw}`;
|
};
|
const rawExp = node.content;
|
const bailConstant = constantBailRE.test(rawExp);
|
if (isSimpleIdentifier(rawExp)) {
|
const isScopeVarReference = context.identifiers[rawExp];
|
const isAllowedGlobal = isGloballyWhitelisted(rawExp);
|
const isLiteral = isLiteralWhitelisted(rawExp);
|
if (!asParams && !isScopeVarReference && !isAllowedGlobal && !isLiteral) {
|
if (isConst(bindingMetadata[node.content])) {
|
node.constType = 1;
|
}
|
node.content = rewriteIdentifier(rawExp);
|
} else if (!isScopeVarReference) {
|
if (isLiteral) {
|
node.constType = 3;
|
} else {
|
node.constType = 2;
|
}
|
}
|
return node;
|
}
|
let ast;
|
const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
|
try {
|
ast = parse_1$1(source, {
|
plugins: context.expressionPlugins
|
}).program;
|
} catch (e) {
|
context.onError(
|
createCompilerError(
|
45,
|
node.loc,
|
void 0,
|
e.message
|
)
|
);
|
return node;
|
}
|
const ids = [];
|
const parentStack = [];
|
const knownIds = Object.create(context.identifiers);
|
walkIdentifiers(
|
ast,
|
(node2, parent, _, isReferenced, isLocal) => {
|
if (isStaticPropertyKey(node2, parent)) {
|
return;
|
}
|
const needPrefix = isReferenced && canPrefix(node2);
|
if (needPrefix && !isLocal) {
|
if (isStaticProperty(parent) && parent.shorthand) {
|
node2.prefix = `${node2.name}: `;
|
}
|
node2.name = rewriteIdentifier(node2.name, parent, node2);
|
ids.push(node2);
|
} else {
|
if (!(needPrefix && isLocal) && !bailConstant) {
|
node2.isConstant = true;
|
}
|
ids.push(node2);
|
}
|
},
|
true,
|
// invoke on ALL identifiers
|
parentStack,
|
knownIds
|
);
|
const children = [];
|
ids.sort((a, b) => a.start - b.start);
|
ids.forEach((id, i) => {
|
const start = id.start - 1;
|
const end = id.end - 1;
|
const last = ids[i - 1];
|
const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);
|
if (leadingText.length || id.prefix) {
|
children.push(leadingText + (id.prefix || ``));
|
}
|
const source2 = rawExp.slice(start, end);
|
children.push(
|
createSimpleExpression(
|
id.name,
|
false,
|
{
|
source: source2,
|
start: advancePositionWithClone(node.loc.start, source2, start),
|
end: advancePositionWithClone(node.loc.start, source2, end)
|
},
|
id.isConstant ? 3 : 0
|
)
|
);
|
if (i === ids.length - 1 && end < rawExp.length) {
|
children.push(rawExp.slice(end));
|
}
|
});
|
let ret;
|
if (children.length) {
|
ret = createCompoundExpression(children, node.loc);
|
} else {
|
ret = node;
|
ret.constType = bailConstant ? 0 : 3;
|
}
|
ret.identifiers = Object.keys(knownIds);
|
return ret;
|
}
|
function canPrefix(id) {
|
if (isGloballyWhitelisted(id.name)) {
|
return false;
|
}
|
if (id.name === "require") {
|
return false;
|
}
|
return true;
|
}
|
function stringifyExpression(exp) {
|
if (isString$2(exp)) {
|
return exp;
|
} else if (exp.type === 4) {
|
return exp.content;
|
} else {
|
return exp.children.map(stringifyExpression).join("");
|
}
|
}
|
function isConst(type) {
|
return type === "setup-const" || type === "literal-const";
|
}
|
|
const transformIf = createStructuralDirectiveTransform(
|
/^(if|else|else-if)$/,
|
(node, dir, context) => {
|
return processIf(node, dir, context, (ifNode, branch, isRoot) => {
|
const siblings = context.parent.children;
|
let i = siblings.indexOf(ifNode);
|
let key = 0;
|
while (i-- >= 0) {
|
const sibling = siblings[i];
|
if (sibling && sibling.type === 9) {
|
key += sibling.branches.length;
|
}
|
}
|
return () => {
|
if (isRoot) {
|
ifNode.codegenNode = createCodegenNodeForBranch(
|
branch,
|
key,
|
context
|
);
|
} else {
|
const parentCondition = getParentCondition(ifNode.codegenNode);
|
parentCondition.alternate = createCodegenNodeForBranch(
|
branch,
|
key + ifNode.branches.length - 1,
|
context
|
);
|
}
|
};
|
});
|
}
|
);
|
function processIf(node, dir, context, processCodegen) {
|
if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
|
const loc = dir.exp ? dir.exp.loc : node.loc;
|
context.onError(
|
createCompilerError(28, dir.loc)
|
);
|
dir.exp = createSimpleExpression(`true`, false, loc);
|
}
|
if (context.prefixIdentifiers && dir.exp) {
|
dir.exp = processExpression(dir.exp, context);
|
}
|
if (dir.name === "if") {
|
const branch = createIfBranch(node, dir);
|
const ifNode = {
|
type: 9,
|
loc: node.loc,
|
branches: [branch]
|
};
|
context.replaceNode(ifNode);
|
if (processCodegen) {
|
return processCodegen(ifNode, branch, true);
|
}
|
} else {
|
const siblings = context.parent.children;
|
const comments = [];
|
let i = siblings.indexOf(node);
|
while (i-- >= -1) {
|
const sibling = siblings[i];
|
if (sibling && sibling.type === 3) {
|
context.removeNode(sibling);
|
comments.unshift(sibling);
|
continue;
|
}
|
if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
|
context.removeNode(sibling);
|
continue;
|
}
|
if (sibling && sibling.type === 9) {
|
if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
|
context.onError(
|
createCompilerError(30, node.loc)
|
);
|
}
|
context.removeNode();
|
const branch = createIfBranch(node, dir);
|
if (comments.length && // #3619 ignore comments if the v-if is direct child of <transition>
|
!(context.parent && context.parent.type === 1 && isBuiltInType(context.parent.tag, "transition"))) {
|
branch.children = [...comments, ...branch.children];
|
}
|
{
|
const key = branch.userKey;
|
if (key) {
|
sibling.branches.forEach(({ userKey }) => {
|
if (isSameKey(userKey, key)) {
|
context.onError(
|
createCompilerError(
|
29,
|
branch.userKey.loc
|
)
|
);
|
}
|
});
|
}
|
}
|
sibling.branches.push(branch);
|
const onExit = processCodegen && processCodegen(sibling, branch, false);
|
traverseNode(branch, context);
|
if (onExit)
|
onExit();
|
context.currentNode = null;
|
} else {
|
context.onError(
|
createCompilerError(30, node.loc)
|
);
|
}
|
break;
|
}
|
}
|
}
|
function createIfBranch(node, dir) {
|
const isTemplateIf = node.tagType === 3;
|
return {
|
type: 10,
|
loc: node.loc,
|
condition: dir.name === "else" ? void 0 : dir.exp,
|
children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
|
userKey: findProp(node, `key`),
|
isTemplateIf
|
};
|
}
|
function createCodegenNodeForBranch(branch, keyIndex, context) {
|
if (branch.condition) {
|
return createConditionalExpression(
|
branch.condition,
|
createChildrenCodegenNode(branch, keyIndex, context),
|
// make sure to pass in asBlock: true so that the comment node call
|
// closes the current block.
|
createCallExpression(context.helper(CREATE_COMMENT), [
|
'"v-if"' ,
|
"true"
|
])
|
);
|
} else {
|
return createChildrenCodegenNode(branch, keyIndex, context);
|
}
|
}
|
function createChildrenCodegenNode(branch, keyIndex, context) {
|
const { helper } = context;
|
const keyProperty = createObjectProperty(
|
`key`,
|
createSimpleExpression(
|
`${keyIndex}`,
|
false,
|
locStub,
|
2
|
)
|
);
|
const { children } = branch;
|
const firstChild = children[0];
|
const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
|
if (needFragmentWrapper) {
|
if (children.length === 1 && firstChild.type === 11) {
|
const vnodeCall = firstChild.codegenNode;
|
injectProp(vnodeCall, keyProperty, context);
|
return vnodeCall;
|
} else {
|
let patchFlag = 64;
|
let patchFlagText = PatchFlagNames[64];
|
if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) {
|
patchFlag |= 2048;
|
patchFlagText += `, ${PatchFlagNames[2048]}`;
|
}
|
return createVNodeCall(
|
context,
|
helper(FRAGMENT),
|
createObjectExpression([keyProperty]),
|
children,
|
patchFlag + (` /* ${patchFlagText} */` ),
|
void 0,
|
void 0,
|
true,
|
false,
|
false,
|
branch.loc
|
);
|
}
|
} else {
|
const ret = firstChild.codegenNode;
|
const vnodeCall = getMemoedVNodeCall(ret);
|
if (vnodeCall.type === 13) {
|
convertToBlock(vnodeCall, context);
|
}
|
injectProp(vnodeCall, keyProperty, context);
|
return ret;
|
}
|
}
|
function isSameKey(a, b) {
|
if (!a || a.type !== b.type) {
|
return false;
|
}
|
if (a.type === 6) {
|
if (a.value.content !== b.value.content) {
|
return false;
|
}
|
} else {
|
const exp = a.exp;
|
const branchExp = b.exp;
|
if (exp.type !== branchExp.type) {
|
return false;
|
}
|
if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
|
return false;
|
}
|
}
|
return true;
|
}
|
function getParentCondition(node) {
|
while (true) {
|
if (node.type === 19) {
|
if (node.alternate.type === 19) {
|
node = node.alternate;
|
} else {
|
return node;
|
}
|
} else if (node.type === 20) {
|
node = node.value;
|
}
|
}
|
}
|
|
const transformFor = createStructuralDirectiveTransform(
|
"for",
|
(node, dir, context) => {
|
const { helper, removeHelper } = context;
|
return processFor(node, dir, context, (forNode) => {
|
const renderExp = createCallExpression(helper(RENDER_LIST), [
|
forNode.source
|
]);
|
const isTemplate = isTemplateNode(node);
|
const memo = findDir(node, "memo");
|
const keyProp = findProp(node, `key`);
|
const keyExp = keyProp && (keyProp.type === 6 ? createSimpleExpression(keyProp.value.content, true) : keyProp.exp);
|
const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null;
|
if (isTemplate) {
|
if (memo) {
|
memo.exp = processExpression(
|
memo.exp,
|
context
|
);
|
}
|
if (keyProperty && keyProp.type !== 6) {
|
keyProperty.value = processExpression(
|
keyProperty.value,
|
context
|
);
|
}
|
}
|
const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
|
const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
|
forNode.codegenNode = createVNodeCall(
|
context,
|
helper(FRAGMENT),
|
void 0,
|
renderExp,
|
fragmentFlag + (` /* ${PatchFlagNames[fragmentFlag]} */` ),
|
void 0,
|
void 0,
|
true,
|
!isStableFragment,
|
false,
|
node.loc
|
);
|
return () => {
|
let childBlock;
|
const { children } = forNode;
|
if (isTemplate) {
|
node.children.some((c) => {
|
if (c.type === 1) {
|
const key = findProp(c, "key");
|
if (key) {
|
context.onError(
|
createCompilerError(
|
33,
|
key.loc
|
)
|
);
|
return true;
|
}
|
}
|
});
|
}
|
const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
|
const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
|
if (slotOutlet) {
|
childBlock = slotOutlet.codegenNode;
|
if (isTemplate && keyProperty) {
|
injectProp(childBlock, keyProperty, context);
|
}
|
} else if (needFragmentWrapper) {
|
childBlock = createVNodeCall(
|
context,
|
helper(FRAGMENT),
|
keyProperty ? createObjectExpression([keyProperty]) : void 0,
|
node.children,
|
64 + (` /* ${PatchFlagNames[64]} */` ),
|
void 0,
|
void 0,
|
true,
|
void 0,
|
false
|
/* isComponent */
|
);
|
} else {
|
childBlock = children[0].codegenNode;
|
if (isTemplate && keyProperty) {
|
injectProp(childBlock, keyProperty, context);
|
}
|
if (childBlock.isBlock !== !isStableFragment) {
|
if (childBlock.isBlock) {
|
removeHelper(OPEN_BLOCK);
|
removeHelper(
|
getVNodeBlockHelper(context.inSSR, childBlock.isComponent)
|
);
|
} else {
|
removeHelper(
|
getVNodeHelper(context.inSSR, childBlock.isComponent)
|
);
|
}
|
}
|
childBlock.isBlock = !isStableFragment;
|
if (childBlock.isBlock) {
|
helper(OPEN_BLOCK);
|
helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
|
} else {
|
helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
|
}
|
}
|
if (memo) {
|
const loop = createFunctionExpression(
|
createForLoopParams(forNode.parseResult, [
|
createSimpleExpression(`_cached`)
|
])
|
);
|
loop.body = createBlockStatement([
|
createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
|
createCompoundExpression([
|
`if (_cached`,
|
...keyExp ? [` && _cached.key === `, keyExp] : [],
|
` && ${context.helperString(
|
IS_MEMO_SAME
|
)}(_cached, _memo)) return _cached`
|
]),
|
createCompoundExpression([`const _item = `, childBlock]),
|
createSimpleExpression(`_item.memo = _memo`),
|
createSimpleExpression(`return _item`)
|
]);
|
renderExp.arguments.push(
|
loop,
|
createSimpleExpression(`_cache`),
|
createSimpleExpression(String(context.cached++))
|
);
|
} else {
|
renderExp.arguments.push(
|
createFunctionExpression(
|
createForLoopParams(forNode.parseResult),
|
childBlock,
|
true
|
/* force newline */
|
)
|
);
|
}
|
};
|
});
|
}
|
);
|
function processFor(node, dir, context, processCodegen) {
|
if (!dir.exp) {
|
context.onError(
|
createCompilerError(31, dir.loc)
|
);
|
return;
|
}
|
const parseResult = parseForExpression(
|
// can only be simple expression because vFor transform is applied
|
// before expression transform.
|
dir.exp,
|
context
|
);
|
if (!parseResult) {
|
context.onError(
|
createCompilerError(32, dir.loc)
|
);
|
return;
|
}
|
const { addIdentifiers, removeIdentifiers, scopes } = context;
|
const { source, value, key, index } = parseResult;
|
const forNode = {
|
type: 11,
|
loc: dir.loc,
|
source,
|
valueAlias: value,
|
keyAlias: key,
|
objectIndexAlias: index,
|
parseResult,
|
children: isTemplateNode(node) ? node.children : [node]
|
};
|
context.replaceNode(forNode);
|
scopes.vFor++;
|
if (context.prefixIdentifiers) {
|
value && addIdentifiers(value);
|
key && addIdentifiers(key);
|
index && addIdentifiers(index);
|
}
|
const onExit = processCodegen && processCodegen(forNode);
|
return () => {
|
scopes.vFor--;
|
if (context.prefixIdentifiers) {
|
value && removeIdentifiers(value);
|
key && removeIdentifiers(key);
|
index && removeIdentifiers(index);
|
}
|
if (onExit)
|
onExit();
|
};
|
}
|
const forAliasRE$1 = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
|
const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
|
const stripParensRE = /^\(|\)$/g;
|
function parseForExpression(input, context) {
|
const loc = input.loc;
|
const exp = input.content;
|
const inMatch = exp.match(forAliasRE$1);
|
if (!inMatch)
|
return;
|
const [, LHS, RHS] = inMatch;
|
const result = {
|
source: createAliasExpression(
|
loc,
|
RHS.trim(),
|
exp.indexOf(RHS, LHS.length)
|
),
|
value: void 0,
|
key: void 0,
|
index: void 0
|
};
|
if (context.prefixIdentifiers) {
|
result.source = processExpression(
|
result.source,
|
context
|
);
|
}
|
let valueContent = LHS.trim().replace(stripParensRE, "").trim();
|
const trimmedOffset = LHS.indexOf(valueContent);
|
const iteratorMatch = valueContent.match(forIteratorRE);
|
if (iteratorMatch) {
|
valueContent = valueContent.replace(forIteratorRE, "").trim();
|
const keyContent = iteratorMatch[1].trim();
|
let keyOffset;
|
if (keyContent) {
|
keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
|
result.key = createAliasExpression(loc, keyContent, keyOffset);
|
if (context.prefixIdentifiers) {
|
result.key = processExpression(result.key, context, true);
|
}
|
}
|
if (iteratorMatch[2]) {
|
const indexContent = iteratorMatch[2].trim();
|
if (indexContent) {
|
result.index = createAliasExpression(
|
loc,
|
indexContent,
|
exp.indexOf(
|
indexContent,
|
result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
|
)
|
);
|
if (context.prefixIdentifiers) {
|
result.index = processExpression(result.index, context, true);
|
}
|
}
|
}
|
}
|
if (valueContent) {
|
result.value = createAliasExpression(loc, valueContent, trimmedOffset);
|
if (context.prefixIdentifiers) {
|
result.value = processExpression(result.value, context, true);
|
}
|
}
|
return result;
|
}
|
function createAliasExpression(range, content, offset) {
|
return createSimpleExpression(
|
content,
|
false,
|
getInnerRange(range, offset, content.length)
|
);
|
}
|
function createForLoopParams({ value, key, index }, memoArgs = []) {
|
return createParamsList([value, key, index, ...memoArgs]);
|
}
|
function createParamsList(args) {
|
let i = args.length;
|
while (i--) {
|
if (args[i])
|
break;
|
}
|
return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
|
}
|
|
const defaultFallback = createSimpleExpression(`undefined`, false);
|
const trackSlotScopes = (node, context) => {
|
if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
|
const vSlot = findDir(node, "slot");
|
if (vSlot) {
|
const slotProps = vSlot.exp;
|
if (context.prefixIdentifiers) {
|
slotProps && context.addIdentifiers(slotProps);
|
}
|
context.scopes.vSlot++;
|
return () => {
|
if (context.prefixIdentifiers) {
|
slotProps && context.removeIdentifiers(slotProps);
|
}
|
context.scopes.vSlot--;
|
};
|
}
|
}
|
};
|
const trackVForSlotScopes = (node, context) => {
|
let vFor;
|
if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
|
const result = vFor.parseResult = parseForExpression(
|
vFor.exp,
|
context
|
);
|
if (result) {
|
const { value, key, index } = result;
|
const { addIdentifiers, removeIdentifiers } = context;
|
value && addIdentifiers(value);
|
key && addIdentifiers(key);
|
index && addIdentifiers(index);
|
return () => {
|
value && removeIdentifiers(value);
|
key && removeIdentifiers(key);
|
index && removeIdentifiers(index);
|
};
|
}
|
}
|
};
|
const buildClientSlotFn = (props, children, loc) => createFunctionExpression(
|
props,
|
children,
|
false,
|
true,
|
children.length ? children[0].loc : loc
|
);
|
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
|
context.helper(WITH_CTX);
|
const { children, loc } = node;
|
const slotsProperties = [];
|
const dynamicSlots = [];
|
let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
|
if (!context.ssr && context.prefixIdentifiers) {
|
hasDynamicSlots = hasScopeRef(node, context.identifiers);
|
}
|
const onComponentSlot = findDir(node, "slot", true);
|
if (onComponentSlot) {
|
const { arg, exp } = onComponentSlot;
|
if (arg && !isStaticExp(arg)) {
|
hasDynamicSlots = true;
|
}
|
slotsProperties.push(
|
createObjectProperty(
|
arg || createSimpleExpression("default", true),
|
buildSlotFn(exp, children, loc)
|
)
|
);
|
}
|
let hasTemplateSlots = false;
|
let hasNamedDefaultSlot = false;
|
const implicitDefaultChildren = [];
|
const seenSlotNames = /* @__PURE__ */ new Set();
|
let conditionalBranchIndex = 0;
|
for (let i = 0; i < children.length; i++) {
|
const slotElement = children[i];
|
let slotDir;
|
if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
|
if (slotElement.type !== 3) {
|
implicitDefaultChildren.push(slotElement);
|
}
|
continue;
|
}
|
if (onComponentSlot) {
|
context.onError(
|
createCompilerError(37, slotDir.loc)
|
);
|
break;
|
}
|
hasTemplateSlots = true;
|
const { children: slotChildren, loc: slotLoc } = slotElement;
|
const {
|
arg: slotName = createSimpleExpression(`default`, true),
|
exp: slotProps,
|
loc: dirLoc
|
} = slotDir;
|
let staticSlotName;
|
if (isStaticExp(slotName)) {
|
staticSlotName = slotName ? slotName.content : `default`;
|
} else {
|
hasDynamicSlots = true;
|
}
|
const slotFunction = buildSlotFn(slotProps, slotChildren, slotLoc);
|
let vIf;
|
let vElse;
|
let vFor;
|
if (vIf = findDir(slotElement, "if")) {
|
hasDynamicSlots = true;
|
dynamicSlots.push(
|
createConditionalExpression(
|
vIf.exp,
|
buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
|
defaultFallback
|
)
|
);
|
} else if (vElse = findDir(
|
slotElement,
|
/^else(-if)?$/,
|
true
|
/* allowEmpty */
|
)) {
|
let j = i;
|
let prev;
|
while (j--) {
|
prev = children[j];
|
if (prev.type !== 3) {
|
break;
|
}
|
}
|
if (prev && isTemplateNode(prev) && findDir(prev, "if")) {
|
children.splice(i, 1);
|
i--;
|
let conditional = dynamicSlots[dynamicSlots.length - 1];
|
while (conditional.alternate.type === 19) {
|
conditional = conditional.alternate;
|
}
|
conditional.alternate = vElse.exp ? createConditionalExpression(
|
vElse.exp,
|
buildDynamicSlot(
|
slotName,
|
slotFunction,
|
conditionalBranchIndex++
|
),
|
defaultFallback
|
) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
|
} else {
|
context.onError(
|
createCompilerError(30, vElse.loc)
|
);
|
}
|
} else if (vFor = findDir(slotElement, "for")) {
|
hasDynamicSlots = true;
|
const parseResult = vFor.parseResult || parseForExpression(vFor.exp, context);
|
if (parseResult) {
|
dynamicSlots.push(
|
createCallExpression(context.helper(RENDER_LIST), [
|
parseResult.source,
|
createFunctionExpression(
|
createForLoopParams(parseResult),
|
buildDynamicSlot(slotName, slotFunction),
|
true
|
/* force newline */
|
)
|
])
|
);
|
} else {
|
context.onError(
|
createCompilerError(32, vFor.loc)
|
);
|
}
|
} else {
|
if (staticSlotName) {
|
if (seenSlotNames.has(staticSlotName)) {
|
context.onError(
|
createCompilerError(
|
38,
|
dirLoc
|
)
|
);
|
continue;
|
}
|
seenSlotNames.add(staticSlotName);
|
if (staticSlotName === "default") {
|
hasNamedDefaultSlot = true;
|
}
|
}
|
slotsProperties.push(createObjectProperty(slotName, slotFunction));
|
}
|
}
|
if (!onComponentSlot) {
|
const buildDefaultSlotProperty = (props, children2) => {
|
const fn = buildSlotFn(props, children2, loc);
|
return createObjectProperty(`default`, fn);
|
};
|
if (!hasTemplateSlots) {
|
slotsProperties.push(buildDefaultSlotProperty(void 0, children));
|
} else if (implicitDefaultChildren.length && // #3766
|
// with whitespace: 'preserve', whitespaces between slots will end up in
|
// implicitDefaultChildren. Ignore if all implicit children are whitespaces.
|
implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
|
if (hasNamedDefaultSlot) {
|
context.onError(
|
createCompilerError(
|
39,
|
implicitDefaultChildren[0].loc
|
)
|
);
|
} else {
|
slotsProperties.push(
|
buildDefaultSlotProperty(void 0, implicitDefaultChildren)
|
);
|
}
|
}
|
}
|
const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
|
let slots = createObjectExpression(
|
slotsProperties.concat(
|
createObjectProperty(
|
`_`,
|
// 2 = compiled but dynamic = can skip normalization, but must run diff
|
// 1 = compiled and static = can skip normalization AND diff as optimized
|
createSimpleExpression(
|
slotFlag + (` /* ${slotFlagsText[slotFlag]} */` ),
|
false
|
)
|
)
|
),
|
loc
|
);
|
if (dynamicSlots.length) {
|
slots = createCallExpression(context.helper(CREATE_SLOTS), [
|
slots,
|
createArrayExpression(dynamicSlots)
|
]);
|
}
|
return {
|
slots,
|
hasDynamicSlots
|
};
|
}
|
function buildDynamicSlot(name, fn, index) {
|
const props = [
|
createObjectProperty(`name`, name),
|
createObjectProperty(`fn`, fn)
|
];
|
if (index != null) {
|
props.push(
|
createObjectProperty(`key`, createSimpleExpression(String(index), true))
|
);
|
}
|
return createObjectExpression(props);
|
}
|
function hasForwardedSlots(children) {
|
for (let i = 0; i < children.length; i++) {
|
const child = children[i];
|
switch (child.type) {
|
case 1:
|
if (child.tagType === 2 || hasForwardedSlots(child.children)) {
|
return true;
|
}
|
break;
|
case 9:
|
if (hasForwardedSlots(child.branches))
|
return true;
|
break;
|
case 10:
|
case 11:
|
if (hasForwardedSlots(child.children))
|
return true;
|
break;
|
}
|
}
|
return false;
|
}
|
function isNonWhitespaceContent(node) {
|
if (node.type !== 2 && node.type !== 12)
|
return true;
|
return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
|
}
|
|
const directiveImportMap = /* @__PURE__ */ new WeakMap();
|
const transformElement = (node, context) => {
|
return function postTransformElement() {
|
node = context.currentNode;
|
if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
|
return;
|
}
|
const { tag, props } = node;
|
const isComponent = node.tagType === 1;
|
let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
|
const isDynamicComponent = isObject$2(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
|
let vnodeProps;
|
let vnodeChildren;
|
let vnodePatchFlag;
|
let patchFlag = 0;
|
let vnodeDynamicProps;
|
let dynamicPropNames;
|
let vnodeDirectives;
|
let shouldUseBlock = (
|
// dynamic component may resolve to plain elements
|
isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
|
// updates inside get proper isSVG flag at runtime. (#639, #643)
|
// This is technically web-specific, but splitting the logic out of core
|
// leads to too much unnecessary complexity.
|
(tag === "svg" || tag === "foreignObject")
|
);
|
if (props.length > 0) {
|
const propsBuildResult = buildProps(
|
node,
|
context,
|
void 0,
|
isComponent,
|
isDynamicComponent
|
);
|
vnodeProps = propsBuildResult.props;
|
patchFlag = propsBuildResult.patchFlag;
|
dynamicPropNames = propsBuildResult.dynamicPropNames;
|
const directives = propsBuildResult.directives;
|
vnodeDirectives = directives && directives.length ? createArrayExpression(
|
directives.map((dir) => buildDirectiveArgs(dir, context))
|
) : void 0;
|
if (propsBuildResult.shouldUseBlock) {
|
shouldUseBlock = true;
|
}
|
}
|
if (node.children.length > 0) {
|
if (vnodeTag === KEEP_ALIVE) {
|
shouldUseBlock = true;
|
patchFlag |= 1024;
|
if (node.children.length > 1) {
|
context.onError(
|
createCompilerError(46, {
|
start: node.children[0].loc.start,
|
end: node.children[node.children.length - 1].loc.end,
|
source: ""
|
})
|
);
|
}
|
}
|
const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling
|
vnodeTag !== TELEPORT && // explained above.
|
vnodeTag !== KEEP_ALIVE;
|
if (shouldBuildAsSlots) {
|
const { slots, hasDynamicSlots } = buildSlots(node, context);
|
vnodeChildren = slots;
|
if (hasDynamicSlots) {
|
patchFlag |= 1024;
|
}
|
} else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
|
const child = node.children[0];
|
const type = child.type;
|
const hasDynamicTextChild = type === 5 || type === 8;
|
if (hasDynamicTextChild && getConstantType(child, context) === 0) {
|
patchFlag |= 1;
|
}
|
if (hasDynamicTextChild || type === 2) {
|
vnodeChildren = child;
|
} else {
|
vnodeChildren = node.children;
|
}
|
} else {
|
vnodeChildren = node.children;
|
}
|
}
|
if (patchFlag !== 0) {
|
{
|
if (patchFlag < 0) {
|
vnodePatchFlag = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;
|
} else {
|
const flagNames = Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `);
|
vnodePatchFlag = patchFlag + ` /* ${flagNames} */`;
|
}
|
}
|
if (dynamicPropNames && dynamicPropNames.length) {
|
vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
|
}
|
}
|
node.codegenNode = createVNodeCall(
|
context,
|
vnodeTag,
|
vnodeProps,
|
vnodeChildren,
|
vnodePatchFlag,
|
vnodeDynamicProps,
|
vnodeDirectives,
|
!!shouldUseBlock,
|
false,
|
isComponent,
|
node.loc
|
);
|
};
|
};
|
function resolveComponentType(node, context, ssr = false) {
|
let { tag } = node;
|
const isExplicitDynamic = isComponentTag(tag);
|
const isProp = findProp(node, "is");
|
if (isProp) {
|
if (isExplicitDynamic || false) {
|
const exp = isProp.type === 6 ? isProp.value && createSimpleExpression(isProp.value.content, true) : isProp.exp;
|
if (exp) {
|
return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
|
exp
|
]);
|
}
|
} else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
|
tag = isProp.value.content.slice(4);
|
}
|
}
|
const isDir = !isExplicitDynamic && findDir(node, "is");
|
if (isDir && isDir.exp) {
|
{
|
context.onWarn(
|
createCompilerError(52, isDir.loc)
|
);
|
}
|
return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
|
isDir.exp
|
]);
|
}
|
const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
|
if (builtIn) {
|
if (!ssr)
|
context.helper(builtIn);
|
return builtIn;
|
}
|
{
|
const fromSetup = resolveSetupReference(tag, context);
|
if (fromSetup) {
|
return fromSetup;
|
}
|
const dotIndex = tag.indexOf(".");
|
if (dotIndex > 0) {
|
const ns = resolveSetupReference(tag.slice(0, dotIndex), context);
|
if (ns) {
|
return ns + tag.slice(dotIndex);
|
}
|
}
|
}
|
if (context.selfName && capitalize$1(camelize(tag)) === context.selfName) {
|
context.helper(RESOLVE_COMPONENT);
|
context.components.add(tag + `__self`);
|
return toValidAssetId(tag, `component`);
|
}
|
context.helper(RESOLVE_COMPONENT);
|
context.components.add(tag);
|
return toValidAssetId(tag, `component`);
|
}
|
function resolveSetupReference(name, context) {
|
const bindings = context.bindingMetadata;
|
if (!bindings || bindings.__isScriptSetup === false) {
|
return;
|
}
|
const camelName = camelize(name);
|
const PascalName = capitalize$1(camelName);
|
const checkType = (type) => {
|
if (bindings[name] === type) {
|
return name;
|
}
|
if (bindings[camelName] === type) {
|
return camelName;
|
}
|
if (bindings[PascalName] === type) {
|
return PascalName;
|
}
|
};
|
const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const");
|
if (fromConst) {
|
return context.inline ? (
|
// in inline mode, const setup bindings (e.g. imports) can be used as-is
|
fromConst
|
) : `$setup[${JSON.stringify(fromConst)}]`;
|
}
|
const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref");
|
if (fromMaybeRef) {
|
return context.inline ? (
|
// setup scope bindings that may be refs need to be unrefed
|
`${context.helperString(UNREF)}(${fromMaybeRef})`
|
) : `$setup[${JSON.stringify(fromMaybeRef)}]`;
|
}
|
}
|
function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
|
const { tag, loc: elementLoc, children } = node;
|
let properties = [];
|
const mergeArgs = [];
|
const runtimeDirectives = [];
|
const hasChildren = children.length > 0;
|
let shouldUseBlock = false;
|
let patchFlag = 0;
|
let hasRef = false;
|
let hasClassBinding = false;
|
let hasStyleBinding = false;
|
let hasHydrationEventBinding = false;
|
let hasDynamicKeys = false;
|
let hasVnodeHook = false;
|
const dynamicPropNames = [];
|
const pushMergeArg = (arg) => {
|
if (properties.length) {
|
mergeArgs.push(
|
createObjectExpression(dedupeProperties(properties), elementLoc)
|
);
|
properties = [];
|
}
|
if (arg)
|
mergeArgs.push(arg);
|
};
|
const analyzePatchFlag = ({ key, value }) => {
|
if (isStaticExp(key)) {
|
const name = key.content;
|
const isEventHandler = isOn(name);
|
if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click
|
// dedicated fast path.
|
name.toLowerCase() !== "onclick" && // omit v-model handlers
|
name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks
|
!isReservedProp(name)) {
|
hasHydrationEventBinding = true;
|
}
|
if (isEventHandler && isReservedProp(name)) {
|
hasVnodeHook = true;
|
}
|
if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
|
return;
|
}
|
if (name === "ref") {
|
hasRef = true;
|
} else if (name === "class") {
|
hasClassBinding = true;
|
} else if (name === "style") {
|
hasStyleBinding = true;
|
} else if (name !== "key" && !dynamicPropNames.includes(name)) {
|
dynamicPropNames.push(name);
|
}
|
if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
|
dynamicPropNames.push(name);
|
}
|
} else {
|
hasDynamicKeys = true;
|
}
|
};
|
for (let i = 0; i < props.length; i++) {
|
const prop = props[i];
|
if (prop.type === 6) {
|
const { loc, name, value } = prop;
|
let isStatic = true;
|
if (name === "ref") {
|
hasRef = true;
|
if (context.scopes.vFor > 0) {
|
properties.push(
|
createObjectProperty(
|
createSimpleExpression("ref_for", true),
|
createSimpleExpression("true")
|
)
|
);
|
}
|
if (value && context.inline) {
|
const binding = context.bindingMetadata[value.content];
|
if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") {
|
isStatic = false;
|
properties.push(
|
createObjectProperty(
|
createSimpleExpression("ref_key", true),
|
createSimpleExpression(value.content, true, value.loc)
|
)
|
);
|
}
|
}
|
}
|
if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || false)) {
|
continue;
|
}
|
properties.push(
|
createObjectProperty(
|
createSimpleExpression(
|
name,
|
true,
|
getInnerRange(loc, 0, name.length)
|
),
|
createSimpleExpression(
|
value ? value.content : "",
|
isStatic,
|
value ? value.loc : loc
|
)
|
)
|
);
|
} else {
|
const { name, arg, exp, loc } = prop;
|
const isVBind = name === "bind";
|
const isVOn = name === "on";
|
if (name === "slot") {
|
if (!isComponent) {
|
context.onError(
|
createCompilerError(40, loc)
|
);
|
}
|
continue;
|
}
|
if (name === "once" || name === "memo") {
|
continue;
|
}
|
if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || false)) {
|
continue;
|
}
|
if (isVOn && ssr) {
|
continue;
|
}
|
if (
|
// #938: elements with dynamic keys should be forced into blocks
|
isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
|
// before children
|
isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
|
) {
|
shouldUseBlock = true;
|
}
|
if (isVBind && isStaticArgOf(arg, "ref") && context.scopes.vFor > 0) {
|
properties.push(
|
createObjectProperty(
|
createSimpleExpression("ref_for", true),
|
createSimpleExpression("true")
|
)
|
);
|
}
|
if (!arg && (isVBind || isVOn)) {
|
hasDynamicKeys = true;
|
if (exp) {
|
if (isVBind) {
|
pushMergeArg();
|
mergeArgs.push(exp);
|
} else {
|
pushMergeArg({
|
type: 14,
|
loc,
|
callee: context.helper(TO_HANDLERS),
|
arguments: isComponent ? [exp] : [exp, `true`]
|
});
|
}
|
} else {
|
context.onError(
|
createCompilerError(
|
isVBind ? 34 : 35,
|
loc
|
)
|
);
|
}
|
continue;
|
}
|
const directiveTransform = context.directiveTransforms[name];
|
if (directiveTransform) {
|
const { props: props2, needRuntime } = directiveTransform(prop, node, context);
|
!ssr && props2.forEach(analyzePatchFlag);
|
if (isVOn && arg && !isStaticExp(arg)) {
|
pushMergeArg(createObjectExpression(props2, elementLoc));
|
} else {
|
properties.push(...props2);
|
}
|
if (needRuntime) {
|
runtimeDirectives.push(prop);
|
if (isSymbol$1(needRuntime)) {
|
directiveImportMap.set(prop, needRuntime);
|
}
|
}
|
} else if (!isBuiltInDirective(name)) {
|
runtimeDirectives.push(prop);
|
if (hasChildren) {
|
shouldUseBlock = true;
|
}
|
}
|
}
|
}
|
let propsExpression = void 0;
|
if (mergeArgs.length) {
|
pushMergeArg();
|
if (mergeArgs.length > 1) {
|
propsExpression = createCallExpression(
|
context.helper(MERGE_PROPS),
|
mergeArgs,
|
elementLoc
|
);
|
} else {
|
propsExpression = mergeArgs[0];
|
}
|
} else if (properties.length) {
|
propsExpression = createObjectExpression(
|
dedupeProperties(properties),
|
elementLoc
|
);
|
}
|
if (hasDynamicKeys) {
|
patchFlag |= 16;
|
} else {
|
if (hasClassBinding && !isComponent) {
|
patchFlag |= 2;
|
}
|
if (hasStyleBinding && !isComponent) {
|
patchFlag |= 4;
|
}
|
if (dynamicPropNames.length) {
|
patchFlag |= 8;
|
}
|
if (hasHydrationEventBinding) {
|
patchFlag |= 32;
|
}
|
}
|
if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
|
patchFlag |= 512;
|
}
|
if (!context.inSSR && propsExpression) {
|
switch (propsExpression.type) {
|
case 15:
|
let classKeyIndex = -1;
|
let styleKeyIndex = -1;
|
let hasDynamicKey = false;
|
for (let i = 0; i < propsExpression.properties.length; i++) {
|
const key = propsExpression.properties[i].key;
|
if (isStaticExp(key)) {
|
if (key.content === "class") {
|
classKeyIndex = i;
|
} else if (key.content === "style") {
|
styleKeyIndex = i;
|
}
|
} else if (!key.isHandlerKey) {
|
hasDynamicKey = true;
|
}
|
}
|
const classProp = propsExpression.properties[classKeyIndex];
|
const styleProp = propsExpression.properties[styleKeyIndex];
|
if (!hasDynamicKey) {
|
if (classProp && !isStaticExp(classProp.value)) {
|
classProp.value = createCallExpression(
|
context.helper(NORMALIZE_CLASS),
|
[classProp.value]
|
);
|
}
|
if (styleProp && // the static style is compiled into an object,
|
// so use `hasStyleBinding` to ensure that it is a dynamic style binding
|
(hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,
|
// v-bind:style with static literal object
|
styleProp.value.type === 17)) {
|
styleProp.value = createCallExpression(
|
context.helper(NORMALIZE_STYLE),
|
[styleProp.value]
|
);
|
}
|
} else {
|
propsExpression = createCallExpression(
|
context.helper(NORMALIZE_PROPS),
|
[propsExpression]
|
);
|
}
|
break;
|
case 14:
|
break;
|
default:
|
propsExpression = createCallExpression(
|
context.helper(NORMALIZE_PROPS),
|
[
|
createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
|
propsExpression
|
])
|
]
|
);
|
break;
|
}
|
}
|
return {
|
props: propsExpression,
|
directives: runtimeDirectives,
|
patchFlag,
|
dynamicPropNames,
|
shouldUseBlock
|
};
|
}
|
function dedupeProperties(properties) {
|
const knownProps = /* @__PURE__ */ new Map();
|
const deduped = [];
|
for (let i = 0; i < properties.length; i++) {
|
const prop = properties[i];
|
if (prop.key.type === 8 || !prop.key.isStatic) {
|
deduped.push(prop);
|
continue;
|
}
|
const name = prop.key.content;
|
const existing = knownProps.get(name);
|
if (existing) {
|
if (name === "style" || name === "class" || isOn(name)) {
|
mergeAsArray(existing, prop);
|
}
|
} else {
|
knownProps.set(name, prop);
|
deduped.push(prop);
|
}
|
}
|
return deduped;
|
}
|
function mergeAsArray(existing, incoming) {
|
if (existing.value.type === 17) {
|
existing.value.elements.push(incoming.value);
|
} else {
|
existing.value = createArrayExpression(
|
[existing.value, incoming.value],
|
existing.loc
|
);
|
}
|
}
|
function buildDirectiveArgs(dir, context) {
|
const dirArgs = [];
|
const runtime = directiveImportMap.get(dir);
|
if (runtime) {
|
dirArgs.push(context.helperString(runtime));
|
} else {
|
const fromSetup = resolveSetupReference("v-" + dir.name, context);
|
if (fromSetup) {
|
dirArgs.push(fromSetup);
|
} else {
|
context.helper(RESOLVE_DIRECTIVE);
|
context.directives.add(dir.name);
|
dirArgs.push(toValidAssetId(dir.name, `directive`));
|
}
|
}
|
const { loc } = dir;
|
if (dir.exp)
|
dirArgs.push(dir.exp);
|
if (dir.arg) {
|
if (!dir.exp) {
|
dirArgs.push(`void 0`);
|
}
|
dirArgs.push(dir.arg);
|
}
|
if (Object.keys(dir.modifiers).length) {
|
if (!dir.arg) {
|
if (!dir.exp) {
|
dirArgs.push(`void 0`);
|
}
|
dirArgs.push(`void 0`);
|
}
|
const trueExpression = createSimpleExpression(`true`, false, loc);
|
dirArgs.push(
|
createObjectExpression(
|
dir.modifiers.map(
|
(modifier) => createObjectProperty(modifier, trueExpression)
|
),
|
loc
|
)
|
);
|
}
|
return createArrayExpression(dirArgs, dir.loc);
|
}
|
function stringifyDynamicPropNames(props) {
|
let propsNamesString = `[`;
|
for (let i = 0, l = props.length; i < l; i++) {
|
propsNamesString += JSON.stringify(props[i]);
|
if (i < l - 1)
|
propsNamesString += ", ";
|
}
|
return propsNamesString + `]`;
|
}
|
function isComponentTag(tag) {
|
return tag === "component" || tag === "Component";
|
}
|
|
const transformSlotOutlet = (node, context) => {
|
if (isSlotOutlet(node)) {
|
const { children, loc } = node;
|
const { slotName, slotProps } = processSlotOutlet(node, context);
|
const slotArgs = [
|
context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
|
slotName,
|
"{}",
|
"undefined",
|
"true"
|
];
|
let expectedLen = 2;
|
if (slotProps) {
|
slotArgs[2] = slotProps;
|
expectedLen = 3;
|
}
|
if (children.length) {
|
slotArgs[3] = createFunctionExpression([], children, false, false, loc);
|
expectedLen = 4;
|
}
|
if (context.scopeId && !context.slotted) {
|
expectedLen = 5;
|
}
|
slotArgs.splice(expectedLen);
|
node.codegenNode = createCallExpression(
|
context.helper(RENDER_SLOT),
|
slotArgs,
|
loc
|
);
|
}
|
};
|
function processSlotOutlet(node, context) {
|
let slotName = `"default"`;
|
let slotProps = void 0;
|
const nonNameProps = [];
|
for (let i = 0; i < node.props.length; i++) {
|
const p = node.props[i];
|
if (p.type === 6) {
|
if (p.value) {
|
if (p.name === "name") {
|
slotName = JSON.stringify(p.value.content);
|
} else {
|
p.name = camelize(p.name);
|
nonNameProps.push(p);
|
}
|
}
|
} else {
|
if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
|
if (p.exp)
|
slotName = p.exp;
|
} else {
|
if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
|
p.arg.content = camelize(p.arg.content);
|
}
|
nonNameProps.push(p);
|
}
|
}
|
}
|
if (nonNameProps.length > 0) {
|
const { props, directives } = buildProps(
|
node,
|
context,
|
nonNameProps,
|
false,
|
false
|
);
|
slotProps = props;
|
if (directives.length) {
|
context.onError(
|
createCompilerError(
|
36,
|
directives[0].loc
|
)
|
);
|
}
|
}
|
return {
|
slotName,
|
slotProps
|
};
|
}
|
|
const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
|
const transformOn$1 = (dir, node, context, augmentor) => {
|
const { loc, modifiers, arg } = dir;
|
if (!dir.exp && !modifiers.length) {
|
context.onError(createCompilerError(35, loc));
|
}
|
let eventName;
|
if (arg.type === 4) {
|
if (arg.isStatic) {
|
let rawName = arg.content;
|
if (rawName.startsWith("vnode")) {
|
context.onWarn(
|
createCompilerError(51, arg.loc)
|
);
|
}
|
if (rawName.startsWith("vue:")) {
|
rawName = `vnode-${rawName.slice(4)}`;
|
}
|
const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? (
|
// for non-element and vnode lifecycle event listeners, auto convert
|
// it to camelCase. See issue #2249
|
toHandlerKey(camelize(rawName))
|
) : (
|
// preserve case for plain element listeners that have uppercase
|
// letters, as these may be custom elements' custom events
|
`on:${rawName}`
|
);
|
eventName = createSimpleExpression(eventString, true, arg.loc);
|
} else {
|
eventName = createCompoundExpression([
|
`${context.helperString(TO_HANDLER_KEY)}(`,
|
arg,
|
`)`
|
]);
|
}
|
} else {
|
eventName = arg;
|
eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
|
eventName.children.push(`)`);
|
}
|
let exp = dir.exp;
|
if (exp && !exp.content.trim()) {
|
exp = void 0;
|
}
|
let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
|
if (exp) {
|
const isMemberExp = isMemberExpression(exp.content, context);
|
const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
|
const hasMultipleStatements = exp.content.includes(`;`);
|
if (context.prefixIdentifiers) {
|
isInlineStatement && context.addIdentifiers(`$event`);
|
exp = dir.exp = processExpression(
|
exp,
|
context,
|
false,
|
hasMultipleStatements
|
);
|
isInlineStatement && context.removeIdentifiers(`$event`);
|
shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once
|
!context.inVOnce && // runtime constants don't need to be cached
|
// (this is analyzed by compileScript in SFC <script setup>)
|
!(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component -
|
// we need to use the original function to preserve arity,
|
// e.g. <transition> relies on checking cb.length to determine
|
// transition end handling. Inline function is ok since its arity
|
// is preserved even when cached.
|
!(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot)
|
// it must be passed fresh to avoid stale values.
|
!hasScopeRef(exp, context.identifiers);
|
if (shouldCache && isMemberExp) {
|
if (exp.type === 4) {
|
exp.content = `${exp.content} && ${exp.content}(...args)`;
|
} else {
|
exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];
|
}
|
}
|
}
|
if (isInlineStatement || shouldCache && isMemberExp) {
|
exp = createCompoundExpression([
|
`${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `
|
//@ts-ignore
|
` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
|
exp,
|
hasMultipleStatements ? `}` : `)`
|
]);
|
}
|
}
|
let ret = {
|
props: [
|
createObjectProperty(
|
eventName,
|
exp || createSimpleExpression(`() => {}`, false, loc)
|
)
|
]
|
};
|
if (augmentor) {
|
ret = augmentor(ret);
|
}
|
if (shouldCache) {
|
ret.props[0].value = context.cache(ret.props[0].value);
|
}
|
ret.props.forEach((p) => p.key.isHandlerKey = true);
|
return ret;
|
};
|
|
const transformBind = (dir, _node, context) => {
|
const { exp, modifiers, loc } = dir;
|
const arg = dir.arg;
|
if (arg.type !== 4) {
|
arg.children.unshift(`(`);
|
arg.children.push(`) || ""`);
|
} else if (!arg.isStatic) {
|
arg.content = `${arg.content} || ""`;
|
}
|
if (modifiers.includes("camel")) {
|
if (arg.type === 4) {
|
if (arg.isStatic) {
|
arg.content = camelize(arg.content);
|
} else {
|
arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
|
}
|
} else {
|
arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
|
arg.children.push(`)`);
|
}
|
}
|
if (!context.inSSR) {
|
if (modifiers.includes("prop")) {
|
injectPrefix(arg, ".");
|
}
|
if (modifiers.includes("attr")) {
|
injectPrefix(arg, "^");
|
}
|
}
|
if (!exp || exp.type === 4 && !exp.content.trim()) {
|
context.onError(createCompilerError(34, loc));
|
return {
|
props: [createObjectProperty(arg, createSimpleExpression("", true, loc))]
|
};
|
}
|
return {
|
props: [createObjectProperty(arg, exp)]
|
};
|
};
|
const injectPrefix = (arg, prefix) => {
|
if (arg.type === 4) {
|
if (arg.isStatic) {
|
arg.content = prefix + arg.content;
|
} else {
|
arg.content = `\`${prefix}\${${arg.content}}\``;
|
}
|
} else {
|
arg.children.unshift(`'${prefix}' + (`);
|
arg.children.push(`)`);
|
}
|
};
|
|
const transformText = (node, context) => {
|
if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
|
return () => {
|
const children = node.children;
|
let currentContainer = void 0;
|
let hasText = false;
|
for (let i = 0; i < children.length; i++) {
|
const child = children[i];
|
if (isText$1(child)) {
|
hasText = true;
|
for (let j = i + 1; j < children.length; j++) {
|
const next = children[j];
|
if (isText$1(next)) {
|
if (!currentContainer) {
|
currentContainer = children[i] = createCompoundExpression(
|
[child],
|
child.loc
|
);
|
}
|
currentContainer.children.push(` + `, next);
|
children.splice(j, 1);
|
j--;
|
} else {
|
currentContainer = void 0;
|
break;
|
}
|
}
|
}
|
}
|
if (!hasText || // if this is a plain element with a single text child, leave it
|
// as-is since the runtime has dedicated fast path for this by directly
|
// setting textContent of the element.
|
// for component root it's always normalized anyway.
|
children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
|
// custom directives can potentially add DOM elements arbitrarily,
|
// we need to avoid setting textContent of the element at runtime
|
// to avoid accidentally overwriting the DOM elements added
|
// by the user through custom directives.
|
!node.props.find(
|
(p) => p.type === 7 && !context.directiveTransforms[p.name]
|
) && // in compat mode, <template> tags with no special directives
|
// will be rendered as a fragment so its children must be
|
// converted into vnodes.
|
true)) {
|
return;
|
}
|
for (let i = 0; i < children.length; i++) {
|
const child = children[i];
|
if (isText$1(child) || child.type === 8) {
|
const callArgs = [];
|
if (child.type !== 2 || child.content !== " ") {
|
callArgs.push(child);
|
}
|
if (!context.ssr && getConstantType(child, context) === 0) {
|
callArgs.push(
|
1 + (` /* ${PatchFlagNames[1]} */` )
|
);
|
}
|
children[i] = {
|
type: 12,
|
content: child,
|
loc: child.loc,
|
codegenNode: createCallExpression(
|
context.helper(CREATE_TEXT),
|
callArgs
|
)
|
};
|
}
|
}
|
};
|
}
|
};
|
|
const seen$1 = /* @__PURE__ */ new WeakSet();
|
const transformOnce = (node, context) => {
|
if (node.type === 1 && findDir(node, "once", true)) {
|
if (seen$1.has(node) || context.inVOnce || context.inSSR) {
|
return;
|
}
|
seen$1.add(node);
|
context.inVOnce = true;
|
context.helper(SET_BLOCK_TRACKING);
|
return () => {
|
context.inVOnce = false;
|
const cur = context.currentNode;
|
if (cur.codegenNode) {
|
cur.codegenNode = context.cache(
|
cur.codegenNode,
|
true
|
/* isVNode */
|
);
|
}
|
};
|
}
|
};
|
|
const transformModel$1 = (dir, node, context) => {
|
const { exp, arg } = dir;
|
if (!exp) {
|
context.onError(
|
createCompilerError(41, dir.loc)
|
);
|
return createTransformProps();
|
}
|
const rawExp = exp.loc.source;
|
const expString = exp.type === 4 ? exp.content : rawExp;
|
const bindingType = context.bindingMetadata[rawExp];
|
if (bindingType === "props" || bindingType === "props-aliased") {
|
context.onError(createCompilerError(44, exp.loc));
|
return createTransformProps();
|
}
|
const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
|
if (!expString.trim() || !isMemberExpression(expString, context) && !maybeRef) {
|
context.onError(
|
createCompilerError(42, exp.loc)
|
);
|
return createTransformProps();
|
}
|
if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {
|
context.onError(
|
createCompilerError(43, exp.loc)
|
);
|
return createTransformProps();
|
}
|
const propName = arg ? arg : createSimpleExpression("modelValue", true);
|
const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
|
let assignmentExp;
|
const eventArg = context.isTS ? `($event: any)` : `$event`;
|
if (maybeRef) {
|
if (bindingType === "setup-ref") {
|
assignmentExp = createCompoundExpression([
|
`${eventArg} => ((`,
|
createSimpleExpression(rawExp, false, exp.loc),
|
`).value = $event)`
|
]);
|
} else {
|
const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`;
|
assignmentExp = createCompoundExpression([
|
`${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,
|
createSimpleExpression(rawExp, false, exp.loc),
|
`).value = $event : ${altAssignment})`
|
]);
|
}
|
} else {
|
assignmentExp = createCompoundExpression([
|
`${eventArg} => ((`,
|
exp,
|
`) = $event)`
|
]);
|
}
|
const props = [
|
// modelValue: foo
|
createObjectProperty(propName, dir.exp),
|
// "onUpdate:modelValue": $event => (foo = $event)
|
createObjectProperty(eventName, assignmentExp)
|
];
|
if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) {
|
props[1].value = context.cache(props[1].value);
|
}
|
if (dir.modifiers.length && node.tagType === 1) {
|
const modifiers = dir.modifiers.map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
|
const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
|
props.push(
|
createObjectProperty(
|
modifiersKey,
|
createSimpleExpression(
|
`{ ${modifiers} }`,
|
false,
|
dir.loc,
|
2
|
)
|
)
|
);
|
}
|
return createTransformProps(props);
|
};
|
function createTransformProps(props = []) {
|
return { props };
|
}
|
|
const seen = /* @__PURE__ */ new WeakSet();
|
const transformMemo = (node, context) => {
|
if (node.type === 1) {
|
const dir = findDir(node, "memo");
|
if (!dir || seen.has(node)) {
|
return;
|
}
|
seen.add(node);
|
return () => {
|
const codegenNode = node.codegenNode || context.currentNode.codegenNode;
|
if (codegenNode && codegenNode.type === 13) {
|
if (node.tagType !== 1) {
|
convertToBlock(codegenNode, context);
|
}
|
node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
|
dir.exp,
|
createFunctionExpression(void 0, codegenNode),
|
`_cache`,
|
String(context.cached++)
|
]);
|
}
|
};
|
}
|
};
|
|
function getBaseTransformPreset(prefixIdentifiers) {
|
return [
|
[
|
transformOnce,
|
transformIf,
|
transformMemo,
|
transformFor,
|
...[],
|
...prefixIdentifiers ? [
|
// order is important
|
trackVForSlotScopes,
|
transformExpression
|
] : [],
|
transformSlotOutlet,
|
transformElement,
|
trackSlotScopes,
|
transformText
|
],
|
{
|
on: transformOn$1,
|
bind: transformBind,
|
model: transformModel$1
|
}
|
];
|
}
|
function baseCompile(template, options = {}) {
|
const onError = options.onError || defaultOnError;
|
const isModuleMode = options.mode === "module";
|
const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
|
if (!prefixIdentifiers && options.cacheHandlers) {
|
onError(createCompilerError(49));
|
}
|
if (options.scopeId && !isModuleMode) {
|
onError(createCompilerError(50));
|
}
|
const ast = isString$2(template) ? baseParse(template, options) : template;
|
const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
|
if (options.isTS) {
|
const { expressionPlugins } = options;
|
if (!expressionPlugins || !expressionPlugins.includes("typescript")) {
|
options.expressionPlugins = [...expressionPlugins || [], "typescript"];
|
}
|
}
|
transform$1(
|
ast,
|
extend({}, options, {
|
prefixIdentifiers,
|
nodeTransforms: [
|
...nodeTransforms,
|
...options.nodeTransforms || []
|
// user transforms
|
],
|
directiveTransforms: extend(
|
{},
|
directiveTransforms,
|
options.directiveTransforms || {}
|
// user transforms
|
)
|
})
|
);
|
return generate(
|
ast,
|
extend({}, options, {
|
prefixIdentifiers
|
})
|
);
|
}
|
|
const noopDirectiveTransform = () => ({ props: [] });
|
|
const V_MODEL_RADIO = Symbol(`vModelRadio` );
|
const V_MODEL_CHECKBOX = Symbol(`vModelCheckbox` );
|
const V_MODEL_TEXT = Symbol(`vModelText` );
|
const V_MODEL_SELECT = Symbol(`vModelSelect` );
|
const V_MODEL_DYNAMIC = Symbol(`vModelDynamic` );
|
const V_ON_WITH_MODIFIERS = Symbol(`vOnModifiersGuard` );
|
const V_ON_WITH_KEYS = Symbol(`vOnKeysGuard` );
|
const V_SHOW = Symbol(`vShow` );
|
const TRANSITION = Symbol(`Transition` );
|
const TRANSITION_GROUP = Symbol(`TransitionGroup` );
|
registerRuntimeHelpers({
|
[V_MODEL_RADIO]: `vModelRadio`,
|
[V_MODEL_CHECKBOX]: `vModelCheckbox`,
|
[V_MODEL_TEXT]: `vModelText`,
|
[V_MODEL_SELECT]: `vModelSelect`,
|
[V_MODEL_DYNAMIC]: `vModelDynamic`,
|
[V_ON_WITH_MODIFIERS]: `withModifiers`,
|
[V_ON_WITH_KEYS]: `withKeys`,
|
[V_SHOW]: `vShow`,
|
[TRANSITION]: `Transition`,
|
[TRANSITION_GROUP]: `TransitionGroup`
|
});
|
|
var namedCharacterReferences = {
|
GT: ">",
|
gt: ">",
|
LT: "<",
|
lt: "<",
|
"ac;": "∾",
|
"af;": "",
|
AMP: "&",
|
amp: "&",
|
"ap;": "≈",
|
"DD;": "ⅅ",
|
"dd;": "ⅆ",
|
deg: "°",
|
"ee;": "ⅇ",
|
"eg;": "⪚",
|
"el;": "⪙",
|
ETH: "Ð",
|
eth: "ð",
|
"gE;": "≧",
|
"ge;": "≥",
|
"Gg;": "⋙",
|
"gg;": "≫",
|
"gl;": "≷",
|
"GT;": ">",
|
"Gt;": "≫",
|
"gt;": ">",
|
"ic;": "",
|
"ii;": "ⅈ",
|
"Im;": "ℑ",
|
"in;": "∈",
|
"it;": "",
|
"lE;": "≦",
|
"le;": "≤",
|
"lg;": "≶",
|
"Ll;": "⋘",
|
"ll;": "≪",
|
"LT;": "<",
|
"Lt;": "≪",
|
"lt;": "<",
|
"mp;": "∓",
|
"Mu;": "Μ",
|
"mu;": "μ",
|
"ne;": "≠",
|
"ni;": "∋",
|
not: "¬",
|
"Nu;": "Ν",
|
"nu;": "ν",
|
"Or;": "⩔",
|
"or;": "∨",
|
"oS;": "Ⓢ",
|
"Pi;": "Π",
|
"pi;": "π",
|
"pm;": "±",
|
"Pr;": "⪻",
|
"pr;": "≺",
|
"Re;": "ℜ",
|
REG: "®",
|
reg: "®",
|
"rx;": "℞",
|
"Sc;": "⪼",
|
"sc;": "≻",
|
shy: "",
|
uml: "¨",
|
"wp;": "℘",
|
"wr;": "≀",
|
"Xi;": "Ξ",
|
"xi;": "ξ",
|
yen: "¥",
|
"acd;": "∿",
|
"acE;": "∾̳",
|
"Acy;": "А",
|
"acy;": "а",
|
"Afr;": "𝔄",
|
"afr;": "𝔞",
|
"AMP;": "&",
|
"amp;": "&",
|
"And;": "⩓",
|
"and;": "∧",
|
"ang;": "∠",
|
"apE;": "⩰",
|
"ape;": "≊",
|
"ast;": "*",
|
Auml: "Ä",
|
auml: "ä",
|
"Bcy;": "Б",
|
"bcy;": "б",
|
"Bfr;": "𝔅",
|
"bfr;": "𝔟",
|
"bne;": "=⃥",
|
"bot;": "⊥",
|
"Cap;": "⋒",
|
"cap;": "∩",
|
cent: "¢",
|
"Cfr;": "ℭ",
|
"cfr;": "𝔠",
|
"Chi;": "Χ",
|
"chi;": "χ",
|
"cir;": "○",
|
COPY: "©",
|
copy: "©",
|
"Cup;": "⋓",
|
"cup;": "∪",
|
"Dcy;": "Д",
|
"dcy;": "д",
|
"deg;": "°",
|
"Del;": "∇",
|
"Dfr;": "𝔇",
|
"dfr;": "𝔡",
|
"die;": "¨",
|
"div;": "÷",
|
"Dot;": "¨",
|
"dot;": "˙",
|
"Ecy;": "Э",
|
"ecy;": "э",
|
"Efr;": "𝔈",
|
"efr;": "𝔢",
|
"egs;": "⪖",
|
"ell;": "ℓ",
|
"els;": "⪕",
|
"ENG;": "Ŋ",
|
"eng;": "ŋ",
|
"Eta;": "Η",
|
"eta;": "η",
|
"ETH;": "Ð",
|
"eth;": "ð",
|
Euml: "Ë",
|
euml: "ë",
|
"Fcy;": "Ф",
|
"fcy;": "ф",
|
"Ffr;": "𝔉",
|
"ffr;": "𝔣",
|
"gap;": "⪆",
|
"Gcy;": "Г",
|
"gcy;": "г",
|
"gEl;": "⪌",
|
"gel;": "⋛",
|
"geq;": "≥",
|
"ges;": "⩾",
|
"Gfr;": "𝔊",
|
"gfr;": "𝔤",
|
"ggg;": "⋙",
|
"gla;": "⪥",
|
"glE;": "⪒",
|
"glj;": "⪤",
|
"gnE;": "≩",
|
"gne;": "⪈",
|
"Hat;": "^",
|
"Hfr;": "ℌ",
|
"hfr;": "𝔥",
|
"Icy;": "И",
|
"icy;": "и",
|
"iff;": "⇔",
|
"Ifr;": "ℑ",
|
"ifr;": "𝔦",
|
"Int;": "∬",
|
"int;": "∫",
|
Iuml: "Ï",
|
iuml: "ï",
|
"Jcy;": "Й",
|
"jcy;": "й",
|
"Jfr;": "𝔍",
|
"jfr;": "𝔧",
|
"Kcy;": "К",
|
"kcy;": "к",
|
"Kfr;": "𝔎",
|
"kfr;": "𝔨",
|
"lap;": "⪅",
|
"lat;": "⪫",
|
"Lcy;": "Л",
|
"lcy;": "л",
|
"lEg;": "⪋",
|
"leg;": "⋚",
|
"leq;": "≤",
|
"les;": "⩽",
|
"Lfr;": "𝔏",
|
"lfr;": "𝔩",
|
"lgE;": "⪑",
|
"lnE;": "≨",
|
"lne;": "⪇",
|
"loz;": "◊",
|
"lrm;": "",
|
"Lsh;": "↰",
|
"lsh;": "↰",
|
macr: "¯",
|
"Map;": "⤅",
|
"map;": "↦",
|
"Mcy;": "М",
|
"mcy;": "м",
|
"Mfr;": "𝔐",
|
"mfr;": "𝔪",
|
"mho;": "℧",
|
"mid;": "∣",
|
"nap;": "≉",
|
nbsp: " ",
|
"Ncy;": "Н",
|
"ncy;": "н",
|
"Nfr;": "𝔑",
|
"nfr;": "𝔫",
|
"ngE;": "≧̸",
|
"nge;": "≱",
|
"nGg;": "⋙̸",
|
"nGt;": "≫⃒",
|
"ngt;": "≯",
|
"nis;": "⋼",
|
"niv;": "∋",
|
"nlE;": "≦̸",
|
"nle;": "≰",
|
"nLl;": "⋘̸",
|
"nLt;": "≪⃒",
|
"nlt;": "≮",
|
"Not;": "⫬",
|
"not;": "¬",
|
"npr;": "⊀",
|
"nsc;": "⊁",
|
"num;": "#",
|
"Ocy;": "О",
|
"ocy;": "о",
|
"Ofr;": "𝔒",
|
"ofr;": "𝔬",
|
"ogt;": "⧁",
|
"ohm;": "Ω",
|
"olt;": "⧀",
|
"ord;": "⩝",
|
ordf: "ª",
|
ordm: "º",
|
"orv;": "⩛",
|
Ouml: "Ö",
|
ouml: "ö",
|
"par;": "∥",
|
para: "¶",
|
"Pcy;": "П",
|
"pcy;": "п",
|
"Pfr;": "𝔓",
|
"pfr;": "𝔭",
|
"Phi;": "Φ",
|
"phi;": "φ",
|
"piv;": "ϖ",
|
"prE;": "⪳",
|
"pre;": "⪯",
|
"Psi;": "Ψ",
|
"psi;": "ψ",
|
"Qfr;": "𝔔",
|
"qfr;": "𝔮",
|
QUOT: "\"",
|
quot: "\"",
|
"Rcy;": "Р",
|
"rcy;": "р",
|
"REG;": "®",
|
"reg;": "®",
|
"Rfr;": "ℜ",
|
"rfr;": "𝔯",
|
"Rho;": "Ρ",
|
"rho;": "ρ",
|
"rlm;": "",
|
"Rsh;": "↱",
|
"rsh;": "↱",
|
"scE;": "⪴",
|
"sce;": "⪰",
|
"Scy;": "С",
|
"scy;": "с",
|
sect: "§",
|
"Sfr;": "𝔖",
|
"sfr;": "𝔰",
|
"shy;": "",
|
"sim;": "∼",
|
"smt;": "⪪",
|
"sol;": "/",
|
"squ;": "□",
|
"Sub;": "⋐",
|
"sub;": "⊂",
|
"Sum;": "∑",
|
"sum;": "∑",
|
"Sup;": "⋑",
|
"sup;": "⊃",
|
sup1: "¹",
|
sup2: "²",
|
sup3: "³",
|
"Tab;": "\t",
|
"Tau;": "Τ",
|
"tau;": "τ",
|
"Tcy;": "Т",
|
"tcy;": "т",
|
"Tfr;": "𝔗",
|
"tfr;": "𝔱",
|
"top;": "⊤",
|
"Ucy;": "У",
|
"ucy;": "у",
|
"Ufr;": "𝔘",
|
"ufr;": "𝔲",
|
"uml;": "¨",
|
Uuml: "Ü",
|
uuml: "ü",
|
"Vcy;": "В",
|
"vcy;": "в",
|
"Vee;": "⋁",
|
"vee;": "∨",
|
"Vfr;": "𝔙",
|
"vfr;": "𝔳",
|
"Wfr;": "𝔚",
|
"wfr;": "𝔴",
|
"Xfr;": "𝔛",
|
"xfr;": "𝔵",
|
"Ycy;": "Ы",
|
"ycy;": "ы",
|
"yen;": "¥",
|
"Yfr;": "𝔜",
|
"yfr;": "𝔶",
|
yuml: "ÿ",
|
"Zcy;": "З",
|
"zcy;": "з",
|
"Zfr;": "ℨ",
|
"zfr;": "𝔷",
|
"zwj;": "",
|
Acirc: "Â",
|
acirc: "â",
|
acute: "´",
|
AElig: "Æ",
|
aelig: "æ",
|
"andd;": "⩜",
|
"andv;": "⩚",
|
"ange;": "⦤",
|
"Aopf;": "𝔸",
|
"aopf;": "𝕒",
|
"apid;": "≋",
|
"apos;": "'",
|
Aring: "Å",
|
aring: "å",
|
"Ascr;": "𝒜",
|
"ascr;": "𝒶",
|
"Auml;": "Ä",
|
"auml;": "ä",
|
"Barv;": "⫧",
|
"bbrk;": "⎵",
|
"Beta;": "Β",
|
"beta;": "β",
|
"beth;": "ℶ",
|
"bNot;": "⫭",
|
"bnot;": "⌐",
|
"Bopf;": "𝔹",
|
"bopf;": "𝕓",
|
"boxH;": "═",
|
"boxh;": "─",
|
"boxV;": "║",
|
"boxv;": "│",
|
"Bscr;": "ℬ",
|
"bscr;": "𝒷",
|
"bsim;": "∽",
|
"bsol;": "\\",
|
"bull;": "•",
|
"bump;": "≎",
|
"caps;": "∩︀",
|
"Cdot;": "Ċ",
|
"cdot;": "ċ",
|
cedil: "¸",
|
"cent;": "¢",
|
"CHcy;": "Ч",
|
"chcy;": "ч",
|
"circ;": "ˆ",
|
"cirE;": "⧃",
|
"cire;": "≗",
|
"comp;": "∁",
|
"cong;": "≅",
|
"Copf;": "ℂ",
|
"copf;": "𝕔",
|
"COPY;": "©",
|
"copy;": "©",
|
"Cscr;": "𝒞",
|
"cscr;": "𝒸",
|
"csub;": "⫏",
|
"csup;": "⫐",
|
"cups;": "∪︀",
|
"Darr;": "↡",
|
"dArr;": "⇓",
|
"darr;": "↓",
|
"dash;": "‐",
|
"dHar;": "⥥",
|
"diam;": "⋄",
|
"DJcy;": "Ђ",
|
"djcy;": "ђ",
|
"Dopf;": "𝔻",
|
"dopf;": "𝕕",
|
"Dscr;": "𝒟",
|
"dscr;": "𝒹",
|
"DScy;": "Ѕ",
|
"dscy;": "ѕ",
|
"dsol;": "⧶",
|
"dtri;": "▿",
|
"DZcy;": "Џ",
|
"dzcy;": "џ",
|
"ecir;": "≖",
|
Ecirc: "Ê",
|
ecirc: "ê",
|
"Edot;": "Ė",
|
"eDot;": "≑",
|
"edot;": "ė",
|
"emsp;": " ",
|
"ensp;": " ",
|
"Eopf;": "𝔼",
|
"eopf;": "𝕖",
|
"epar;": "⋕",
|
"epsi;": "ε",
|
"Escr;": "ℰ",
|
"escr;": "ℯ",
|
"Esim;": "⩳",
|
"esim;": "≂",
|
"Euml;": "Ë",
|
"euml;": "ë",
|
"euro;": "€",
|
"excl;": "!",
|
"flat;": "♭",
|
"fnof;": "ƒ",
|
"Fopf;": "𝔽",
|
"fopf;": "𝕗",
|
"fork;": "⋔",
|
"Fscr;": "ℱ",
|
"fscr;": "𝒻",
|
"Gdot;": "Ġ",
|
"gdot;": "ġ",
|
"geqq;": "≧",
|
"gesl;": "⋛︀",
|
"GJcy;": "Ѓ",
|
"gjcy;": "ѓ",
|
"gnap;": "⪊",
|
"gneq;": "⪈",
|
"Gopf;": "𝔾",
|
"gopf;": "𝕘",
|
"Gscr;": "𝒢",
|
"gscr;": "ℊ",
|
"gsim;": "≳",
|
"gtcc;": "⪧",
|
"gvnE;": "≩︀",
|
"half;": "½",
|
"hArr;": "⇔",
|
"harr;": "↔",
|
"hbar;": "ℏ",
|
"Hopf;": "ℍ",
|
"hopf;": "𝕙",
|
"Hscr;": "ℋ",
|
"hscr;": "𝒽",
|
Icirc: "Î",
|
icirc: "î",
|
"Idot;": "İ",
|
"IEcy;": "Е",
|
"iecy;": "е",
|
iexcl: "¡",
|
"imof;": "⊷",
|
"IOcy;": "Ё",
|
"iocy;": "ё",
|
"Iopf;": "𝕀",
|
"iopf;": "𝕚",
|
"Iota;": "Ι",
|
"iota;": "ι",
|
"Iscr;": "ℐ",
|
"iscr;": "𝒾",
|
"isin;": "∈",
|
"Iuml;": "Ï",
|
"iuml;": "ï",
|
"Jopf;": "𝕁",
|
"jopf;": "𝕛",
|
"Jscr;": "𝒥",
|
"jscr;": "𝒿",
|
"KHcy;": "Х",
|
"khcy;": "х",
|
"KJcy;": "Ќ",
|
"kjcy;": "ќ",
|
"Kopf;": "𝕂",
|
"kopf;": "𝕜",
|
"Kscr;": "𝒦",
|
"kscr;": "𝓀",
|
"Lang;": "⟪",
|
"lang;": "⟨",
|
laquo: "«",
|
"Larr;": "↞",
|
"lArr;": "⇐",
|
"larr;": "←",
|
"late;": "⪭",
|
"lcub;": "{",
|
"ldca;": "⤶",
|
"ldsh;": "↲",
|
"leqq;": "≦",
|
"lesg;": "⋚︀",
|
"lHar;": "⥢",
|
"LJcy;": "Љ",
|
"ljcy;": "љ",
|
"lnap;": "⪉",
|
"lneq;": "⪇",
|
"Lopf;": "𝕃",
|
"lopf;": "𝕝",
|
"lozf;": "⧫",
|
"lpar;": "(",
|
"Lscr;": "ℒ",
|
"lscr;": "𝓁",
|
"lsim;": "≲",
|
"lsqb;": "[",
|
"ltcc;": "⪦",
|
"ltri;": "◃",
|
"lvnE;": "≨︀",
|
"macr;": "¯",
|
"male;": "♂",
|
"malt;": "✠",
|
micro: "µ",
|
"mlcp;": "⫛",
|
"mldr;": "…",
|
"Mopf;": "𝕄",
|
"mopf;": "𝕞",
|
"Mscr;": "ℳ",
|
"mscr;": "𝓂",
|
"nang;": "∠⃒",
|
"napE;": "⩰̸",
|
"nbsp;": " ",
|
"ncap;": "⩃",
|
"ncup;": "⩂",
|
"ngeq;": "≱",
|
"nges;": "⩾̸",
|
"ngtr;": "≯",
|
"nGtv;": "≫̸",
|
"nisd;": "⋺",
|
"NJcy;": "Њ",
|
"njcy;": "њ",
|
"nldr;": "‥",
|
"nleq;": "≰",
|
"nles;": "⩽̸",
|
"nLtv;": "≪̸",
|
"nmid;": "∤",
|
"Nopf;": "ℕ",
|
"nopf;": "𝕟",
|
"npar;": "∦",
|
"npre;": "⪯̸",
|
"nsce;": "⪰̸",
|
"Nscr;": "𝒩",
|
"nscr;": "𝓃",
|
"nsim;": "≁",
|
"nsub;": "⊄",
|
"nsup;": "⊅",
|
"ntgl;": "≹",
|
"ntlg;": "≸",
|
"nvap;": "≍⃒",
|
"nvge;": "≥⃒",
|
"nvgt;": ">⃒",
|
"nvle;": "≤⃒",
|
"nvlt;": "<⃒",
|
"oast;": "⊛",
|
"ocir;": "⊚",
|
Ocirc: "Ô",
|
ocirc: "ô",
|
"odiv;": "⨸",
|
"odot;": "⊙",
|
"ogon;": "˛",
|
"oint;": "∮",
|
"omid;": "⦶",
|
"Oopf;": "𝕆",
|
"oopf;": "𝕠",
|
"opar;": "⦷",
|
"ordf;": "ª",
|
"ordm;": "º",
|
"oror;": "⩖",
|
"Oscr;": "𝒪",
|
"oscr;": "ℴ",
|
"osol;": "⊘",
|
"Ouml;": "Ö",
|
"ouml;": "ö",
|
"para;": "¶",
|
"part;": "∂",
|
"perp;": "⊥",
|
"phiv;": "ϕ",
|
"plus;": "+",
|
"Popf;": "ℙ",
|
"popf;": "𝕡",
|
pound: "£",
|
"prap;": "⪷",
|
"prec;": "≺",
|
"prnE;": "⪵",
|
"prod;": "∏",
|
"prop;": "∝",
|
"Pscr;": "𝒫",
|
"pscr;": "𝓅",
|
"qint;": "⨌",
|
"Qopf;": "ℚ",
|
"qopf;": "𝕢",
|
"Qscr;": "𝒬",
|
"qscr;": "𝓆",
|
"QUOT;": "\"",
|
"quot;": "\"",
|
"race;": "∽̱",
|
"Rang;": "⟫",
|
"rang;": "⟩",
|
raquo: "»",
|
"Rarr;": "↠",
|
"rArr;": "⇒",
|
"rarr;": "→",
|
"rcub;": "}",
|
"rdca;": "⤷",
|
"rdsh;": "↳",
|
"real;": "ℜ",
|
"rect;": "▭",
|
"rHar;": "⥤",
|
"rhov;": "ϱ",
|
"ring;": "˚",
|
"Ropf;": "ℝ",
|
"ropf;": "𝕣",
|
"rpar;": ")",
|
"Rscr;": "ℛ",
|
"rscr;": "𝓇",
|
"rsqb;": "]",
|
"rtri;": "▹",
|
"scap;": "⪸",
|
"scnE;": "⪶",
|
"sdot;": "⋅",
|
"sect;": "§",
|
"semi;": ";",
|
"sext;": "✶",
|
"SHcy;": "Ш",
|
"shcy;": "ш",
|
"sime;": "≃",
|
"simg;": "⪞",
|
"siml;": "⪝",
|
"smid;": "∣",
|
"smte;": "⪬",
|
"solb;": "⧄",
|
"Sopf;": "𝕊",
|
"sopf;": "𝕤",
|
"spar;": "∥",
|
"Sqrt;": "√",
|
"squf;": "▪",
|
"Sscr;": "𝒮",
|
"sscr;": "𝓈",
|
"Star;": "⋆",
|
"star;": "☆",
|
"subE;": "⫅",
|
"sube;": "⊆",
|
"succ;": "≻",
|
"sung;": "♪",
|
"sup1;": "¹",
|
"sup2;": "²",
|
"sup3;": "³",
|
"supE;": "⫆",
|
"supe;": "⊇",
|
szlig: "ß",
|
"tbrk;": "⎴",
|
"tdot;": "⃛",
|
THORN: "Þ",
|
thorn: "þ",
|
times: "×",
|
"tint;": "∭",
|
"toea;": "⤨",
|
"Topf;": "𝕋",
|
"topf;": "𝕥",
|
"tosa;": "⤩",
|
"trie;": "≜",
|
"Tscr;": "𝒯",
|
"tscr;": "𝓉",
|
"TScy;": "Ц",
|
"tscy;": "ц",
|
"Uarr;": "↟",
|
"uArr;": "⇑",
|
"uarr;": "↑",
|
Ucirc: "Û",
|
ucirc: "û",
|
"uHar;": "⥣",
|
"Uopf;": "𝕌",
|
"uopf;": "𝕦",
|
"Upsi;": "ϒ",
|
"upsi;": "υ",
|
"Uscr;": "𝒰",
|
"uscr;": "𝓊",
|
"utri;": "▵",
|
"Uuml;": "Ü",
|
"uuml;": "ü",
|
"vArr;": "⇕",
|
"varr;": "↕",
|
"Vbar;": "⫫",
|
"vBar;": "⫨",
|
"Vert;": "‖",
|
"vert;": "|",
|
"Vopf;": "𝕍",
|
"vopf;": "𝕧",
|
"Vscr;": "𝒱",
|
"vscr;": "𝓋",
|
"Wopf;": "𝕎",
|
"wopf;": "𝕨",
|
"Wscr;": "𝒲",
|
"wscr;": "𝓌",
|
"xcap;": "⋂",
|
"xcup;": "⋃",
|
"xmap;": "⟼",
|
"xnis;": "⋻",
|
"Xopf;": "𝕏",
|
"xopf;": "𝕩",
|
"Xscr;": "𝒳",
|
"xscr;": "𝓍",
|
"xvee;": "⋁",
|
"YAcy;": "Я",
|
"yacy;": "я",
|
"YIcy;": "Ї",
|
"yicy;": "ї",
|
"Yopf;": "𝕐",
|
"yopf;": "𝕪",
|
"Yscr;": "𝒴",
|
"yscr;": "𝓎",
|
"YUcy;": "Ю",
|
"yucy;": "ю",
|
"Yuml;": "Ÿ",
|
"yuml;": "ÿ",
|
"Zdot;": "Ż",
|
"zdot;": "ż",
|
"Zeta;": "Ζ",
|
"zeta;": "ζ",
|
"ZHcy;": "Ж",
|
"zhcy;": "ж",
|
"Zopf;": "ℤ",
|
"zopf;": "𝕫",
|
"Zscr;": "𝒵",
|
"zscr;": "𝓏",
|
"zwnj;": "",
|
Aacute: "Á",
|
aacute: "á",
|
"Acirc;": "Â",
|
"acirc;": "â",
|
"acute;": "´",
|
"AElig;": "Æ",
|
"aelig;": "æ",
|
Agrave: "À",
|
agrave: "à",
|
"aleph;": "ℵ",
|
"Alpha;": "Α",
|
"alpha;": "α",
|
"Amacr;": "Ā",
|
"amacr;": "ā",
|
"amalg;": "⨿",
|
"angle;": "∠",
|
"angrt;": "∟",
|
"angst;": "Å",
|
"Aogon;": "Ą",
|
"aogon;": "ą",
|
"Aring;": "Å",
|
"aring;": "å",
|
"asymp;": "≈",
|
Atilde: "Ã",
|
atilde: "ã",
|
"awint;": "⨑",
|
"bcong;": "≌",
|
"bdquo;": "„",
|
"bepsi;": "϶",
|
"blank;": "␣",
|
"blk12;": "▒",
|
"blk14;": "░",
|
"blk34;": "▓",
|
"block;": "█",
|
"boxDL;": "╗",
|
"boxDl;": "╖",
|
"boxdL;": "╕",
|
"boxdl;": "┐",
|
"boxDR;": "╔",
|
"boxDr;": "╓",
|
"boxdR;": "╒",
|
"boxdr;": "┌",
|
"boxHD;": "╦",
|
"boxHd;": "╤",
|
"boxhD;": "╥",
|
"boxhd;": "┬",
|
"boxHU;": "╩",
|
"boxHu;": "╧",
|
"boxhU;": "╨",
|
"boxhu;": "┴",
|
"boxUL;": "╝",
|
"boxUl;": "╜",
|
"boxuL;": "╛",
|
"boxul;": "┘",
|
"boxUR;": "╚",
|
"boxUr;": "╙",
|
"boxuR;": "╘",
|
"boxur;": "└",
|
"boxVH;": "╬",
|
"boxVh;": "╫",
|
"boxvH;": "╪",
|
"boxvh;": "┼",
|
"boxVL;": "╣",
|
"boxVl;": "╢",
|
"boxvL;": "╡",
|
"boxvl;": "┤",
|
"boxVR;": "╠",
|
"boxVr;": "╟",
|
"boxvR;": "╞",
|
"boxvr;": "├",
|
"Breve;": "˘",
|
"breve;": "˘",
|
brvbar: "¦",
|
"bsemi;": "⁏",
|
"bsime;": "⋍",
|
"bsolb;": "⧅",
|
"bumpE;": "⪮",
|
"bumpe;": "≏",
|
"caret;": "⁁",
|
"caron;": "ˇ",
|
"ccaps;": "⩍",
|
Ccedil: "Ç",
|
ccedil: "ç",
|
"Ccirc;": "Ĉ",
|
"ccirc;": "ĉ",
|
"ccups;": "⩌",
|
"cedil;": "¸",
|
"check;": "✓",
|
"clubs;": "♣",
|
"Colon;": "∷",
|
"colon;": ":",
|
"comma;": ",",
|
"crarr;": "↵",
|
"Cross;": "⨯",
|
"cross;": "✗",
|
"csube;": "⫑",
|
"csupe;": "⫒",
|
"ctdot;": "⋯",
|
"cuepr;": "⋞",
|
"cuesc;": "⋟",
|
"cupor;": "⩅",
|
curren: "¤",
|
"cuvee;": "⋎",
|
"cuwed;": "⋏",
|
"cwint;": "∱",
|
"Dashv;": "⫤",
|
"dashv;": "⊣",
|
"dblac;": "˝",
|
"ddarr;": "⇊",
|
"Delta;": "Δ",
|
"delta;": "δ",
|
"dharl;": "⇃",
|
"dharr;": "⇂",
|
"diams;": "♦",
|
"disin;": "⋲",
|
divide: "÷",
|
"doteq;": "≐",
|
"dtdot;": "⋱",
|
"dtrif;": "▾",
|
"duarr;": "⇵",
|
"duhar;": "⥯",
|
Eacute: "É",
|
eacute: "é",
|
"Ecirc;": "Ê",
|
"ecirc;": "ê",
|
"eDDot;": "⩷",
|
"efDot;": "≒",
|
Egrave: "È",
|
egrave: "è",
|
"Emacr;": "Ē",
|
"emacr;": "ē",
|
"empty;": "∅",
|
"Eogon;": "Ę",
|
"eogon;": "ę",
|
"eplus;": "⩱",
|
"epsiv;": "ϵ",
|
"eqsim;": "≂",
|
"Equal;": "⩵",
|
"equiv;": "≡",
|
"erarr;": "⥱",
|
"erDot;": "≓",
|
"esdot;": "≐",
|
"exist;": "∃",
|
"fflig;": "ff",
|
"filig;": "fi",
|
"fjlig;": "fj",
|
"fllig;": "fl",
|
"fltns;": "▱",
|
"forkv;": "⫙",
|
frac12: "½",
|
frac14: "¼",
|
frac34: "¾",
|
"frasl;": "⁄",
|
"frown;": "⌢",
|
"Gamma;": "Γ",
|
"gamma;": "γ",
|
"Gcirc;": "Ĝ",
|
"gcirc;": "ĝ",
|
"gescc;": "⪩",
|
"gimel;": "ℷ",
|
"gneqq;": "≩",
|
"gnsim;": "⋧",
|
"grave;": "`",
|
"gsime;": "⪎",
|
"gsiml;": "⪐",
|
"gtcir;": "⩺",
|
"gtdot;": "⋗",
|
"Hacek;": "ˇ",
|
"harrw;": "↭",
|
"Hcirc;": "Ĥ",
|
"hcirc;": "ĥ",
|
"hoarr;": "⇿",
|
Iacute: "Í",
|
iacute: "í",
|
"Icirc;": "Î",
|
"icirc;": "î",
|
"iexcl;": "¡",
|
Igrave: "Ì",
|
igrave: "ì",
|
"iiint;": "∭",
|
"iiota;": "℩",
|
"IJlig;": "IJ",
|
"ijlig;": "ij",
|
"Imacr;": "Ī",
|
"imacr;": "ī",
|
"image;": "ℑ",
|
"imath;": "ı",
|
"imped;": "Ƶ",
|
"infin;": "∞",
|
"Iogon;": "Į",
|
"iogon;": "į",
|
"iprod;": "⨼",
|
iquest: "¿",
|
"isinE;": "⋹",
|
"isins;": "⋴",
|
"isinv;": "∈",
|
"Iukcy;": "І",
|
"iukcy;": "і",
|
"Jcirc;": "Ĵ",
|
"jcirc;": "ĵ",
|
"jmath;": "ȷ",
|
"Jukcy;": "Є",
|
"jukcy;": "є",
|
"Kappa;": "Κ",
|
"kappa;": "κ",
|
"lAarr;": "⇚",
|
"langd;": "⦑",
|
"laquo;": "«",
|
"larrb;": "⇤",
|
"lates;": "⪭︀",
|
"lBarr;": "⤎",
|
"lbarr;": "⤌",
|
"lbbrk;": "❲",
|
"lbrke;": "⦋",
|
"lceil;": "⌈",
|
"ldquo;": "“",
|
"lescc;": "⪨",
|
"lhard;": "↽",
|
"lharu;": "↼",
|
"lhblk;": "▄",
|
"llarr;": "⇇",
|
"lltri;": "◺",
|
"lneqq;": "≨",
|
"lnsim;": "⋦",
|
"loang;": "⟬",
|
"loarr;": "⇽",
|
"lobrk;": "⟦",
|
"lopar;": "⦅",
|
"lrarr;": "⇆",
|
"lrhar;": "⇋",
|
"lrtri;": "⊿",
|
"lsime;": "⪍",
|
"lsimg;": "⪏",
|
"lsquo;": "‘",
|
"ltcir;": "⩹",
|
"ltdot;": "⋖",
|
"ltrie;": "⊴",
|
"ltrif;": "◂",
|
"mdash;": "—",
|
"mDDot;": "∺",
|
"micro;": "µ",
|
middot: "·",
|
"minus;": "−",
|
"mumap;": "⊸",
|
"nabla;": "∇",
|
"napid;": "≋̸",
|
"napos;": "ʼn",
|
"natur;": "♮",
|
"nbump;": "≎̸",
|
"ncong;": "≇",
|
"ndash;": "–",
|
"neArr;": "⇗",
|
"nearr;": "↗",
|
"nedot;": "≐̸",
|
"nesim;": "≂̸",
|
"ngeqq;": "≧̸",
|
"ngsim;": "≵",
|
"nhArr;": "⇎",
|
"nharr;": "↮",
|
"nhpar;": "⫲",
|
"nlArr;": "⇍",
|
"nlarr;": "↚",
|
"nleqq;": "≦̸",
|
"nless;": "≮",
|
"nlsim;": "≴",
|
"nltri;": "⋪",
|
"notin;": "∉",
|
"notni;": "∌",
|
"npart;": "∂̸",
|
"nprec;": "⊀",
|
"nrArr;": "⇏",
|
"nrarr;": "↛",
|
"nrtri;": "⋫",
|
"nsime;": "≄",
|
"nsmid;": "∤",
|
"nspar;": "∦",
|
"nsubE;": "⫅̸",
|
"nsube;": "⊈",
|
"nsucc;": "⊁",
|
"nsupE;": "⫆̸",
|
"nsupe;": "⊉",
|
Ntilde: "Ñ",
|
ntilde: "ñ",
|
"numsp;": " ",
|
"nvsim;": "∼⃒",
|
"nwArr;": "⇖",
|
"nwarr;": "↖",
|
Oacute: "Ó",
|
oacute: "ó",
|
"Ocirc;": "Ô",
|
"ocirc;": "ô",
|
"odash;": "⊝",
|
"OElig;": "Œ",
|
"oelig;": "œ",
|
"ofcir;": "⦿",
|
Ograve: "Ò",
|
ograve: "ò",
|
"ohbar;": "⦵",
|
"olarr;": "↺",
|
"olcir;": "⦾",
|
"oline;": "‾",
|
"Omacr;": "Ō",
|
"omacr;": "ō",
|
"Omega;": "Ω",
|
"omega;": "ω",
|
"operp;": "⦹",
|
"oplus;": "⊕",
|
"orarr;": "↻",
|
"order;": "ℴ",
|
Oslash: "Ø",
|
oslash: "ø",
|
Otilde: "Õ",
|
otilde: "õ",
|
"ovbar;": "⌽",
|
"parsl;": "⫽",
|
"phone;": "☎",
|
"plusb;": "⊞",
|
"pluse;": "⩲",
|
plusmn: "±",
|
"pound;": "£",
|
"prcue;": "≼",
|
"Prime;": "″",
|
"prime;": "′",
|
"prnap;": "⪹",
|
"prsim;": "≾",
|
"quest;": "?",
|
"rAarr;": "⇛",
|
"radic;": "√",
|
"rangd;": "⦒",
|
"range;": "⦥",
|
"raquo;": "»",
|
"rarrb;": "⇥",
|
"rarrc;": "⤳",
|
"rarrw;": "↝",
|
"ratio;": "∶",
|
"RBarr;": "⤐",
|
"rBarr;": "⤏",
|
"rbarr;": "⤍",
|
"rbbrk;": "❳",
|
"rbrke;": "⦌",
|
"rceil;": "⌉",
|
"rdquo;": "”",
|
"reals;": "ℝ",
|
"rhard;": "⇁",
|
"rharu;": "⇀",
|
"rlarr;": "⇄",
|
"rlhar;": "⇌",
|
"rnmid;": "⫮",
|
"roang;": "⟭",
|
"roarr;": "⇾",
|
"robrk;": "⟧",
|
"ropar;": "⦆",
|
"rrarr;": "⇉",
|
"rsquo;": "’",
|
"rtrie;": "⊵",
|
"rtrif;": "▸",
|
"sbquo;": "‚",
|
"sccue;": "≽",
|
"Scirc;": "Ŝ",
|
"scirc;": "ŝ",
|
"scnap;": "⪺",
|
"scsim;": "≿",
|
"sdotb;": "⊡",
|
"sdote;": "⩦",
|
"seArr;": "⇘",
|
"searr;": "↘",
|
"setmn;": "∖",
|
"sharp;": "♯",
|
"Sigma;": "Σ",
|
"sigma;": "σ",
|
"simeq;": "≃",
|
"simgE;": "⪠",
|
"simlE;": "⪟",
|
"simne;": "≆",
|
"slarr;": "←",
|
"smile;": "⌣",
|
"smtes;": "⪬︀",
|
"sqcap;": "⊓",
|
"sqcup;": "⊔",
|
"sqsub;": "⊏",
|
"sqsup;": "⊐",
|
"srarr;": "→",
|
"starf;": "★",
|
"strns;": "¯",
|
"subnE;": "⫋",
|
"subne;": "⊊",
|
"supnE;": "⫌",
|
"supne;": "⊋",
|
"swArr;": "⇙",
|
"swarr;": "↙",
|
"szlig;": "ß",
|
"Theta;": "Θ",
|
"theta;": "θ",
|
"thkap;": "≈",
|
"THORN;": "Þ",
|
"thorn;": "þ",
|
"Tilde;": "∼",
|
"tilde;": "˜",
|
"times;": "×",
|
"TRADE;": "™",
|
"trade;": "™",
|
"trisb;": "⧍",
|
"TSHcy;": "Ћ",
|
"tshcy;": "ћ",
|
"twixt;": "≬",
|
Uacute: "Ú",
|
uacute: "ú",
|
"Ubrcy;": "Ў",
|
"ubrcy;": "ў",
|
"Ucirc;": "Û",
|
"ucirc;": "û",
|
"udarr;": "⇅",
|
"udhar;": "⥮",
|
Ugrave: "Ù",
|
ugrave: "ù",
|
"uharl;": "↿",
|
"uharr;": "↾",
|
"uhblk;": "▀",
|
"ultri;": "◸",
|
"Umacr;": "Ū",
|
"umacr;": "ū",
|
"Union;": "⋃",
|
"Uogon;": "Ų",
|
"uogon;": "ų",
|
"uplus;": "⊎",
|
"upsih;": "ϒ",
|
"UpTee;": "⊥",
|
"Uring;": "Ů",
|
"uring;": "ů",
|
"urtri;": "◹",
|
"utdot;": "⋰",
|
"utrif;": "▴",
|
"uuarr;": "⇈",
|
"varpi;": "ϖ",
|
"vBarv;": "⫩",
|
"VDash;": "⊫",
|
"Vdash;": "⊩",
|
"vDash;": "⊨",
|
"vdash;": "⊢",
|
"veeeq;": "≚",
|
"vltri;": "⊲",
|
"vnsub;": "⊂⃒",
|
"vnsup;": "⊃⃒",
|
"vprop;": "∝",
|
"vrtri;": "⊳",
|
"Wcirc;": "Ŵ",
|
"wcirc;": "ŵ",
|
"Wedge;": "⋀",
|
"wedge;": "∧",
|
"xcirc;": "◯",
|
"xdtri;": "▽",
|
"xhArr;": "⟺",
|
"xharr;": "⟷",
|
"xlArr;": "⟸",
|
"xlarr;": "⟵",
|
"xodot;": "⨀",
|
"xrArr;": "⟹",
|
"xrarr;": "⟶",
|
"xutri;": "△",
|
Yacute: "Ý",
|
yacute: "ý",
|
"Ycirc;": "Ŷ",
|
"ycirc;": "ŷ",
|
"Aacute;": "Á",
|
"aacute;": "á",
|
"Abreve;": "Ă",
|
"abreve;": "ă",
|
"Agrave;": "À",
|
"agrave;": "à",
|
"andand;": "⩕",
|
"angmsd;": "∡",
|
"angsph;": "∢",
|
"apacir;": "⩯",
|
"approx;": "≈",
|
"Assign;": "≔",
|
"Atilde;": "Ã",
|
"atilde;": "ã",
|
"barvee;": "⊽",
|
"Barwed;": "⌆",
|
"barwed;": "⌅",
|
"becaus;": "∵",
|
"bernou;": "ℬ",
|
"bigcap;": "⋂",
|
"bigcup;": "⋃",
|
"bigvee;": "⋁",
|
"bkarow;": "⤍",
|
"bottom;": "⊥",
|
"bowtie;": "⋈",
|
"boxbox;": "⧉",
|
"bprime;": "‵",
|
"brvbar;": "¦",
|
"bullet;": "•",
|
"Bumpeq;": "≎",
|
"bumpeq;": "≏",
|
"Cacute;": "Ć",
|
"cacute;": "ć",
|
"capand;": "⩄",
|
"capcap;": "⩋",
|
"capcup;": "⩇",
|
"capdot;": "⩀",
|
"Ccaron;": "Č",
|
"ccaron;": "č",
|
"Ccedil;": "Ç",
|
"ccedil;": "ç",
|
"circeq;": "≗",
|
"cirmid;": "⫯",
|
"Colone;": "⩴",
|
"colone;": "≔",
|
"commat;": "@",
|
"compfn;": "∘",
|
"Conint;": "∯",
|
"conint;": "∮",
|
"coprod;": "∐",
|
"copysr;": "℗",
|
"cularr;": "↶",
|
"CupCap;": "≍",
|
"cupcap;": "⩆",
|
"cupcup;": "⩊",
|
"cupdot;": "⊍",
|
"curarr;": "↷",
|
"curren;": "¤",
|
"cylcty;": "⌭",
|
"Dagger;": "‡",
|
"dagger;": "†",
|
"daleth;": "ℸ",
|
"Dcaron;": "Ď",
|
"dcaron;": "ď",
|
"dfisht;": "⥿",
|
"divide;": "÷",
|
"divonx;": "⋇",
|
"dlcorn;": "⌞",
|
"dlcrop;": "⌍",
|
"dollar;": "$",
|
"DotDot;": "⃜",
|
"drcorn;": "⌟",
|
"drcrop;": "⌌",
|
"Dstrok;": "Đ",
|
"dstrok;": "đ",
|
"Eacute;": "É",
|
"eacute;": "é",
|
"easter;": "⩮",
|
"Ecaron;": "Ě",
|
"ecaron;": "ě",
|
"ecolon;": "≕",
|
"Egrave;": "È",
|
"egrave;": "è",
|
"egsdot;": "⪘",
|
"elsdot;": "⪗",
|
"emptyv;": "∅",
|
"emsp13;": " ",
|
"emsp14;": " ",
|
"eparsl;": "⧣",
|
"eqcirc;": "≖",
|
"equals;": "=",
|
"equest;": "≟",
|
"Exists;": "∃",
|
"female;": "♀",
|
"ffilig;": "ffi",
|
"ffllig;": "ffl",
|
"ForAll;": "∀",
|
"forall;": "∀",
|
"frac12;": "½",
|
"frac13;": "⅓",
|
"frac14;": "¼",
|
"frac15;": "⅕",
|
"frac16;": "⅙",
|
"frac18;": "⅛",
|
"frac23;": "⅔",
|
"frac25;": "⅖",
|
"frac34;": "¾",
|
"frac35;": "⅗",
|
"frac38;": "⅜",
|
"frac45;": "⅘",
|
"frac56;": "⅚",
|
"frac58;": "⅝",
|
"frac78;": "⅞",
|
"gacute;": "ǵ",
|
"Gammad;": "Ϝ",
|
"gammad;": "ϝ",
|
"Gbreve;": "Ğ",
|
"gbreve;": "ğ",
|
"Gcedil;": "Ģ",
|
"gesdot;": "⪀",
|
"gesles;": "⪔",
|
"gtlPar;": "⦕",
|
"gtrarr;": "⥸",
|
"gtrdot;": "⋗",
|
"gtrsim;": "≳",
|
"hairsp;": " ",
|
"hamilt;": "ℋ",
|
"HARDcy;": "Ъ",
|
"hardcy;": "ъ",
|
"hearts;": "♥",
|
"hellip;": "…",
|
"hercon;": "⊹",
|
"homtht;": "∻",
|
"horbar;": "―",
|
"hslash;": "ℏ",
|
"Hstrok;": "Ħ",
|
"hstrok;": "ħ",
|
"hybull;": "⁃",
|
"hyphen;": "‐",
|
"Iacute;": "Í",
|
"iacute;": "í",
|
"Igrave;": "Ì",
|
"igrave;": "ì",
|
"iiiint;": "⨌",
|
"iinfin;": "⧜",
|
"incare;": "℅",
|
"inodot;": "ı",
|
"intcal;": "⊺",
|
"iquest;": "¿",
|
"isinsv;": "⋳",
|
"Itilde;": "Ĩ",
|
"itilde;": "ĩ",
|
"Jsercy;": "Ј",
|
"jsercy;": "ј",
|
"kappav;": "ϰ",
|
"Kcedil;": "Ķ",
|
"kcedil;": "ķ",
|
"kgreen;": "ĸ",
|
"Lacute;": "Ĺ",
|
"lacute;": "ĺ",
|
"lagran;": "ℒ",
|
"Lambda;": "Λ",
|
"lambda;": "λ",
|
"langle;": "⟨",
|
"larrfs;": "⤝",
|
"larrhk;": "↩",
|
"larrlp;": "↫",
|
"larrpl;": "⤹",
|
"larrtl;": "↢",
|
"lAtail;": "⤛",
|
"latail;": "⤙",
|
"lbrace;": "{",
|
"lbrack;": "[",
|
"Lcaron;": "Ľ",
|
"lcaron;": "ľ",
|
"Lcedil;": "Ļ",
|
"lcedil;": "ļ",
|
"ldquor;": "„",
|
"lesdot;": "⩿",
|
"lesges;": "⪓",
|
"lfisht;": "⥼",
|
"lfloor;": "⌊",
|
"lharul;": "⥪",
|
"llhard;": "⥫",
|
"Lmidot;": "Ŀ",
|
"lmidot;": "ŀ",
|
"lmoust;": "⎰",
|
"loplus;": "⨭",
|
"lowast;": "∗",
|
"lowbar;": "_",
|
"lparlt;": "⦓",
|
"lrhard;": "⥭",
|
"lsaquo;": "‹",
|
"lsquor;": "‚",
|
"Lstrok;": "Ł",
|
"lstrok;": "ł",
|
"lthree;": "⋋",
|
"ltimes;": "⋉",
|
"ltlarr;": "⥶",
|
"ltrPar;": "⦖",
|
"mapsto;": "↦",
|
"marker;": "▮",
|
"mcomma;": "⨩",
|
"midast;": "*",
|
"midcir;": "⫰",
|
"middot;": "·",
|
"minusb;": "⊟",
|
"minusd;": "∸",
|
"mnplus;": "∓",
|
"models;": "⊧",
|
"mstpos;": "∾",
|
"Nacute;": "Ń",
|
"nacute;": "ń",
|
"nbumpe;": "≏̸",
|
"Ncaron;": "Ň",
|
"ncaron;": "ň",
|
"Ncedil;": "Ņ",
|
"ncedil;": "ņ",
|
"nearhk;": "⤤",
|
"nequiv;": "≢",
|
"nesear;": "⤨",
|
"nexist;": "∄",
|
"nltrie;": "⋬",
|
"notinE;": "⋹̸",
|
"nparsl;": "⫽⃥",
|
"nprcue;": "⋠",
|
"nrarrc;": "⤳̸",
|
"nrarrw;": "↝̸",
|
"nrtrie;": "⋭",
|
"nsccue;": "⋡",
|
"nsimeq;": "≄",
|
"Ntilde;": "Ñ",
|
"ntilde;": "ñ",
|
"numero;": "№",
|
"nVDash;": "⊯",
|
"nVdash;": "⊮",
|
"nvDash;": "⊭",
|
"nvdash;": "⊬",
|
"nvHarr;": "⤄",
|
"nvlArr;": "⤂",
|
"nvrArr;": "⤃",
|
"nwarhk;": "⤣",
|
"nwnear;": "⤧",
|
"Oacute;": "Ó",
|
"oacute;": "ó",
|
"Odblac;": "Ő",
|
"odblac;": "ő",
|
"odsold;": "⦼",
|
"Ograve;": "Ò",
|
"ograve;": "ò",
|
"ominus;": "⊖",
|
"origof;": "⊶",
|
"Oslash;": "Ø",
|
"oslash;": "ø",
|
"Otilde;": "Õ",
|
"otilde;": "õ",
|
"Otimes;": "⨷",
|
"otimes;": "⊗",
|
"parsim;": "⫳",
|
"percnt;": "%",
|
"period;": ".",
|
"permil;": "‰",
|
"phmmat;": "ℳ",
|
"planck;": "ℏ",
|
"plankv;": "ℏ",
|
"plusdo;": "∔",
|
"plusdu;": "⨥",
|
"plusmn;": "±",
|
"preceq;": "⪯",
|
"primes;": "ℙ",
|
"prnsim;": "⋨",
|
"propto;": "∝",
|
"prurel;": "⊰",
|
"puncsp;": " ",
|
"qprime;": "⁗",
|
"Racute;": "Ŕ",
|
"racute;": "ŕ",
|
"rangle;": "⟩",
|
"rarrap;": "⥵",
|
"rarrfs;": "⤞",
|
"rarrhk;": "↪",
|
"rarrlp;": "↬",
|
"rarrpl;": "⥅",
|
"Rarrtl;": "⤖",
|
"rarrtl;": "↣",
|
"rAtail;": "⤜",
|
"ratail;": "⤚",
|
"rbrace;": "}",
|
"rbrack;": "]",
|
"Rcaron;": "Ř",
|
"rcaron;": "ř",
|
"Rcedil;": "Ŗ",
|
"rcedil;": "ŗ",
|
"rdquor;": "”",
|
"rfisht;": "⥽",
|
"rfloor;": "⌋",
|
"rharul;": "⥬",
|
"rmoust;": "⎱",
|
"roplus;": "⨮",
|
"rpargt;": "⦔",
|
"rsaquo;": "›",
|
"rsquor;": "’",
|
"rthree;": "⋌",
|
"rtimes;": "⋊",
|
"Sacute;": "Ś",
|
"sacute;": "ś",
|
"Scaron;": "Š",
|
"scaron;": "š",
|
"Scedil;": "Ş",
|
"scedil;": "ş",
|
"scnsim;": "⋩",
|
"searhk;": "⤥",
|
"seswar;": "⤩",
|
"sfrown;": "⌢",
|
"SHCHcy;": "Щ",
|
"shchcy;": "щ",
|
"sigmaf;": "ς",
|
"sigmav;": "ς",
|
"simdot;": "⩪",
|
"smashp;": "⨳",
|
"SOFTcy;": "Ь",
|
"softcy;": "ь",
|
"solbar;": "⌿",
|
"spades;": "♠",
|
"sqcaps;": "⊓︀",
|
"sqcups;": "⊔︀",
|
"sqsube;": "⊑",
|
"sqsupe;": "⊒",
|
"Square;": "□",
|
"square;": "□",
|
"squarf;": "▪",
|
"ssetmn;": "∖",
|
"ssmile;": "⌣",
|
"sstarf;": "⋆",
|
"subdot;": "⪽",
|
"Subset;": "⋐",
|
"subset;": "⊂",
|
"subsim;": "⫇",
|
"subsub;": "⫕",
|
"subsup;": "⫓",
|
"succeq;": "⪰",
|
"supdot;": "⪾",
|
"Supset;": "⋑",
|
"supset;": "⊃",
|
"supsim;": "⫈",
|
"supsub;": "⫔",
|
"supsup;": "⫖",
|
"swarhk;": "⤦",
|
"swnwar;": "⤪",
|
"target;": "⌖",
|
"Tcaron;": "Ť",
|
"tcaron;": "ť",
|
"Tcedil;": "Ţ",
|
"tcedil;": "ţ",
|
"telrec;": "⌕",
|
"there4;": "∴",
|
"thetav;": "ϑ",
|
"thinsp;": " ",
|
"thksim;": "∼",
|
"timesb;": "⊠",
|
"timesd;": "⨰",
|
"topbot;": "⌶",
|
"topcir;": "⫱",
|
"tprime;": "‴",
|
"tridot;": "◬",
|
"Tstrok;": "Ŧ",
|
"tstrok;": "ŧ",
|
"Uacute;": "Ú",
|
"uacute;": "ú",
|
"Ubreve;": "Ŭ",
|
"ubreve;": "ŭ",
|
"Udblac;": "Ű",
|
"udblac;": "ű",
|
"ufisht;": "⥾",
|
"Ugrave;": "Ù",
|
"ugrave;": "ù",
|
"ulcorn;": "⌜",
|
"ulcrop;": "⌏",
|
"urcorn;": "⌝",
|
"urcrop;": "⌎",
|
"Utilde;": "Ũ",
|
"utilde;": "ũ",
|
"vangrt;": "⦜",
|
"varphi;": "ϕ",
|
"varrho;": "ϱ",
|
"Vdashl;": "⫦",
|
"veebar;": "⊻",
|
"vellip;": "⋮",
|
"Verbar;": "‖",
|
"verbar;": "|",
|
"vsubnE;": "⫋︀",
|
"vsubne;": "⊊︀",
|
"vsupnE;": "⫌︀",
|
"vsupne;": "⊋︀",
|
"Vvdash;": "⊪",
|
"wedbar;": "⩟",
|
"wedgeq;": "≙",
|
"weierp;": "℘",
|
"wreath;": "≀",
|
"xoplus;": "⨁",
|
"xotime;": "⨂",
|
"xsqcup;": "⨆",
|
"xuplus;": "⨄",
|
"xwedge;": "⋀",
|
"Yacute;": "Ý",
|
"yacute;": "ý",
|
"Zacute;": "Ź",
|
"zacute;": "ź",
|
"Zcaron;": "Ž",
|
"zcaron;": "ž",
|
"zeetrf;": "ℨ",
|
"alefsym;": "ℵ",
|
"angrtvb;": "⊾",
|
"angzarr;": "⍼",
|
"asympeq;": "≍",
|
"backsim;": "∽",
|
"Because;": "∵",
|
"because;": "∵",
|
"bemptyv;": "⦰",
|
"between;": "≬",
|
"bigcirc;": "◯",
|
"bigodot;": "⨀",
|
"bigstar;": "★",
|
"bnequiv;": "≡⃥",
|
"boxplus;": "⊞",
|
"Cayleys;": "ℭ",
|
"Cconint;": "∰",
|
"ccupssm;": "⩐",
|
"Cedilla;": "¸",
|
"cemptyv;": "⦲",
|
"cirscir;": "⧂",
|
"coloneq;": "≔",
|
"congdot;": "⩭",
|
"cudarrl;": "⤸",
|
"cudarrr;": "⤵",
|
"cularrp;": "⤽",
|
"curarrm;": "⤼",
|
"dbkarow;": "⤏",
|
"ddagger;": "‡",
|
"ddotseq;": "⩷",
|
"demptyv;": "⦱",
|
"Diamond;": "⋄",
|
"diamond;": "⋄",
|
"digamma;": "ϝ",
|
"dotplus;": "∔",
|
"DownTee;": "⊤",
|
"dwangle;": "⦦",
|
"Element;": "∈",
|
"Epsilon;": "Ε",
|
"epsilon;": "ε",
|
"eqcolon;": "≕",
|
"equivDD;": "⩸",
|
"gesdoto;": "⪂",
|
"gtquest;": "⩼",
|
"gtrless;": "≷",
|
"harrcir;": "⥈",
|
"Implies;": "⇒",
|
"intprod;": "⨼",
|
"isindot;": "⋵",
|
"larrbfs;": "⤟",
|
"larrsim;": "⥳",
|
"lbrksld;": "⦏",
|
"lbrkslu;": "⦍",
|
"ldrdhar;": "⥧",
|
"LeftTee;": "⊣",
|
"lesdoto;": "⪁",
|
"lessdot;": "⋖",
|
"lessgtr;": "≶",
|
"lesssim;": "≲",
|
"lotimes;": "⨴",
|
"lozenge;": "◊",
|
"ltquest;": "⩻",
|
"luruhar;": "⥦",
|
"maltese;": "✠",
|
"minusdu;": "⨪",
|
"napprox;": "≉",
|
"natural;": "♮",
|
"nearrow;": "↗",
|
"NewLine;": "\n",
|
"nexists;": "∄",
|
"NoBreak;": "",
|
"notinva;": "∉",
|
"notinvb;": "⋷",
|
"notinvc;": "⋶",
|
"NotLess;": "≮",
|
"notniva;": "∌",
|
"notnivb;": "⋾",
|
"notnivc;": "⋽",
|
"npolint;": "⨔",
|
"npreceq;": "⪯̸",
|
"nsqsube;": "⋢",
|
"nsqsupe;": "⋣",
|
"nsubset;": "⊂⃒",
|
"nsucceq;": "⪰̸",
|
"nsupset;": "⊃⃒",
|
"nvinfin;": "⧞",
|
"nvltrie;": "⊴⃒",
|
"nvrtrie;": "⊵⃒",
|
"nwarrow;": "↖",
|
"olcross;": "⦻",
|
"Omicron;": "Ο",
|
"omicron;": "ο",
|
"orderof;": "ℴ",
|
"orslope;": "⩗",
|
"OverBar;": "‾",
|
"pertenk;": "‱",
|
"planckh;": "ℎ",
|
"pluscir;": "⨢",
|
"plussim;": "⨦",
|
"plustwo;": "⨧",
|
"precsim;": "≾",
|
"Product;": "∏",
|
"quatint;": "⨖",
|
"questeq;": "≟",
|
"rarrbfs;": "⤠",
|
"rarrsim;": "⥴",
|
"rbrksld;": "⦎",
|
"rbrkslu;": "⦐",
|
"rdldhar;": "⥩",
|
"realine;": "ℛ",
|
"rotimes;": "⨵",
|
"ruluhar;": "⥨",
|
"searrow;": "↘",
|
"simplus;": "⨤",
|
"simrarr;": "⥲",
|
"subedot;": "⫃",
|
"submult;": "⫁",
|
"subplus;": "⪿",
|
"subrarr;": "⥹",
|
"succsim;": "≿",
|
"supdsub;": "⫘",
|
"supedot;": "⫄",
|
"suphsol;": "⟉",
|
"suphsub;": "⫗",
|
"suplarr;": "⥻",
|
"supmult;": "⫂",
|
"supplus;": "⫀",
|
"swarrow;": "↙",
|
"topfork;": "⫚",
|
"triplus;": "⨹",
|
"tritime;": "⨻",
|
"UpArrow;": "↑",
|
"Uparrow;": "⇑",
|
"uparrow;": "↑",
|
"Upsilon;": "Υ",
|
"upsilon;": "υ",
|
"uwangle;": "⦧",
|
"vzigzag;": "⦚",
|
"zigrarr;": "⇝",
|
"andslope;": "⩘",
|
"angmsdaa;": "⦨",
|
"angmsdab;": "⦩",
|
"angmsdac;": "⦪",
|
"angmsdad;": "⦫",
|
"angmsdae;": "⦬",
|
"angmsdaf;": "⦭",
|
"angmsdag;": "⦮",
|
"angmsdah;": "⦯",
|
"angrtvbd;": "⦝",
|
"approxeq;": "≊",
|
"awconint;": "∳",
|
"backcong;": "≌",
|
"barwedge;": "⌅",
|
"bbrktbrk;": "⎶",
|
"bigoplus;": "⨁",
|
"bigsqcup;": "⨆",
|
"biguplus;": "⨄",
|
"bigwedge;": "⋀",
|
"boxminus;": "⊟",
|
"boxtimes;": "⊠",
|
"bsolhsub;": "⟈",
|
"capbrcup;": "⩉",
|
"circledR;": "®",
|
"circledS;": "Ⓢ",
|
"cirfnint;": "⨐",
|
"clubsuit;": "♣",
|
"cupbrcap;": "⩈",
|
"curlyvee;": "⋎",
|
"cwconint;": "∲",
|
"DDotrahd;": "⤑",
|
"doteqdot;": "≑",
|
"DotEqual;": "≐",
|
"dotminus;": "∸",
|
"drbkarow;": "⤐",
|
"dzigrarr;": "⟿",
|
"elinters;": "⏧",
|
"emptyset;": "∅",
|
"eqvparsl;": "⧥",
|
"fpartint;": "⨍",
|
"geqslant;": "⩾",
|
"gesdotol;": "⪄",
|
"gnapprox;": "⪊",
|
"hksearow;": "⤥",
|
"hkswarow;": "⤦",
|
"imagline;": "ℐ",
|
"imagpart;": "ℑ",
|
"infintie;": "⧝",
|
"integers;": "ℤ",
|
"Integral;": "∫",
|
"intercal;": "⊺",
|
"intlarhk;": "⨗",
|
"laemptyv;": "⦴",
|
"ldrushar;": "⥋",
|
"leqslant;": "⩽",
|
"lesdotor;": "⪃",
|
"LessLess;": "⪡",
|
"llcorner;": "⌞",
|
"lnapprox;": "⪉",
|
"lrcorner;": "⌟",
|
"lurdshar;": "⥊",
|
"mapstoup;": "↥",
|
"multimap;": "⊸",
|
"naturals;": "ℕ",
|
"ncongdot;": "⩭̸",
|
"NotEqual;": "≠",
|
"notindot;": "⋵̸",
|
"NotTilde;": "≁",
|
"otimesas;": "⨶",
|
"parallel;": "∥",
|
"PartialD;": "∂",
|
"plusacir;": "⨣",
|
"pointint;": "⨕",
|
"Precedes;": "≺",
|
"precneqq;": "⪵",
|
"precnsim;": "⋨",
|
"profalar;": "⌮",
|
"profline;": "⌒",
|
"profsurf;": "⌓",
|
"raemptyv;": "⦳",
|
"realpart;": "ℜ",
|
"RightTee;": "⊢",
|
"rppolint;": "⨒",
|
"rtriltri;": "⧎",
|
"scpolint;": "⨓",
|
"setminus;": "∖",
|
"shortmid;": "∣",
|
"smeparsl;": "⧤",
|
"sqsubset;": "⊏",
|
"sqsupset;": "⊐",
|
"subseteq;": "⊆",
|
"Succeeds;": "≻",
|
"succneqq;": "⪶",
|
"succnsim;": "⋩",
|
"SuchThat;": "∋",
|
"Superset;": "⊃",
|
"supseteq;": "⊇",
|
"thetasym;": "ϑ",
|
"thicksim;": "∼",
|
"timesbar;": "⨱",
|
"triangle;": "▵",
|
"triminus;": "⨺",
|
"trpezium;": "⏢",
|
"Uarrocir;": "⥉",
|
"ulcorner;": "⌜",
|
"UnderBar;": "_",
|
"urcorner;": "⌝",
|
"varkappa;": "ϰ",
|
"varsigma;": "ς",
|
"vartheta;": "ϑ",
|
"backprime;": "‵",
|
"backsimeq;": "⋍",
|
"Backslash;": "∖",
|
"bigotimes;": "⨂",
|
"CenterDot;": "·",
|
"centerdot;": "·",
|
"checkmark;": "✓",
|
"CircleDot;": "⊙",
|
"complexes;": "ℂ",
|
"Congruent;": "≡",
|
"Coproduct;": "∐",
|
"dotsquare;": "⊡",
|
"DoubleDot;": "¨",
|
"DownArrow;": "↓",
|
"Downarrow;": "⇓",
|
"downarrow;": "↓",
|
"DownBreve;": "̑",
|
"gtrapprox;": "⪆",
|
"gtreqless;": "⋛",
|
"gvertneqq;": "≩︀",
|
"heartsuit;": "♥",
|
"HumpEqual;": "≏",
|
"LeftArrow;": "←",
|
"Leftarrow;": "⇐",
|
"leftarrow;": "←",
|
"LeftFloor;": "⌊",
|
"lesseqgtr;": "⋚",
|
"LessTilde;": "≲",
|
"lvertneqq;": "≨︀",
|
"Mellintrf;": "ℳ",
|
"MinusPlus;": "∓",
|
"ngeqslant;": "⩾̸",
|
"nleqslant;": "⩽̸",
|
"NotCupCap;": "≭",
|
"NotExists;": "∄",
|
"NotSubset;": "⊂⃒",
|
"nparallel;": "∦",
|
"nshortmid;": "∤",
|
"nsubseteq;": "⊈",
|
"nsupseteq;": "⊉",
|
"OverBrace;": "⏞",
|
"pitchfork;": "⋔",
|
"PlusMinus;": "±",
|
"rationals;": "ℚ",
|
"spadesuit;": "♠",
|
"subseteqq;": "⫅",
|
"subsetneq;": "⊊",
|
"supseteqq;": "⫆",
|
"supsetneq;": "⊋",
|
"Therefore;": "∴",
|
"therefore;": "∴",
|
"ThinSpace;": " ",
|
"triangleq;": "≜",
|
"TripleDot;": "⃛",
|
"UnionPlus;": "⊎",
|
"varpropto;": "∝",
|
"Bernoullis;": "ℬ",
|
"circledast;": "⊛",
|
"CirclePlus;": "⊕",
|
"complement;": "∁",
|
"curlywedge;": "⋏",
|
"eqslantgtr;": "⪖",
|
"EqualTilde;": "≂",
|
"Fouriertrf;": "ℱ",
|
"gtreqqless;": "⪌",
|
"ImaginaryI;": "ⅈ",
|
"Laplacetrf;": "ℒ",
|
"LeftVector;": "↼",
|
"lessapprox;": "⪅",
|
"lesseqqgtr;": "⪋",
|
"Lleftarrow;": "⇚",
|
"lmoustache;": "⎰",
|
"longmapsto;": "⟼",
|
"mapstodown;": "↧",
|
"mapstoleft;": "↤",
|
"nLeftarrow;": "⇍",
|
"nleftarrow;": "↚",
|
"NotElement;": "∉",
|
"NotGreater;": "≯",
|
"nsubseteqq;": "⫅̸",
|
"nsupseteqq;": "⫆̸",
|
"precapprox;": "⪷",
|
"Proportion;": "∷",
|
"RightArrow;": "→",
|
"Rightarrow;": "⇒",
|
"rightarrow;": "→",
|
"RightFloor;": "⌋",
|
"rmoustache;": "⎱",
|
"sqsubseteq;": "⊑",
|
"sqsupseteq;": "⊒",
|
"subsetneqq;": "⫋",
|
"succapprox;": "⪸",
|
"supsetneqq;": "⫌",
|
"ThickSpace;": " ",
|
"TildeEqual;": "≃",
|
"TildeTilde;": "≈",
|
"UnderBrace;": "⏟",
|
"UpArrowBar;": "⤒",
|
"UpTeeArrow;": "↥",
|
"upuparrows;": "⇈",
|
"varepsilon;": "ϵ",
|
"varnothing;": "∅",
|
"backepsilon;": "϶",
|
"blacksquare;": "▪",
|
"circledcirc;": "⊚",
|
"circleddash;": "⊝",
|
"CircleMinus;": "⊖",
|
"CircleTimes;": "⊗",
|
"curlyeqprec;": "⋞",
|
"curlyeqsucc;": "⋟",
|
"diamondsuit;": "♦",
|
"eqslantless;": "⪕",
|
"Equilibrium;": "⇌",
|
"expectation;": "ℰ",
|
"GreaterLess;": "≷",
|
"LeftCeiling;": "⌈",
|
"LessGreater;": "≶",
|
"MediumSpace;": " ",
|
"NotLessLess;": "≪̸",
|
"NotPrecedes;": "⊀",
|
"NotSucceeds;": "⊁",
|
"NotSuperset;": "⊃⃒",
|
"nRightarrow;": "⇏",
|
"nrightarrow;": "↛",
|
"OverBracket;": "⎴",
|
"preccurlyeq;": "≼",
|
"precnapprox;": "⪹",
|
"quaternions;": "ℍ",
|
"RightVector;": "⇀",
|
"Rrightarrow;": "⇛",
|
"RuleDelayed;": "⧴",
|
"SmallCircle;": "∘",
|
"SquareUnion;": "⊔",
|
"straightphi;": "ϕ",
|
"SubsetEqual;": "⊆",
|
"succcurlyeq;": "≽",
|
"succnapprox;": "⪺",
|
"thickapprox;": "≈",
|
"UpDownArrow;": "↕",
|
"Updownarrow;": "⇕",
|
"updownarrow;": "↕",
|
"VerticalBar;": "∣",
|
"blacklozenge;": "⧫",
|
"DownArrowBar;": "⤓",
|
"DownTeeArrow;": "↧",
|
"ExponentialE;": "ⅇ",
|
"exponentiale;": "ⅇ",
|
"GreaterEqual;": "≥",
|
"GreaterTilde;": "≳",
|
"HilbertSpace;": "ℋ",
|
"HumpDownHump;": "≎",
|
"Intersection;": "⋂",
|
"LeftArrowBar;": "⇤",
|
"LeftTeeArrow;": "↤",
|
"LeftTriangle;": "⊲",
|
"LeftUpVector;": "↿",
|
"NotCongruent;": "≢",
|
"NotHumpEqual;": "≏̸",
|
"NotLessEqual;": "≰",
|
"NotLessTilde;": "≴",
|
"Proportional;": "∝",
|
"RightCeiling;": "⌉",
|
"risingdotseq;": "≓",
|
"RoundImplies;": "⥰",
|
"ShortUpArrow;": "↑",
|
"SquareSubset;": "⊏",
|
"triangledown;": "▿",
|
"triangleleft;": "◃",
|
"UnderBracket;": "⎵",
|
"varsubsetneq;": "⊊︀",
|
"varsupsetneq;": "⊋︀",
|
"VerticalLine;": "|",
|
"ApplyFunction;": "",
|
"bigtriangleup;": "△",
|
"blacktriangle;": "▴",
|
"DifferentialD;": "ⅆ",
|
"divideontimes;": "⋇",
|
"DoubleLeftTee;": "⫤",
|
"DoubleUpArrow;": "⇑",
|
"fallingdotseq;": "≒",
|
"hookleftarrow;": "↩",
|
"leftarrowtail;": "↢",
|
"leftharpoonup;": "↼",
|
"LeftTeeVector;": "⥚",
|
"LeftVectorBar;": "⥒",
|
"LessFullEqual;": "≦",
|
"LongLeftArrow;": "⟵",
|
"Longleftarrow;": "⟸",
|
"longleftarrow;": "⟵",
|
"looparrowleft;": "↫",
|
"measuredangle;": "∡",
|
"NotEqualTilde;": "≂̸",
|
"NotTildeEqual;": "≄",
|
"NotTildeTilde;": "≉",
|
"ntriangleleft;": "⋪",
|
"Poincareplane;": "ℌ",
|
"PrecedesEqual;": "⪯",
|
"PrecedesTilde;": "≾",
|
"RightArrowBar;": "⇥",
|
"RightTeeArrow;": "↦",
|
"RightTriangle;": "⊳",
|
"RightUpVector;": "↾",
|
"shortparallel;": "∥",
|
"smallsetminus;": "∖",
|
"SucceedsEqual;": "⪰",
|
"SucceedsTilde;": "≿",
|
"SupersetEqual;": "⊇",
|
"triangleright;": "▹",
|
"UpEquilibrium;": "⥮",
|
"upharpoonleft;": "↿",
|
"varsubsetneqq;": "⫋︀",
|
"varsupsetneqq;": "⫌︀",
|
"VerticalTilde;": "≀",
|
"VeryThinSpace;": " ",
|
"curvearrowleft;": "↶",
|
"DiacriticalDot;": "˙",
|
"doublebarwedge;": "⌆",
|
"DoubleRightTee;": "⊨",
|
"downdownarrows;": "⇊",
|
"DownLeftVector;": "↽",
|
"GreaterGreater;": "⪢",
|
"hookrightarrow;": "↪",
|
"HorizontalLine;": "─",
|
"InvisibleComma;": "",
|
"InvisibleTimes;": "",
|
"LeftDownVector;": "⇃",
|
"leftleftarrows;": "⇇",
|
"LeftRightArrow;": "↔",
|
"Leftrightarrow;": "⇔",
|
"leftrightarrow;": "↔",
|
"leftthreetimes;": "⋋",
|
"LessSlantEqual;": "⩽",
|
"LongRightArrow;": "⟶",
|
"Longrightarrow;": "⟹",
|
"longrightarrow;": "⟶",
|
"looparrowright;": "↬",
|
"LowerLeftArrow;": "↙",
|
"NestedLessLess;": "≪",
|
"NotGreaterLess;": "≹",
|
"NotLessGreater;": "≸",
|
"NotSubsetEqual;": "⊈",
|
"NotVerticalBar;": "∤",
|
"nshortparallel;": "∦",
|
"ntriangleright;": "⋫",
|
"OpenCurlyQuote;": "‘",
|
"ReverseElement;": "∋",
|
"rightarrowtail;": "↣",
|
"rightharpoonup;": "⇀",
|
"RightTeeVector;": "⥛",
|
"RightVectorBar;": "⥓",
|
"ShortDownArrow;": "↓",
|
"ShortLeftArrow;": "←",
|
"SquareSuperset;": "⊐",
|
"TildeFullEqual;": "≅",
|
"trianglelefteq;": "⊴",
|
"upharpoonright;": "↾",
|
"UpperLeftArrow;": "↖",
|
"ZeroWidthSpace;": "",
|
"bigtriangledown;": "▽",
|
"circlearrowleft;": "↺",
|
"CloseCurlyQuote;": "’",
|
"ContourIntegral;": "∮",
|
"curvearrowright;": "↷",
|
"DoubleDownArrow;": "⇓",
|
"DoubleLeftArrow;": "⇐",
|
"downharpoonleft;": "⇃",
|
"DownRightVector;": "⇁",
|
"leftharpoondown;": "↽",
|
"leftrightarrows;": "⇆",
|
"LeftRightVector;": "⥎",
|
"LeftTriangleBar;": "⧏",
|
"LeftUpTeeVector;": "⥠",
|
"LeftUpVectorBar;": "⥘",
|
"LowerRightArrow;": "↘",
|
"nLeftrightarrow;": "⇎",
|
"nleftrightarrow;": "↮",
|
"NotGreaterEqual;": "≱",
|
"NotGreaterTilde;": "≵",
|
"NotHumpDownHump;": "≎̸",
|
"NotLeftTriangle;": "⋪",
|
"NotSquareSubset;": "⊏̸",
|
"ntrianglelefteq;": "⋬",
|
"OverParenthesis;": "⏜",
|
"RightDownVector;": "⇂",
|
"rightleftarrows;": "⇄",
|
"rightsquigarrow;": "↝",
|
"rightthreetimes;": "⋌",
|
"ShortRightArrow;": "→",
|
"straightepsilon;": "ϵ",
|
"trianglerighteq;": "⊵",
|
"UpperRightArrow;": "↗",
|
"vartriangleleft;": "⊲",
|
"circlearrowright;": "↻",
|
"DiacriticalAcute;": "´",
|
"DiacriticalGrave;": "`",
|
"DiacriticalTilde;": "˜",
|
"DoubleRightArrow;": "⇒",
|
"DownArrowUpArrow;": "⇵",
|
"downharpoonright;": "⇂",
|
"EmptySmallSquare;": "◻",
|
"GreaterEqualLess;": "⋛",
|
"GreaterFullEqual;": "≧",
|
"LeftAngleBracket;": "⟨",
|
"LeftUpDownVector;": "⥑",
|
"LessEqualGreater;": "⋚",
|
"NonBreakingSpace;": " ",
|
"NotPrecedesEqual;": "⪯̸",
|
"NotRightTriangle;": "⋫",
|
"NotSucceedsEqual;": "⪰̸",
|
"NotSucceedsTilde;": "≿̸",
|
"NotSupersetEqual;": "⊉",
|
"ntrianglerighteq;": "⋭",
|
"rightharpoondown;": "⇁",
|
"rightrightarrows;": "⇉",
|
"RightTriangleBar;": "⧐",
|
"RightUpTeeVector;": "⥜",
|
"RightUpVectorBar;": "⥔",
|
"twoheadleftarrow;": "↞",
|
"UnderParenthesis;": "⏝",
|
"UpArrowDownArrow;": "⇅",
|
"vartriangleright;": "⊳",
|
"blacktriangledown;": "▾",
|
"blacktriangleleft;": "◂",
|
"DoubleUpDownArrow;": "⇕",
|
"DoubleVerticalBar;": "∥",
|
"DownLeftTeeVector;": "⥞",
|
"DownLeftVectorBar;": "⥖",
|
"FilledSmallSquare;": "◼",
|
"GreaterSlantEqual;": "⩾",
|
"LeftDoubleBracket;": "⟦",
|
"LeftDownTeeVector;": "⥡",
|
"LeftDownVectorBar;": "⥙",
|
"leftrightharpoons;": "⇋",
|
"LeftTriangleEqual;": "⊴",
|
"NegativeThinSpace;": "",
|
"NotGreaterGreater;": "≫̸",
|
"NotLessSlantEqual;": "⩽̸",
|
"NotNestedLessLess;": "⪡̸",
|
"NotReverseElement;": "∌",
|
"NotSquareSuperset;": "⊐̸",
|
"NotTildeFullEqual;": "≇",
|
"RightAngleBracket;": "⟩",
|
"rightleftharpoons;": "⇌",
|
"RightUpDownVector;": "⥏",
|
"SquareSubsetEqual;": "⊑",
|
"twoheadrightarrow;": "↠",
|
"VerticalSeparator;": "❘",
|
"blacktriangleright;": "▸",
|
"DownRightTeeVector;": "⥟",
|
"DownRightVectorBar;": "⥗",
|
"LongLeftRightArrow;": "⟷",
|
"Longleftrightarrow;": "⟺",
|
"longleftrightarrow;": "⟷",
|
"NegativeThickSpace;": "",
|
"NotLeftTriangleBar;": "⧏̸",
|
"PrecedesSlantEqual;": "≼",
|
"ReverseEquilibrium;": "⇋",
|
"RightDoubleBracket;": "⟧",
|
"RightDownTeeVector;": "⥝",
|
"RightDownVectorBar;": "⥕",
|
"RightTriangleEqual;": "⊵",
|
"SquareIntersection;": "⊓",
|
"SucceedsSlantEqual;": "≽",
|
"DoubleLongLeftArrow;": "⟸",
|
"DownLeftRightVector;": "⥐",
|
"LeftArrowRightArrow;": "⇆",
|
"leftrightsquigarrow;": "↭",
|
"NegativeMediumSpace;": "",
|
"NotGreaterFullEqual;": "≧̸",
|
"NotRightTriangleBar;": "⧐̸",
|
"RightArrowLeftArrow;": "⇄",
|
"SquareSupersetEqual;": "⊒",
|
"CapitalDifferentialD;": "ⅅ",
|
"DoubleLeftRightArrow;": "⇔",
|
"DoubleLongRightArrow;": "⟹",
|
"EmptyVerySmallSquare;": "▫",
|
"NestedGreaterGreater;": "≫",
|
"NotDoubleVerticalBar;": "∦",
|
"NotGreaterSlantEqual;": "⩾̸",
|
"NotLeftTriangleEqual;": "⋬",
|
"NotSquareSubsetEqual;": "⋢",
|
"OpenCurlyDoubleQuote;": "“",
|
"ReverseUpEquilibrium;": "⥯",
|
"CloseCurlyDoubleQuote;": "”",
|
"DoubleContourIntegral;": "∯",
|
"FilledVerySmallSquare;": "▪",
|
"NegativeVeryThinSpace;": "",
|
"NotPrecedesSlantEqual;": "⋠",
|
"NotRightTriangleEqual;": "⋭",
|
"NotSucceedsSlantEqual;": "⋡",
|
"DiacriticalDoubleAcute;": "˝",
|
"NotSquareSupersetEqual;": "⋣",
|
"NotNestedGreaterGreater;": "⪢̸",
|
"ClockwiseContourIntegral;": "∲",
|
"DoubleLongLeftRightArrow;": "⟺",
|
"CounterClockwiseContourIntegral;": "∳"
|
};
|
|
let maxCRNameLength;
|
const decodeHtml = (rawText, asAttr) => {
|
let offset = 0;
|
const end = rawText.length;
|
let decodedText = "";
|
function advance(length) {
|
offset += length;
|
rawText = rawText.slice(length);
|
}
|
while (offset < end) {
|
const head = /&(?:#x?)?/i.exec(rawText);
|
if (!head || offset + head.index >= end) {
|
const remaining = end - offset;
|
decodedText += rawText.slice(0, remaining);
|
advance(remaining);
|
break;
|
}
|
decodedText += rawText.slice(0, head.index);
|
advance(head.index);
|
if (head[0] === "&") {
|
let name = "";
|
let value = void 0;
|
if (/[0-9a-z]/i.test(rawText[1])) {
|
if (!maxCRNameLength) {
|
maxCRNameLength = Object.keys(namedCharacterReferences).reduce(
|
(max, name2) => Math.max(max, name2.length),
|
0
|
);
|
}
|
for (let length = maxCRNameLength; !value && length > 0; --length) {
|
name = rawText.slice(1, 1 + length);
|
value = namedCharacterReferences[name];
|
}
|
if (value) {
|
const semi = name.endsWith(";");
|
if (asAttr && !semi && /[=a-z0-9]/i.test(rawText[name.length + 1] || "")) {
|
decodedText += "&" + name;
|
advance(1 + name.length);
|
} else {
|
decodedText += value;
|
advance(1 + name.length);
|
}
|
} else {
|
decodedText += "&" + name;
|
advance(1 + name.length);
|
}
|
} else {
|
decodedText += "&";
|
advance(1);
|
}
|
} else {
|
const hex = head[0] === "&#x";
|
const pattern = hex ? /^&#x([0-9a-f]+);?/i : /^&#([0-9]+);?/;
|
const body = pattern.exec(rawText);
|
if (!body) {
|
decodedText += head[0];
|
advance(head[0].length);
|
} else {
|
let cp = Number.parseInt(body[1], hex ? 16 : 10);
|
if (cp === 0) {
|
cp = 65533;
|
} else if (cp > 1114111) {
|
cp = 65533;
|
} else if (cp >= 55296 && cp <= 57343) {
|
cp = 65533;
|
} else if (cp >= 64976 && cp <= 65007 || (cp & 65534) === 65534) ; else if (cp >= 1 && cp <= 8 || cp === 11 || cp >= 13 && cp <= 31 || cp >= 127 && cp <= 159) {
|
cp = CCR_REPLACEMENTS[cp] || cp;
|
}
|
decodedText += String.fromCodePoint(cp);
|
advance(body[0].length);
|
}
|
}
|
}
|
return decodedText;
|
};
|
const CCR_REPLACEMENTS = {
|
128: 8364,
|
130: 8218,
|
131: 402,
|
132: 8222,
|
133: 8230,
|
134: 8224,
|
135: 8225,
|
136: 710,
|
137: 8240,
|
138: 352,
|
139: 8249,
|
140: 338,
|
142: 381,
|
145: 8216,
|
146: 8217,
|
147: 8220,
|
148: 8221,
|
149: 8226,
|
150: 8211,
|
151: 8212,
|
152: 732,
|
153: 8482,
|
154: 353,
|
155: 8250,
|
156: 339,
|
158: 382,
|
159: 376
|
};
|
|
const isRawTextContainer = /* @__PURE__ */ makeMap(
|
"style,iframe,script,noscript",
|
true
|
);
|
const parserOptions = {
|
isVoidTag,
|
isNativeTag: (tag) => isHTMLTag(tag) || isSVGTag(tag),
|
isPreTag: (tag) => tag === "pre",
|
decodeEntities: decodeHtml,
|
isBuiltInComponent: (tag) => {
|
if (isBuiltInType(tag, `Transition`)) {
|
return TRANSITION;
|
} else if (isBuiltInType(tag, `TransitionGroup`)) {
|
return TRANSITION_GROUP;
|
}
|
},
|
// https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
|
getNamespace(tag, parent) {
|
let ns = parent ? parent.ns : 0;
|
if (parent && ns === 2) {
|
if (parent.tag === "annotation-xml") {
|
if (tag === "svg") {
|
return 1;
|
}
|
if (parent.props.some(
|
(a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
|
)) {
|
ns = 0;
|
}
|
} else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
|
ns = 0;
|
}
|
} else if (parent && ns === 1) {
|
if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
|
ns = 0;
|
}
|
}
|
if (ns === 0) {
|
if (tag === "svg") {
|
return 1;
|
}
|
if (tag === "math") {
|
return 2;
|
}
|
}
|
return ns;
|
},
|
// https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
|
getTextMode({ tag, ns }) {
|
if (ns === 0) {
|
if (tag === "textarea" || tag === "title") {
|
return 1;
|
}
|
if (isRawTextContainer(tag)) {
|
return 2;
|
}
|
}
|
return 0;
|
}
|
};
|
|
const transformStyle = (node) => {
|
if (node.type === 1) {
|
node.props.forEach((p, i) => {
|
if (p.type === 6 && p.name === "style" && p.value) {
|
node.props[i] = {
|
type: 7,
|
name: `bind`,
|
arg: createSimpleExpression(`style`, true, p.loc),
|
exp: parseInlineCSS(p.value.content, p.loc),
|
modifiers: [],
|
loc: p.loc
|
};
|
}
|
});
|
}
|
};
|
const parseInlineCSS = (cssText, loc) => {
|
const normalized = parseStringStyle(cssText);
|
return createSimpleExpression(
|
JSON.stringify(normalized),
|
false,
|
loc,
|
3
|
);
|
};
|
|
function createDOMCompilerError(code, loc) {
|
return createCompilerError(
|
code,
|
loc,
|
DOMErrorMessages
|
);
|
}
|
const DOMErrorMessages = {
|
[53]: `v-html is missing expression.`,
|
[54]: `v-html will override element children.`,
|
[55]: `v-text is missing expression.`,
|
[56]: `v-text will override element children.`,
|
[57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
|
[58]: `v-model argument is not supported on plain elements.`,
|
[59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
|
[60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
|
[61]: `v-show is missing expression.`,
|
[62]: `<Transition> expects exactly one child element or component.`,
|
[63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
|
};
|
|
const transformVHtml = (dir, node, context) => {
|
const { exp, loc } = dir;
|
if (!exp) {
|
context.onError(
|
createDOMCompilerError(53, loc)
|
);
|
}
|
if (node.children.length) {
|
context.onError(
|
createDOMCompilerError(54, loc)
|
);
|
node.children.length = 0;
|
}
|
return {
|
props: [
|
createObjectProperty(
|
createSimpleExpression(`innerHTML`, true, loc),
|
exp || createSimpleExpression("", true)
|
)
|
]
|
};
|
};
|
|
const transformVText = (dir, node, context) => {
|
const { exp, loc } = dir;
|
if (!exp) {
|
context.onError(
|
createDOMCompilerError(55, loc)
|
);
|
}
|
if (node.children.length) {
|
context.onError(
|
createDOMCompilerError(56, loc)
|
);
|
node.children.length = 0;
|
}
|
return {
|
props: [
|
createObjectProperty(
|
createSimpleExpression(`textContent`, true),
|
exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(
|
context.helperString(TO_DISPLAY_STRING),
|
[exp],
|
loc
|
) : createSimpleExpression("", true)
|
)
|
]
|
};
|
};
|
|
const transformModel = (dir, node, context) => {
|
const baseResult = transformModel$1(dir, node, context);
|
if (!baseResult.props.length || node.tagType === 1) {
|
return baseResult;
|
}
|
if (dir.arg) {
|
context.onError(
|
createDOMCompilerError(
|
58,
|
dir.arg.loc
|
)
|
);
|
}
|
function checkDuplicatedValue() {
|
const value = findProp(node, "value");
|
if (value) {
|
context.onError(
|
createDOMCompilerError(
|
60,
|
value.loc
|
)
|
);
|
}
|
}
|
const { tag } = node;
|
const isCustomElement = context.isCustomElement(tag);
|
if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
|
let directiveToUse = V_MODEL_TEXT;
|
let isInvalidType = false;
|
if (tag === "input" || isCustomElement) {
|
const type = findProp(node, `type`);
|
if (type) {
|
if (type.type === 7) {
|
directiveToUse = V_MODEL_DYNAMIC;
|
} else if (type.value) {
|
switch (type.value.content) {
|
case "radio":
|
directiveToUse = V_MODEL_RADIO;
|
break;
|
case "checkbox":
|
directiveToUse = V_MODEL_CHECKBOX;
|
break;
|
case "file":
|
isInvalidType = true;
|
context.onError(
|
createDOMCompilerError(
|
59,
|
dir.loc
|
)
|
);
|
break;
|
default:
|
checkDuplicatedValue();
|
break;
|
}
|
}
|
} else if (hasDynamicKeyVBind(node)) {
|
directiveToUse = V_MODEL_DYNAMIC;
|
} else {
|
checkDuplicatedValue();
|
}
|
} else if (tag === "select") {
|
directiveToUse = V_MODEL_SELECT;
|
} else {
|
checkDuplicatedValue();
|
}
|
if (!isInvalidType) {
|
baseResult.needRuntime = context.helper(directiveToUse);
|
}
|
} else {
|
context.onError(
|
createDOMCompilerError(
|
57,
|
dir.loc
|
)
|
);
|
}
|
baseResult.props = baseResult.props.filter(
|
(p) => !(p.key.type === 4 && p.key.content === "modelValue")
|
);
|
return baseResult;
|
};
|
|
const isEventOptionModifier = /* @__PURE__ */ makeMap(`passive,once,capture`);
|
const isNonKeyModifier = /* @__PURE__ */ makeMap(
|
// event propagation management
|
`stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
|
);
|
const maybeKeyModifier = /* @__PURE__ */ makeMap("left,right");
|
const isKeyboardEvent = /* @__PURE__ */ makeMap(
|
`onkeyup,onkeydown,onkeypress`,
|
true
|
);
|
const resolveModifiers = (key, modifiers, context, loc) => {
|
const keyModifiers = [];
|
const nonKeyModifiers = [];
|
const eventOptionModifiers = [];
|
for (let i = 0; i < modifiers.length; i++) {
|
const modifier = modifiers[i];
|
if (isEventOptionModifier(modifier)) {
|
eventOptionModifiers.push(modifier);
|
} else {
|
if (maybeKeyModifier(modifier)) {
|
if (isStaticExp(key)) {
|
if (isKeyboardEvent(key.content)) {
|
keyModifiers.push(modifier);
|
} else {
|
nonKeyModifiers.push(modifier);
|
}
|
} else {
|
keyModifiers.push(modifier);
|
nonKeyModifiers.push(modifier);
|
}
|
} else {
|
if (isNonKeyModifier(modifier)) {
|
nonKeyModifiers.push(modifier);
|
} else {
|
keyModifiers.push(modifier);
|
}
|
}
|
}
|
}
|
return {
|
keyModifiers,
|
nonKeyModifiers,
|
eventOptionModifiers
|
};
|
};
|
const transformClick = (key, event) => {
|
const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === "onclick";
|
return isStaticClick ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
|
`(`,
|
key,
|
`) === "onClick" ? "${event}" : (`,
|
key,
|
`)`
|
]) : key;
|
};
|
const transformOn = (dir, node, context) => {
|
return transformOn$1(dir, node, context, (baseResult) => {
|
const { modifiers } = dir;
|
if (!modifiers.length)
|
return baseResult;
|
let { key, value: handlerExp } = baseResult.props[0];
|
const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
|
if (nonKeyModifiers.includes("right")) {
|
key = transformClick(key, `onContextmenu`);
|
}
|
if (nonKeyModifiers.includes("middle")) {
|
key = transformClick(key, `onMouseup`);
|
}
|
if (nonKeyModifiers.length) {
|
handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
|
handlerExp,
|
JSON.stringify(nonKeyModifiers)
|
]);
|
}
|
if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
|
(!isStaticExp(key) || isKeyboardEvent(key.content))) {
|
handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [
|
handlerExp,
|
JSON.stringify(keyModifiers)
|
]);
|
}
|
if (eventOptionModifiers.length) {
|
const modifierPostfix = eventOptionModifiers.map(capitalize$1).join("");
|
key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
|
}
|
return {
|
props: [createObjectProperty(key, handlerExp)]
|
};
|
});
|
};
|
|
const transformShow = (dir, node, context) => {
|
const { exp, loc } = dir;
|
if (!exp) {
|
context.onError(
|
createDOMCompilerError(61, loc)
|
);
|
}
|
return {
|
props: [],
|
needRuntime: context.helper(V_SHOW)
|
};
|
};
|
|
const transformTransition = (node, context) => {
|
if (node.type === 1 && node.tagType === 1) {
|
const component = context.isBuiltInComponent(node.tag);
|
if (component === TRANSITION) {
|
return () => {
|
if (!node.children.length) {
|
return;
|
}
|
if (hasMultipleChildren(node)) {
|
context.onError(
|
createDOMCompilerError(
|
62,
|
{
|
start: node.children[0].loc.start,
|
end: node.children[node.children.length - 1].loc.end,
|
source: ""
|
}
|
)
|
);
|
}
|
const child = node.children[0];
|
if (child.type === 1) {
|
for (const p of child.props) {
|
if (p.type === 7 && p.name === "show") {
|
node.props.push({
|
type: 6,
|
name: "persisted",
|
value: void 0,
|
loc: node.loc
|
});
|
}
|
}
|
}
|
};
|
}
|
}
|
};
|
function hasMultipleChildren(node) {
|
const children = node.children = node.children.filter(
|
(c) => c.type !== 3 && !(c.type === 2 && !c.content.trim())
|
);
|
const child = children[0];
|
return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
|
}
|
|
const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
|
const stringifyStatic = (children, context, parent) => {
|
if (context.scopes.vSlot > 0) {
|
return;
|
}
|
let nc = 0;
|
let ec = 0;
|
const currentChunk = [];
|
const stringifyCurrentChunk = (currentIndex) => {
|
if (nc >= 20 || ec >= 5) {
|
const staticCall = createCallExpression(context.helper(CREATE_STATIC), [
|
JSON.stringify(
|
currentChunk.map((node) => stringifyNode(node, context)).join("")
|
).replace(expReplaceRE, `" + $1 + "`),
|
// the 2nd argument indicates the number of DOM nodes this static vnode
|
// will insert / hydrate
|
String(currentChunk.length)
|
]);
|
replaceHoist(currentChunk[0], staticCall, context);
|
if (currentChunk.length > 1) {
|
for (let i2 = 1; i2 < currentChunk.length; i2++) {
|
replaceHoist(currentChunk[i2], null, context);
|
}
|
const deleteCount = currentChunk.length - 1;
|
children.splice(currentIndex - currentChunk.length + 1, deleteCount);
|
return deleteCount;
|
}
|
}
|
return 0;
|
};
|
let i = 0;
|
for (; i < children.length; i++) {
|
const child = children[i];
|
const hoisted = getHoistedNode(child);
|
if (hoisted) {
|
const node = child;
|
const result = analyzeNode(node);
|
if (result) {
|
nc += result[0];
|
ec += result[1];
|
currentChunk.push(node);
|
continue;
|
}
|
}
|
i -= stringifyCurrentChunk(i);
|
nc = 0;
|
ec = 0;
|
currentChunk.length = 0;
|
}
|
stringifyCurrentChunk(i);
|
};
|
const getHoistedNode = (node) => (node.type === 1 && node.tagType === 0 || node.type == 12) && node.codegenNode && node.codegenNode.type === 4 && node.codegenNode.hoisted;
|
const dataAriaRE = /^(data|aria)-/;
|
const isStringifiableAttr = (name, ns) => {
|
return (ns === 0 ? isKnownHtmlAttr(name) : ns === 1 ? isKnownSvgAttr(name) : false) || dataAriaRE.test(name);
|
};
|
const replaceHoist = (node, replacement, context) => {
|
const hoistToReplace = node.codegenNode.hoisted;
|
context.hoists[context.hoists.indexOf(hoistToReplace)] = replacement;
|
};
|
const isNonStringifiable = /* @__PURE__ */ makeMap(
|
`caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
|
);
|
function analyzeNode(node) {
|
if (node.type === 1 && isNonStringifiable(node.tag)) {
|
return false;
|
}
|
if (node.type === 12) {
|
return [1, 0];
|
}
|
let nc = 1;
|
let ec = node.props.length > 0 ? 1 : 0;
|
let bailed = false;
|
const bail = () => {
|
bailed = true;
|
return false;
|
};
|
function walk(node2) {
|
for (let i = 0; i < node2.props.length; i++) {
|
const p = node2.props[i];
|
if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
|
return bail();
|
}
|
if (p.type === 7 && p.name === "bind") {
|
if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
|
return bail();
|
}
|
if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
|
return bail();
|
}
|
}
|
}
|
for (let i = 0; i < node2.children.length; i++) {
|
nc++;
|
const child = node2.children[i];
|
if (child.type === 1) {
|
if (child.props.length > 0) {
|
ec++;
|
}
|
walk(child);
|
if (bailed) {
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
return walk(node) ? [nc, ec] : false;
|
}
|
function stringifyNode(node, context) {
|
if (isString$2(node)) {
|
return node;
|
}
|
if (isSymbol$1(node)) {
|
return ``;
|
}
|
switch (node.type) {
|
case 1:
|
return stringifyElement(node, context);
|
case 2:
|
return escapeHtml(node.content);
|
case 3:
|
return `<!--${escapeHtml(node.content)}-->`;
|
case 5:
|
return escapeHtml(toDisplayString(evaluateConstant(node.content)));
|
case 8:
|
return escapeHtml(evaluateConstant(node));
|
case 12:
|
return stringifyNode(node.content, context);
|
default:
|
return "";
|
}
|
}
|
function stringifyElement(node, context) {
|
let res = `<${node.tag}`;
|
let innerHTML = "";
|
for (let i = 0; i < node.props.length; i++) {
|
const p = node.props[i];
|
if (p.type === 6) {
|
res += ` ${p.name}`;
|
if (p.value) {
|
res += `="${escapeHtml(p.value.content)}"`;
|
}
|
} else if (p.type === 7) {
|
if (p.name === "bind") {
|
const exp = p.exp;
|
if (exp.content[0] === "_") {
|
res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
|
continue;
|
}
|
if (isBooleanAttr(p.arg.content) && exp.content === "false") {
|
continue;
|
}
|
let evaluated = evaluateConstant(exp);
|
if (evaluated != null) {
|
const arg = p.arg && p.arg.content;
|
if (arg === "class") {
|
evaluated = normalizeClass(evaluated);
|
} else if (arg === "style") {
|
evaluated = stringifyStyle(normalizeStyle(evaluated));
|
}
|
res += ` ${p.arg.content}="${escapeHtml(
|
evaluated
|
)}"`;
|
}
|
} else if (p.name === "html") {
|
innerHTML = evaluateConstant(p.exp);
|
} else if (p.name === "text") {
|
innerHTML = escapeHtml(
|
toDisplayString(evaluateConstant(p.exp))
|
);
|
}
|
}
|
}
|
if (context.scopeId) {
|
res += ` ${context.scopeId}`;
|
}
|
res += `>`;
|
if (innerHTML) {
|
res += innerHTML;
|
} else {
|
for (let i = 0; i < node.children.length; i++) {
|
res += stringifyNode(node.children[i], context);
|
}
|
}
|
if (!isVoidTag(node.tag)) {
|
res += `</${node.tag}>`;
|
}
|
return res;
|
}
|
function evaluateConstant(exp) {
|
if (exp.type === 4) {
|
return new Function(`return (${exp.content})`)();
|
} else {
|
let res = ``;
|
exp.children.forEach((c) => {
|
if (isString$2(c) || isSymbol$1(c)) {
|
return;
|
}
|
if (c.type === 2) {
|
res += c.content;
|
} else if (c.type === 5) {
|
res += toDisplayString(evaluateConstant(c.content));
|
} else {
|
res += evaluateConstant(c);
|
}
|
});
|
return res;
|
}
|
}
|
|
const ignoreSideEffectTags = (node, context) => {
|
if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
|
context.onError(
|
createDOMCompilerError(
|
63,
|
node.loc
|
)
|
);
|
context.removeNode();
|
}
|
};
|
|
const DOMNodeTransforms = [
|
transformStyle,
|
...[transformTransition]
|
];
|
const DOMDirectiveTransforms = {
|
cloak: noopDirectiveTransform,
|
html: transformVHtml,
|
text: transformVText,
|
model: transformModel,
|
// override compiler-core
|
on: transformOn,
|
// override compiler-core
|
show: transformShow
|
};
|
function compile$1(template, options = {}) {
|
return baseCompile(
|
template,
|
extend({}, parserOptions, options, {
|
nodeTransforms: [
|
// ignore <script> and <tag>
|
// this is not put inside DOMNodeTransforms because that list is used
|
// by compiler-ssr to generate vnode fallback branches
|
ignoreSideEffectTags,
|
...DOMNodeTransforms,
|
...options.nodeTransforms || []
|
],
|
directiveTransforms: extend(
|
{},
|
DOMDirectiveTransforms,
|
options.directiveTransforms || {}
|
),
|
transformHoist: stringifyStatic
|
})
|
);
|
}
|
function parse$8(template, options = {}) {
|
return baseParse(template, extend({}, parserOptions, options));
|
}
|
|
var CompilerDOM = /*#__PURE__*/Object.freeze({
|
__proto__: null,
|
BASE_TRANSITION: BASE_TRANSITION,
|
CAMELIZE: CAMELIZE,
|
CAPITALIZE: CAPITALIZE,
|
CREATE_BLOCK: CREATE_BLOCK,
|
CREATE_COMMENT: CREATE_COMMENT,
|
CREATE_ELEMENT_BLOCK: CREATE_ELEMENT_BLOCK,
|
CREATE_ELEMENT_VNODE: CREATE_ELEMENT_VNODE,
|
CREATE_SLOTS: CREATE_SLOTS,
|
CREATE_STATIC: CREATE_STATIC,
|
CREATE_TEXT: CREATE_TEXT,
|
CREATE_VNODE: CREATE_VNODE,
|
DOMDirectiveTransforms: DOMDirectiveTransforms,
|
DOMNodeTransforms: DOMNodeTransforms,
|
FRAGMENT: FRAGMENT,
|
GUARD_REACTIVE_PROPS: GUARD_REACTIVE_PROPS,
|
IS_MEMO_SAME: IS_MEMO_SAME,
|
IS_REF: IS_REF,
|
KEEP_ALIVE: KEEP_ALIVE,
|
MERGE_PROPS: MERGE_PROPS,
|
NORMALIZE_CLASS: NORMALIZE_CLASS,
|
NORMALIZE_PROPS: NORMALIZE_PROPS,
|
NORMALIZE_STYLE: NORMALIZE_STYLE,
|
OPEN_BLOCK: OPEN_BLOCK,
|
POP_SCOPE_ID: POP_SCOPE_ID,
|
PUSH_SCOPE_ID: PUSH_SCOPE_ID,
|
RENDER_LIST: RENDER_LIST,
|
RENDER_SLOT: RENDER_SLOT,
|
RESOLVE_COMPONENT: RESOLVE_COMPONENT,
|
RESOLVE_DIRECTIVE: RESOLVE_DIRECTIVE,
|
RESOLVE_DYNAMIC_COMPONENT: RESOLVE_DYNAMIC_COMPONENT,
|
RESOLVE_FILTER: RESOLVE_FILTER,
|
SET_BLOCK_TRACKING: SET_BLOCK_TRACKING,
|
SUSPENSE: SUSPENSE,
|
TELEPORT: TELEPORT,
|
TO_DISPLAY_STRING: TO_DISPLAY_STRING,
|
TO_HANDLERS: TO_HANDLERS,
|
TO_HANDLER_KEY: TO_HANDLER_KEY,
|
TRANSITION: TRANSITION,
|
TRANSITION_GROUP: TRANSITION_GROUP,
|
TS_NODE_TYPES: TS_NODE_TYPES,
|
UNREF: UNREF,
|
V_MODEL_CHECKBOX: V_MODEL_CHECKBOX,
|
V_MODEL_DYNAMIC: V_MODEL_DYNAMIC,
|
V_MODEL_RADIO: V_MODEL_RADIO,
|
V_MODEL_SELECT: V_MODEL_SELECT,
|
V_MODEL_TEXT: V_MODEL_TEXT,
|
V_ON_WITH_KEYS: V_ON_WITH_KEYS,
|
V_ON_WITH_MODIFIERS: V_ON_WITH_MODIFIERS,
|
V_SHOW: V_SHOW,
|
WITH_CTX: WITH_CTX,
|
WITH_DIRECTIVES: WITH_DIRECTIVES,
|
WITH_MEMO: WITH_MEMO,
|
advancePositionWithClone: advancePositionWithClone,
|
advancePositionWithMutation: advancePositionWithMutation,
|
assert: assert,
|
baseCompile: baseCompile,
|
baseParse: baseParse,
|
buildDirectiveArgs: buildDirectiveArgs,
|
buildProps: buildProps,
|
buildSlots: buildSlots,
|
checkCompatEnabled: checkCompatEnabled,
|
compile: compile$1,
|
convertToBlock: convertToBlock,
|
createArrayExpression: createArrayExpression,
|
createAssignmentExpression: createAssignmentExpression,
|
createBlockStatement: createBlockStatement,
|
createCacheExpression: createCacheExpression,
|
createCallExpression: createCallExpression,
|
createCompilerError: createCompilerError,
|
createCompoundExpression: createCompoundExpression,
|
createConditionalExpression: createConditionalExpression,
|
createDOMCompilerError: createDOMCompilerError,
|
createForLoopParams: createForLoopParams,
|
createFunctionExpression: createFunctionExpression,
|
createIfStatement: createIfStatement,
|
createInterpolation: createInterpolation,
|
createObjectExpression: createObjectExpression,
|
createObjectProperty: createObjectProperty,
|
createReturnStatement: createReturnStatement,
|
createRoot: createRoot,
|
createSequenceExpression: createSequenceExpression,
|
createSimpleExpression: createSimpleExpression,
|
createStructuralDirectiveTransform: createStructuralDirectiveTransform,
|
createTemplateLiteral: createTemplateLiteral,
|
createTransformContext: createTransformContext,
|
createVNodeCall: createVNodeCall,
|
extractIdentifiers: extractIdentifiers,
|
findDir: findDir,
|
findProp: findProp,
|
generate: generate,
|
generateCodeFrame: generateCodeFrame,
|
getBaseTransformPreset: getBaseTransformPreset,
|
getConstantType: getConstantType,
|
getInnerRange: getInnerRange,
|
getMemoedVNodeCall: getMemoedVNodeCall,
|
getVNodeBlockHelper: getVNodeBlockHelper,
|
getVNodeHelper: getVNodeHelper,
|
hasDynamicKeyVBind: hasDynamicKeyVBind,
|
hasScopeRef: hasScopeRef,
|
helperNameMap: helperNameMap,
|
injectProp: injectProp,
|
isBuiltInType: isBuiltInType,
|
isCoreComponent: isCoreComponent,
|
isFunctionType: isFunctionType,
|
isInDestructureAssignment: isInDestructureAssignment,
|
isMemberExpression: isMemberExpression,
|
isMemberExpressionBrowser: isMemberExpressionBrowser,
|
isMemberExpressionNode: isMemberExpressionNode,
|
isReferencedIdentifier: isReferencedIdentifier,
|
isSimpleIdentifier: isSimpleIdentifier,
|
isSlotOutlet: isSlotOutlet,
|
isStaticArgOf: isStaticArgOf,
|
isStaticExp: isStaticExp,
|
isStaticProperty: isStaticProperty,
|
isStaticPropertyKey: isStaticPropertyKey,
|
isTemplateNode: isTemplateNode,
|
isText: isText$1,
|
isVSlot: isVSlot,
|
locStub: locStub,
|
noopDirectiveTransform: noopDirectiveTransform,
|
parse: parse$8,
|
parserOptions: parserOptions,
|
processExpression: processExpression,
|
processFor: processFor,
|
processIf: processIf,
|
processSlotOutlet: processSlotOutlet,
|
registerRuntimeHelpers: registerRuntimeHelpers,
|
resolveComponentType: resolveComponentType,
|
stringifyExpression: stringifyExpression,
|
toValidAssetId: toValidAssetId,
|
trackSlotScopes: trackSlotScopes,
|
trackVForSlotScopes: trackVForSlotScopes,
|
transform: transform$1,
|
transformBind: transformBind,
|
transformElement: transformElement,
|
transformExpression: transformExpression,
|
transformModel: transformModel$1,
|
transformOn: transformOn$1,
|
transformStyle: transformStyle,
|
traverseNode: traverseNode,
|
walkBlockDeclarations: walkBlockDeclarations,
|
walkFunctionParams: walkFunctionParams,
|
walkIdentifiers: walkIdentifiers,
|
warnDeprecation: warnDeprecation
|
});
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
//
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
// copy of this software and associated documentation files (the
|
// "Software"), to deal in the Software without restriction, including
|
// without limitation the rights to use, copy, modify, merge, publish,
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
// persons to whom the Software is furnished to do so, subject to the
|
// following conditions:
|
//
|
// The above copyright notice and this permission notice shall be included
|
// in all copies or substantial portions of the Software.
|
//
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
// resolves . and .. elements in a path array with directory names there
|
// must be no slashes, empty elements, or device names (c:\) in the array
|
// (so also no leading and trailing slashes - it does not distinguish
|
// relative and absolute paths)
|
function normalizeArray(parts, allowAboveRoot) {
|
// if the path tries to go above the root, `up` ends up > 0
|
var up = 0;
|
for (var i = parts.length - 1; i >= 0; i--) {
|
var last = parts[i];
|
if (last === '.') {
|
parts.splice(i, 1);
|
} else if (last === '..') {
|
parts.splice(i, 1);
|
up++;
|
} else if (up) {
|
parts.splice(i, 1);
|
up--;
|
}
|
}
|
|
// if the path is allowed to go above the root, restore leading ..s
|
if (allowAboveRoot) {
|
for (; up--; up) {
|
parts.unshift('..');
|
}
|
}
|
|
return parts;
|
}
|
|
// Split a filename into [root, dir, basename, ext], unix version
|
// 'root' is just a slash, or nothing.
|
var splitPathRe =
|
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
var splitPath = function(filename) {
|
return splitPathRe.exec(filename).slice(1);
|
};
|
|
// path.resolve([from ...], to)
|
// posix version
|
function resolve$2() {
|
var resolvedPath = '',
|
resolvedAbsolute = false;
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
var path = (i >= 0) ? arguments[i] : '/';
|
|
// Skip empty and invalid entries
|
if (typeof path !== 'string') {
|
throw new TypeError('Arguments to path.resolve must be strings');
|
} else if (!path) {
|
continue;
|
}
|
|
resolvedPath = path + '/' + resolvedPath;
|
resolvedAbsolute = path.charAt(0) === '/';
|
}
|
|
// At this point the path should be resolved to a full absolute path, but
|
// handle relative paths to be safe (might happen when process.cwd() fails)
|
|
// Normalize the path
|
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
|
return !!p;
|
}), !resolvedAbsolute).join('/');
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
}
|
// path.normalize(path)
|
// posix version
|
function normalize$1(path) {
|
var isPathAbsolute = isAbsolute$1(path),
|
trailingSlash = substr(path, -1) === '/';
|
|
// Normalize the path
|
path = normalizeArray(filter(path.split('/'), function(p) {
|
return !!p;
|
}), !isPathAbsolute).join('/');
|
|
if (!path && !isPathAbsolute) {
|
path = '.';
|
}
|
if (path && trailingSlash) {
|
path += '/';
|
}
|
|
return (isPathAbsolute ? '/' : '') + path;
|
}
|
// posix version
|
function isAbsolute$1(path) {
|
return path.charAt(0) === '/';
|
}
|
|
// posix version
|
function join$1() {
|
var paths = Array.prototype.slice.call(arguments, 0);
|
return normalize$1(filter(paths, function(p, index) {
|
if (typeof p !== 'string') {
|
throw new TypeError('Arguments to path.join must be strings');
|
}
|
return p;
|
}).join('/'));
|
}
|
|
|
// path.relative(from, to)
|
// posix version
|
function relative$1(from, to) {
|
from = resolve$2(from).substr(1);
|
to = resolve$2(to).substr(1);
|
|
function trim(arr) {
|
var start = 0;
|
for (; start < arr.length; start++) {
|
if (arr[start] !== '') break;
|
}
|
|
var end = arr.length - 1;
|
for (; end >= 0; end--) {
|
if (arr[end] !== '') break;
|
}
|
|
if (start > end) return [];
|
return arr.slice(start, end - start + 1);
|
}
|
|
var fromParts = trim(from.split('/'));
|
var toParts = trim(to.split('/'));
|
|
var length = Math.min(fromParts.length, toParts.length);
|
var samePartsLength = length;
|
for (var i = 0; i < length; i++) {
|
if (fromParts[i] !== toParts[i]) {
|
samePartsLength = i;
|
break;
|
}
|
}
|
|
var outputParts = [];
|
for (var i = samePartsLength; i < fromParts.length; i++) {
|
outputParts.push('..');
|
}
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
|
return outputParts.join('/');
|
}
|
|
var sep$1 = '/';
|
var delimiter$1 = ':';
|
|
function dirname$2(path) {
|
var result = splitPath(path),
|
root = result[0],
|
dir = result[1];
|
|
if (!root && !dir) {
|
// No dirname whatsoever
|
return '.';
|
}
|
|
if (dir) {
|
// It has a dirname, strip trailing slash
|
dir = dir.substr(0, dir.length - 1);
|
}
|
|
return root + dir;
|
}
|
|
function basename(path, ext) {
|
var f = splitPath(path)[2];
|
// TODO: make this comparison case-insensitive on windows?
|
if (ext && f.substr(-1 * ext.length) === ext) {
|
f = f.substr(0, f.length - ext.length);
|
}
|
return f;
|
}
|
|
|
function extname(path) {
|
return splitPath(path)[3];
|
}
|
var path = {
|
extname: extname,
|
basename: basename,
|
dirname: dirname$2,
|
sep: sep$1,
|
delimiter: delimiter$1,
|
relative: relative$1,
|
join: join$1,
|
isAbsolute: isAbsolute$1,
|
normalize: normalize$1,
|
resolve: resolve$2
|
};
|
function filter (xs, f) {
|
if (xs.filter) return xs.filter(f);
|
var res = [];
|
for (var i = 0; i < xs.length; i++) {
|
if (f(xs[i], i, xs)) res.push(xs[i]);
|
}
|
return res;
|
}
|
|
// String.prototype.substr - negative index don't work in IE8
|
var substr = 'ab'.substr(-1) === 'b' ?
|
function (str, start, len) { return str.substr(start, len) } :
|
function (str, start, len) {
|
if (start < 0) start = str.length + start;
|
return str.substr(start, len);
|
}
|
;
|
|
var _polyfillNode_path = /*#__PURE__*/Object.freeze({
|
__proto__: null,
|
basename: basename,
|
default: path,
|
delimiter: delimiter$1,
|
dirname: dirname$2,
|
extname: extname,
|
isAbsolute: isAbsolute$1,
|
join: join$1,
|
normalize: normalize$1,
|
relative: relative$1,
|
resolve: resolve$2,
|
sep: sep$1
|
});
|
|
const UNKNOWN_TYPE = "Unknown";
|
function resolveObjectKey(node, computed) {
|
switch (node.type) {
|
case "StringLiteral":
|
case "NumericLiteral":
|
return String(node.value);
|
case "Identifier":
|
if (!computed)
|
return node.name;
|
}
|
return void 0;
|
}
|
function concatStrings(strs) {
|
return strs.filter((s) => !!s).join(", ");
|
}
|
function isLiteralNode(node) {
|
return node.type.endsWith("Literal");
|
}
|
function unwrapTSNode(node) {
|
if (TS_NODE_TYPES.includes(node.type)) {
|
return unwrapTSNode(node.expression);
|
} else {
|
return node;
|
}
|
}
|
function isCallOf(node, test) {
|
return !!(node && test && node.type === "CallExpression" && node.callee.type === "Identifier" && (typeof test === "string" ? node.callee.name === test : test(node.callee.name)));
|
}
|
function toRuntimeTypeString(types) {
|
return types.length > 1 ? `[${types.join(", ")}]` : types[0];
|
}
|
function getImportedName(specifier) {
|
if (specifier.type === "ImportSpecifier")
|
return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
|
else if (specifier.type === "ImportNamespaceSpecifier")
|
return "*";
|
return "default";
|
}
|
function getId(node) {
|
return node.type === "Identifier" ? node.name : node.type === "StringLiteral" ? node.value : null;
|
}
|
const normalize = (path.posix || path).normalize;
|
const windowsSlashRE = /\\/g;
|
function normalizePath(p) {
|
return normalize(p.replace(windowsSlashRE, "/"));
|
}
|
const joinPaths = (path.posix || path).join;
|
const escapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
|
function getEscapedKey(key) {
|
return escapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
|
}
|
|
function pad$1 (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$2(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$2 (o) {
|
return Object.prototype.toString.call(o);
|
}
|
|
function sum (o) {
|
return pad$1(foldValue(0, o, '', []).toString(16), 8);
|
}
|
|
var hashSum = sum;
|
|
var hash = hashSum;
|
|
const CSS_VARS_HELPER = `useCssVars`;
|
function genCssVarsFromList(vars, id, isProd, isSSR = false) {
|
return `{
|
${vars.map(
|
(key) => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd)}": (${key})`
|
).join(",\n ")}
|
}`;
|
}
|
function genVarName(id, raw, isProd) {
|
if (isProd) {
|
return hash(id + raw);
|
} else {
|
return `${id}-${raw.replace(escapeSymbolsRE, (s) => `\\${s}`)}`;
|
}
|
}
|
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;
|
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 /* inParens */;
|
let parenDepth = 0;
|
for (let i = start; i < content.length; i++) {
|
const char = content.charAt(i);
|
switch (state) {
|
case 0 /* inParens */:
|
if (char === `'`) {
|
state = 1 /* inSingleQuoteString */;
|
} else if (char === `"`) {
|
state = 2 /* inDoubleQuoteString */;
|
} else if (char === `(`) {
|
parenDepth++;
|
} else if (char === `)`) {
|
if (parenDepth > 0) {
|
parenDepth--;
|
} else {
|
return i;
|
}
|
}
|
break;
|
case 1 /* inSingleQuoteString */:
|
if (char === `'`) {
|
state = 0 /* inParens */;
|
}
|
break;
|
case 2 /* inDoubleQuoteString */:
|
if (char === `"`) {
|
state = 0 /* inParens */;
|
}
|
break;
|
}
|
}
|
return null;
|
}
|
const cssVarsPlugin = (opts) => {
|
const { id, isProd } = opts;
|
return {
|
postcssPlugin: "vue-sfc-vars",
|
Declaration(decl) {
|
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);
|
const exp = createSimpleExpression(varsExp, false);
|
const context = createTransformContext(createRoot([]), {
|
prefixIdentifiers: true,
|
inline: true,
|
bindingMetadata: bindings.__isScriptSetup === false ? void 0 : bindings
|
});
|
const transformed = processExpression(exp, context);
|
const transformedString = transformed.type === 4 ? transformed.content : transformed.children.map((c) => {
|
return typeof c === "string" ? c : c.content;
|
}).join("");
|
return `_${CSS_VARS_HELPER}(_ctx => (${transformedString}))`;
|
}
|
function genNormalScriptCssVarsCode(cssVars, bindings, id, isProd, defaultVar) {
|
return `
|
import { ${CSS_VARS_HELPER} as _${CSS_VARS_HELPER} } from 'vue'
|
const __injectCSSVars__ = () => {
|
${genCssVarsCode(
|
cssVars,
|
bindings,
|
id,
|
isProd
|
)}}
|
const __setup__ = ${defaultVar}.setup
|
${defaultVar}.setup = __setup__
|
? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
|
: __injectCSSVars__
|
`;
|
}
|
|
function createCache(size = 500) {
|
{
|
return /* @__PURE__ */ new Map();
|
}
|
}
|
|
function isImportUsed(local, sfc) {
|
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));
|
}
|
const templateUsageCheckCache = createCache();
|
function resolveTemplateUsageCheckString(sfc) {
|
const { content, ast } = sfc.template;
|
const cached = templateUsageCheckCache.get(content);
|
if (cached) {
|
return cached;
|
}
|
let code = "";
|
transform$1(createRoot([ast]), {
|
nodeTransforms: [
|
(node) => {
|
if (node.type === 1) {
|
if (!parserOptions.isNativeTag(node.tag) && !parserOptions.isBuiltInComponent(node.tag)) {
|
code += `,${camelize(node.tag)},${capitalize$1(camelize(node.tag))}`;
|
}
|
for (let i = 0; i < node.props.length; i++) {
|
const prop = node.props[i];
|
if (prop.type === 7) {
|
if (!isBuiltInDirective(prop.name)) {
|
code += `,v${capitalize$1(camelize(prop.name))}`;
|
}
|
if (prop.exp) {
|
code += `,${processExp(
|
prop.exp.content,
|
prop.name
|
)}`;
|
}
|
}
|
}
|
} else if (node.type === 5) {
|
code += `,${processExp(
|
node.content.content
|
)}`;
|
}
|
}
|
]
|
});
|
code += ";";
|
templateUsageCheckCache.set(content, code);
|
return code;
|
}
|
const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
|
function processExp(exp, dir) {
|
if (/ as\s+\w|<.*>|:/.test(exp)) {
|
if (dir === "slot") {
|
exp = `(${exp})=>{}`;
|
} else if (dir === "on") {
|
exp = `()=>{return ${exp}}`;
|
} else if (dir === "for") {
|
const inMatch = exp.match(forAliasRE);
|
if (inMatch) {
|
let [, LHS, RHS] = inMatch;
|
LHS = LHS.trim().replace(/^\(|\)$/g, "");
|
return processExp(`(${LHS})=>{}`) + processExp(RHS);
|
}
|
}
|
let ret = "";
|
const ast = parseExpression_1(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 "";
|
}
|
|
var __defProp$a = Object.defineProperty;
|
var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
|
var __hasOwnProp$a = Object.prototype.hasOwnProperty;
|
var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$a = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$a.call(b, prop))
|
__defNormalProp$a(a, prop, b[prop]);
|
if (__getOwnPropSymbols$a)
|
for (var prop of __getOwnPropSymbols$a(b)) {
|
if (__propIsEnum$a.call(b, prop))
|
__defNormalProp$a(a, prop, b[prop]);
|
}
|
return a;
|
};
|
const DEFAULT_FILENAME = "anonymous.vue";
|
const parseCache = createCache();
|
function parse$7(source, {
|
sourceMap = true,
|
filename = DEFAULT_FILENAME,
|
sourceRoot = "",
|
pad = false,
|
ignoreEmpty = true,
|
compiler = CompilerDOM
|
} = {}) {
|
const sourceKey = source + sourceMap + filename + sourceRoot + pad + compiler.parse;
|
const cache = parseCache.get(sourceKey);
|
if (cache) {
|
return cache;
|
}
|
const descriptor = {
|
filename,
|
source,
|
template: null,
|
script: null,
|
scriptSetup: null,
|
styles: [],
|
customBlocks: [],
|
cssVars: [],
|
slotted: false,
|
shouldForceReload: (prevImports) => hmrShouldReload(prevImports, descriptor)
|
};
|
const errors = [];
|
const ast = compiler.parse(source, {
|
// there are no components at SFC parsing level
|
isNativeTag: () => true,
|
// preserve all whitespaces
|
isPreTag: () => true,
|
getTextMode: ({ tag, props }, parent) => {
|
if (!parent && tag !== "template" || // <template lang="xxx"> should also be treated as raw text
|
tag === "template" && props.some(
|
(p) => p.type === 6 && p.name === "lang" && p.value && p.value.content && p.value.content !== "html"
|
)) {
|
return 2;
|
} else {
|
return 0;
|
}
|
},
|
onError: (e) => {
|
errors.push(e);
|
}
|
});
|
ast.children.forEach((node) => {
|
if (node.type !== 1) {
|
return;
|
}
|
if (ignoreEmpty && node.tag !== "template" && isEmpty(node) && !hasSrc(node)) {
|
return;
|
}
|
switch (node.tag) {
|
case "template":
|
if (!descriptor.template) {
|
const templateBlock = descriptor.template = createBlock(
|
node,
|
source,
|
false
|
);
|
templateBlock.ast = node;
|
if (templateBlock.attrs.functional) {
|
const err = new SyntaxError(
|
`<template functional> is no longer supported in Vue 3, since functional components no longer have significant performance difference from stateful ones. Just use a normal <template> instead.`
|
);
|
err.loc = node.props.find((p) => p.name === "functional").loc;
|
errors.push(err);
|
}
|
} else {
|
errors.push(createDuplicateBlockError(node));
|
}
|
break;
|
case "script":
|
const scriptBlock = createBlock(node, source, pad);
|
const isSetup = !!scriptBlock.attrs.setup;
|
if (isSetup && !descriptor.scriptSetup) {
|
descriptor.scriptSetup = scriptBlock;
|
break;
|
}
|
if (!isSetup && !descriptor.script) {
|
descriptor.script = scriptBlock;
|
break;
|
}
|
errors.push(createDuplicateBlockError(node, isSetup));
|
break;
|
case "style":
|
const styleBlock = createBlock(node, source, pad);
|
if (styleBlock.attrs.vars) {
|
errors.push(
|
new SyntaxError(
|
`<style vars> has been replaced by a new proposal: https://github.com/vuejs/rfcs/pull/231`
|
)
|
);
|
}
|
descriptor.styles.push(styleBlock);
|
break;
|
default:
|
descriptor.customBlocks.push(createBlock(node, source, pad));
|
break;
|
}
|
});
|
if (!descriptor.template && !descriptor.script && !descriptor.scriptSetup) {
|
errors.push(
|
new SyntaxError(
|
`At least one <template> or <script> is required in a single file component.`
|
)
|
);
|
}
|
if (descriptor.scriptSetup) {
|
if (descriptor.scriptSetup.src) {
|
errors.push(
|
new SyntaxError(
|
`<script setup> cannot use the "src" attribute because its syntax will be ambiguous outside of the component.`
|
)
|
);
|
descriptor.scriptSetup = null;
|
}
|
if (descriptor.script && descriptor.script.src) {
|
errors.push(
|
new SyntaxError(
|
`<script> cannot use the "src" attribute when <script setup> is also present because they must be processed together.`
|
)
|
);
|
descriptor.script = null;
|
}
|
}
|
if (sourceMap) {
|
const genMap = (block) => {
|
if (block && !block.src) {
|
block.map = generateSourceMap(
|
filename,
|
source,
|
block.content,
|
sourceRoot,
|
!pad || block.type === "template" ? block.loc.start.line - 1 : 0
|
);
|
}
|
};
|
genMap(descriptor.template);
|
genMap(descriptor.script);
|
descriptor.styles.forEach(genMap);
|
descriptor.customBlocks.forEach(genMap);
|
}
|
descriptor.cssVars = parseCssVars(descriptor);
|
const slottedRE = /(?:::v-|:)slotted\(/;
|
descriptor.slotted = descriptor.styles.some(
|
(s) => s.scoped && slottedRE.test(s.content)
|
);
|
const result = {
|
descriptor,
|
errors
|
};
|
parseCache.set(sourceKey, result);
|
return result;
|
}
|
function createDuplicateBlockError(node, isScriptSetup = false) {
|
const err = new SyntaxError(
|
`Single file component can contain only one <${node.tag}${isScriptSetup ? ` setup` : ``}> element`
|
);
|
err.loc = node.loc;
|
return err;
|
}
|
function createBlock(node, source, pad) {
|
const type = node.tag;
|
let { start, end } = node.loc;
|
let content = "";
|
if (node.children.length) {
|
start = node.children[0].loc.start;
|
end = node.children[node.children.length - 1].loc.end;
|
content = source.slice(start.offset, end.offset);
|
} else {
|
const offset = node.loc.source.indexOf(`</`);
|
if (offset > -1) {
|
start = {
|
line: start.line,
|
column: start.column + offset,
|
offset: start.offset + offset
|
};
|
}
|
end = __spreadValues$a({}, start);
|
}
|
const loc = {
|
source: content,
|
start,
|
end
|
};
|
const attrs = {};
|
const block = {
|
type,
|
content,
|
loc,
|
attrs
|
};
|
if (pad) {
|
block.content = padContent(source, block, pad) + block.content;
|
}
|
node.props.forEach((p) => {
|
if (p.type === 6) {
|
attrs[p.name] = p.value ? p.value.content || true : true;
|
if (p.name === "lang") {
|
block.lang = p.value && p.value.content;
|
} else if (p.name === "src") {
|
block.src = p.value && p.value.content;
|
} else if (type === "style") {
|
if (p.name === "scoped") {
|
block.scoped = true;
|
} else if (p.name === "module") {
|
block.module = attrs[p.name];
|
}
|
} else if (type === "script" && p.name === "setup") {
|
block.setup = attrs.setup;
|
}
|
}
|
});
|
return block;
|
}
|
const splitRE = /\r?\n/g;
|
const emptyRE = /^(?:\/\/)?\s*$/;
|
const replaceRE = /./g;
|
function generateSourceMap(filename, source, generated, sourceRoot, lineOffset) {
|
const map = new SourceMapGenerator$6({
|
file: filename.replace(/\\/g, "/"),
|
sourceRoot: sourceRoot.replace(/\\/g, "/")
|
});
|
map.setSourceContent(filename, source);
|
generated.split(splitRE).forEach((line, index) => {
|
if (!emptyRE.test(line)) {
|
const originalLine = index + 1 + lineOffset;
|
const generatedLine = index + 1;
|
for (let i = 0; i < line.length; i++) {
|
if (!/\s/.test(line[i])) {
|
map.addMapping({
|
source: filename,
|
original: {
|
line: originalLine,
|
column: i
|
},
|
generated: {
|
line: generatedLine,
|
column: i
|
}
|
});
|
}
|
}
|
}
|
});
|
return JSON.parse(map.toString());
|
}
|
function padContent(content, block, pad) {
|
content = content.slice(0, block.loc.start.offset);
|
if (pad === "space") {
|
return content.replace(replaceRE, " ");
|
} else {
|
const offset = content.split(splitRE).length;
|
const padChar = block.type === "script" && !block.lang ? "//\n" : "\n";
|
return Array(offset).join(padChar);
|
}
|
}
|
function hasSrc(node) {
|
return node.props.some((p) => {
|
if (p.type !== 6) {
|
return false;
|
}
|
return p.name === "src";
|
});
|
}
|
function isEmpty(node) {
|
for (let i = 0; i < node.children.length; i++) {
|
const child = node.children[i];
|
if (child.type !== 2 || child.content.trim() !== "") {
|
return false;
|
}
|
}
|
return true;
|
}
|
function hmrShouldReload(prevImports, next) {
|
if (!next.scriptSetup || next.scriptSetup.lang !== "ts" && next.scriptSetup.lang !== "tsx") {
|
return false;
|
}
|
for (const key in prevImports) {
|
if (!prevImports[key].isUsedInTemplate && isImportUsed(key, next)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
var global$1 = (typeof global !== "undefined" ? global :
|
typeof self !== "undefined" ? self :
|
typeof window !== "undefined" ? window : {});
|
|
/*! https://mths.be/punycode v1.4.1 by @mathias */
|
|
|
/** Highest positive signed 32-bit float value */
|
var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
|
|
/** Bootstring parameters */
|
var base = 36;
|
var tMin = 1;
|
var tMax = 26;
|
var skew = 38;
|
var damp = 700;
|
var initialBias = 72;
|
var initialN = 128; // 0x80
|
var delimiter = '-'; // '\x2D'
|
var regexNonASCII = /[^\x20-\x7E]/; // unprintable ASCII chars + non-ASCII chars
|
var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
|
|
/** Error messages */
|
var errors = {
|
'overflow': 'Overflow: input needs wider integers to process',
|
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
|
'invalid-input': 'Invalid input'
|
};
|
|
/** Convenience shortcuts */
|
var baseMinusTMin = base - tMin;
|
var floor = Math.floor;
|
var stringFromCharCode = String.fromCharCode;
|
|
/*--------------------------------------------------------------------------*/
|
|
/**
|
* A generic error utility function.
|
* @private
|
* @param {String} type The error type.
|
* @returns {Error} Throws a `RangeError` with the applicable error message.
|
*/
|
function error(type) {
|
throw new RangeError(errors[type]);
|
}
|
|
/**
|
* A generic `Array#map` utility function.
|
* @private
|
* @param {Array} array The array to iterate over.
|
* @param {Function} callback The function that gets called for every array
|
* item.
|
* @returns {Array} A new array of values returned by the callback function.
|
*/
|
function map$1(array, fn) {
|
var length = array.length;
|
var result = [];
|
while (length--) {
|
result[length] = fn(array[length]);
|
}
|
return result;
|
}
|
|
/**
|
* A simple `Array#map`-like wrapper to work with domain name strings or email
|
* addresses.
|
* @private
|
* @param {String} domain The domain name or email address.
|
* @param {Function} callback The function that gets called for every
|
* character.
|
* @returns {Array} A new string of characters returned by the callback
|
* function.
|
*/
|
function mapDomain(string, fn) {
|
var parts = string.split('@');
|
var result = '';
|
if (parts.length > 1) {
|
// In email addresses, only the domain name should be punycoded. Leave
|
// the local part (i.e. everything up to `@`) intact.
|
result = parts[0] + '@';
|
string = parts[1];
|
}
|
// Avoid `split(regex)` for IE8 compatibility. See #17.
|
string = string.replace(regexSeparators, '\x2E');
|
var labels = string.split('.');
|
var encoded = map$1(labels, fn).join('.');
|
return result + encoded;
|
}
|
|
/**
|
* Creates an array containing the numeric code points of each Unicode
|
* character in the string. While JavaScript uses UCS-2 internally,
|
* this function will convert a pair of surrogate halves (each of which
|
* UCS-2 exposes as separate characters) into a single code point,
|
* matching UTF-16.
|
* @see `punycode.ucs2.encode`
|
* @see <https://mathiasbynens.be/notes/javascript-encoding>
|
* @memberOf punycode.ucs2
|
* @name decode
|
* @param {String} string The Unicode input string (UCS-2).
|
* @returns {Array} The new array of code points.
|
*/
|
function ucs2decode(string) {
|
var output = [],
|
counter = 0,
|
length = string.length,
|
value,
|
extra;
|
while (counter < length) {
|
value = string.charCodeAt(counter++);
|
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
|
// high surrogate, and there is a next character
|
extra = string.charCodeAt(counter++);
|
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
|
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
|
} else {
|
// unmatched surrogate; only append this code unit, in case the next
|
// code unit is the high surrogate of a surrogate pair
|
output.push(value);
|
counter--;
|
}
|
} else {
|
output.push(value);
|
}
|
}
|
return output;
|
}
|
|
/**
|
* Converts a digit/integer into a basic code point.
|
* @see `basicToDigit()`
|
* @private
|
* @param {Number} digit The numeric value of a basic code point.
|
* @returns {Number} The basic code point whose value (when used for
|
* representing integers) is `digit`, which needs to be in the range
|
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
|
* used; else, the lowercase form is used. The behavior is undefined
|
* if `flag` is non-zero and `digit` has no uppercase form.
|
*/
|
function digitToBasic(digit, flag) {
|
// 0..25 map to ASCII a..z or A..Z
|
// 26..35 map to ASCII 0..9
|
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
|
}
|
|
/**
|
* Bias adaptation function as per section 3.4 of RFC 3492.
|
* https://tools.ietf.org/html/rfc3492#section-3.4
|
* @private
|
*/
|
function adapt(delta, numPoints, firstTime) {
|
var k = 0;
|
delta = firstTime ? floor(delta / damp) : delta >> 1;
|
delta += floor(delta / numPoints);
|
for ( /* no initialization */ ; delta > baseMinusTMin * tMax >> 1; k += base) {
|
delta = floor(delta / baseMinusTMin);
|
}
|
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
|
}
|
|
/**
|
* Converts a string of Unicode symbols (e.g. a domain name label) to a
|
* Punycode string of ASCII-only symbols.
|
* @memberOf punycode
|
* @param {String} input The string of Unicode symbols.
|
* @returns {String} The resulting Punycode string of ASCII-only symbols.
|
*/
|
function encode$1(input) {
|
var n,
|
delta,
|
handledCPCount,
|
basicLength,
|
bias,
|
j,
|
m,
|
q,
|
k,
|
t,
|
currentValue,
|
output = [],
|
/** `inputLength` will hold the number of code points in `input`. */
|
inputLength,
|
/** Cached calculation results */
|
handledCPCountPlusOne,
|
baseMinusT,
|
qMinusT;
|
|
// Convert the input in UCS-2 to Unicode
|
input = ucs2decode(input);
|
|
// Cache the length
|
inputLength = input.length;
|
|
// Initialize the state
|
n = initialN;
|
delta = 0;
|
bias = initialBias;
|
|
// Handle the basic code points
|
for (j = 0; j < inputLength; ++j) {
|
currentValue = input[j];
|
if (currentValue < 0x80) {
|
output.push(stringFromCharCode(currentValue));
|
}
|
}
|
|
handledCPCount = basicLength = output.length;
|
|
// `handledCPCount` is the number of code points that have been handled;
|
// `basicLength` is the number of basic code points.
|
|
// Finish the basic string - if it is not empty - with a delimiter
|
if (basicLength) {
|
output.push(delimiter);
|
}
|
|
// Main encoding loop:
|
while (handledCPCount < inputLength) {
|
|
// All non-basic code points < n have been handled already. Find the next
|
// larger one:
|
for (m = maxInt, j = 0; j < inputLength; ++j) {
|
currentValue = input[j];
|
if (currentValue >= n && currentValue < m) {
|
m = currentValue;
|
}
|
}
|
|
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
|
// but guard against overflow
|
handledCPCountPlusOne = handledCPCount + 1;
|
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
|
error('overflow');
|
}
|
|
delta += (m - n) * handledCPCountPlusOne;
|
n = m;
|
|
for (j = 0; j < inputLength; ++j) {
|
currentValue = input[j];
|
|
if (currentValue < n && ++delta > maxInt) {
|
error('overflow');
|
}
|
|
if (currentValue == n) {
|
// Represent delta as a generalized variable-length integer
|
for (q = delta, k = base; /* no condition */ ; k += base) {
|
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
|
if (q < t) {
|
break;
|
}
|
qMinusT = q - t;
|
baseMinusT = base - t;
|
output.push(
|
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
|
);
|
q = floor(qMinusT / baseMinusT);
|
}
|
|
output.push(stringFromCharCode(digitToBasic(q, 0)));
|
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
|
delta = 0;
|
++handledCPCount;
|
}
|
}
|
|
++delta;
|
++n;
|
|
}
|
return output.join('');
|
}
|
|
/**
|
* Converts a Unicode string representing a domain name or an email address to
|
* Punycode. Only the non-ASCII parts of the domain name will be converted,
|
* i.e. it doesn't matter if you call it with a domain that's already in
|
* ASCII.
|
* @memberOf punycode
|
* @param {String} input The domain name or email address to convert, as a
|
* Unicode string.
|
* @returns {String} The Punycode representation of the given domain name or
|
* email address.
|
*/
|
function toASCII(input) {
|
return mapDomain(input, function(string) {
|
return regexNonASCII.test(string) ?
|
'xn--' + encode$1(string) :
|
string;
|
});
|
}
|
|
var lookup = [];
|
var revLookup = [];
|
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
|
var inited = false;
|
function init () {
|
inited = true;
|
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
for (var i = 0, len = code.length; i < len; ++i) {
|
lookup[i] = code[i];
|
revLookup[code.charCodeAt(i)] = i;
|
}
|
|
revLookup['-'.charCodeAt(0)] = 62;
|
revLookup['_'.charCodeAt(0)] = 63;
|
}
|
|
function toByteArray (b64) {
|
if (!inited) {
|
init();
|
}
|
var i, j, l, tmp, placeHolders, arr;
|
var len = b64.length;
|
|
if (len % 4 > 0) {
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
}
|
|
// the number of equal signs (place holders)
|
// if there are two placeholders, than the two characters before it
|
// represent one byte
|
// if there is only one, then the three characters before it represent 2 bytes
|
// this is just a cheap hack to not do indexOf twice
|
placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;
|
|
// base64 is 4/3 + up to two characters of the original data
|
arr = new Arr(len * 3 / 4 - placeHolders);
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
l = placeHolders > 0 ? len - 4 : len;
|
|
var L = 0;
|
|
for (i = 0, j = 0; i < l; i += 4, j += 3) {
|
tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)];
|
arr[L++] = (tmp >> 16) & 0xFF;
|
arr[L++] = (tmp >> 8) & 0xFF;
|
arr[L++] = tmp & 0xFF;
|
}
|
|
if (placeHolders === 2) {
|
tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);
|
arr[L++] = tmp & 0xFF;
|
} else if (placeHolders === 1) {
|
tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2);
|
arr[L++] = (tmp >> 8) & 0xFF;
|
arr[L++] = tmp & 0xFF;
|
}
|
|
return arr
|
}
|
|
function tripletToBase64 (num) {
|
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
|
}
|
|
function encodeChunk (uint8, start, end) {
|
var tmp;
|
var output = [];
|
for (var i = start; i < end; i += 3) {
|
tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
|
output.push(tripletToBase64(tmp));
|
}
|
return output.join('')
|
}
|
|
function fromByteArray (uint8) {
|
if (!inited) {
|
init();
|
}
|
var tmp;
|
var len = uint8.length;
|
var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
|
var output = '';
|
var parts = [];
|
var maxChunkLength = 16383; // must be multiple of 3
|
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
|
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));
|
}
|
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
if (extraBytes === 1) {
|
tmp = uint8[len - 1];
|
output += lookup[tmp >> 2];
|
output += lookup[(tmp << 4) & 0x3F];
|
output += '==';
|
} else if (extraBytes === 2) {
|
tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
|
output += lookup[tmp >> 10];
|
output += lookup[(tmp >> 4) & 0x3F];
|
output += lookup[(tmp << 2) & 0x3F];
|
output += '=';
|
}
|
|
parts.push(output);
|
|
return parts.join('')
|
}
|
|
function read (buffer, offset, isLE, mLen, nBytes) {
|
var e, m;
|
var eLen = nBytes * 8 - mLen - 1;
|
var eMax = (1 << eLen) - 1;
|
var eBias = eMax >> 1;
|
var nBits = -7;
|
var i = isLE ? (nBytes - 1) : 0;
|
var d = isLE ? -1 : 1;
|
var s = buffer[offset + i];
|
|
i += d;
|
|
e = s & ((1 << (-nBits)) - 1);
|
s >>= (-nBits);
|
nBits += eLen;
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
m = e & ((1 << (-nBits)) - 1);
|
e >>= (-nBits);
|
nBits += mLen;
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
if (e === 0) {
|
e = 1 - eBias;
|
} else if (e === eMax) {
|
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
} else {
|
m = m + Math.pow(2, mLen);
|
e = e - eBias;
|
}
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
}
|
|
function write (buffer, value, offset, isLE, mLen, nBytes) {
|
var e, m, c;
|
var eLen = nBytes * 8 - mLen - 1;
|
var eMax = (1 << eLen) - 1;
|
var eBias = eMax >> 1;
|
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
|
var i = isLE ? 0 : (nBytes - 1);
|
var d = isLE ? 1 : -1;
|
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
|
|
value = Math.abs(value);
|
|
if (isNaN(value) || value === Infinity) {
|
m = isNaN(value) ? 1 : 0;
|
e = eMax;
|
} else {
|
e = Math.floor(Math.log(value) / Math.LN2);
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
e--;
|
c *= 2;
|
}
|
if (e + eBias >= 1) {
|
value += rt / c;
|
} else {
|
value += rt * Math.pow(2, 1 - eBias);
|
}
|
if (value * c >= 2) {
|
e++;
|
c /= 2;
|
}
|
|
if (e + eBias >= eMax) {
|
m = 0;
|
e = eMax;
|
} else if (e + eBias >= 1) {
|
m = (value * c - 1) * Math.pow(2, mLen);
|
e = e + eBias;
|
} else {
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
e = 0;
|
}
|
}
|
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
|
e = (e << mLen) | m;
|
eLen += mLen;
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
|
buffer[offset + i - d] |= s * 128;
|
}
|
|
var toString$1 = {}.toString;
|
|
var isArray$2 = Array.isArray || function (arr) {
|
return toString$1.call(arr) == '[object Array]';
|
};
|
|
/*!
|
* The buffer module from node.js, for the browser.
|
*
|
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
|
* @license MIT
|
*/
|
|
var INSPECT_MAX_BYTES = 50;
|
|
/**
|
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
* === true Use Uint8Array implementation (fastest)
|
* === false Use Object implementation (most compatible, even IE6)
|
*
|
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
|
* Opera 11.6+, iOS 4.2+.
|
*
|
* Due to various browser bugs, sometimes the Object implementation will be used even
|
* when the browser supports typed arrays.
|
*
|
* Note:
|
*
|
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
|
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
|
*
|
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
|
*
|
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
|
* incorrect length in some situations.
|
|
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
|
* get the Object implementation, which is slower but behaves correctly.
|
*/
|
Buffer$1.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
|
? global$1.TYPED_ARRAY_SUPPORT
|
: true;
|
|
/*
|
* Export kMaxLength after typed array support is determined.
|
*/
|
kMaxLength();
|
|
function kMaxLength () {
|
return Buffer$1.TYPED_ARRAY_SUPPORT
|
? 0x7fffffff
|
: 0x3fffffff
|
}
|
|
function createBuffer (that, length) {
|
if (kMaxLength() < length) {
|
throw new RangeError('Invalid typed array length')
|
}
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
// Return an augmented `Uint8Array` instance, for best performance
|
that = new Uint8Array(length);
|
that.__proto__ = Buffer$1.prototype;
|
} else {
|
// Fallback: Return an object instance of the Buffer class
|
if (that === null) {
|
that = new Buffer$1(length);
|
}
|
that.length = length;
|
}
|
|
return that
|
}
|
|
/**
|
* The Buffer constructor returns instances of `Uint8Array` that have their
|
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
|
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
|
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
|
* returns a single octet.
|
*
|
* The `Uint8Array` prototype remains unmodified.
|
*/
|
|
function Buffer$1 (arg, encodingOrOffset, length) {
|
if (!Buffer$1.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer$1)) {
|
return new Buffer$1(arg, encodingOrOffset, length)
|
}
|
|
// Common case.
|
if (typeof arg === 'number') {
|
if (typeof encodingOrOffset === 'string') {
|
throw new Error(
|
'If encoding is specified then the first argument must be a string'
|
)
|
}
|
return allocUnsafe(this, arg)
|
}
|
return from(this, arg, encodingOrOffset, length)
|
}
|
|
Buffer$1.poolSize = 8192; // not used by this implementation
|
|
// TODO: Legacy, not needed anymore. Remove in next major version.
|
Buffer$1._augment = function (arr) {
|
arr.__proto__ = Buffer$1.prototype;
|
return arr
|
};
|
|
function from (that, value, encodingOrOffset, length) {
|
if (typeof value === 'number') {
|
throw new TypeError('"value" argument must not be a number')
|
}
|
|
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
|
return fromArrayBuffer(that, value, encodingOrOffset, length)
|
}
|
|
if (typeof value === 'string') {
|
return fromString(that, value, encodingOrOffset)
|
}
|
|
return fromObject(that, value)
|
}
|
|
/**
|
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
|
* if value is a number.
|
* Buffer.from(str[, encoding])
|
* Buffer.from(array)
|
* Buffer.from(buffer)
|
* Buffer.from(arrayBuffer[, byteOffset[, length]])
|
**/
|
Buffer$1.from = function (value, encodingOrOffset, length) {
|
return from(null, value, encodingOrOffset, length)
|
};
|
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
Buffer$1.prototype.__proto__ = Uint8Array.prototype;
|
Buffer$1.__proto__ = Uint8Array;
|
if (typeof Symbol !== 'undefined' && Symbol.species &&
|
Buffer$1[Symbol.species] === Buffer$1) ;
|
}
|
|
function assertSize (size) {
|
if (typeof size !== 'number') {
|
throw new TypeError('"size" argument must be a number')
|
} else if (size < 0) {
|
throw new RangeError('"size" argument must not be negative')
|
}
|
}
|
|
function alloc (that, size, fill, encoding) {
|
assertSize(size);
|
if (size <= 0) {
|
return createBuffer(that, size)
|
}
|
if (fill !== undefined) {
|
// Only pay attention to encoding if it's a string. This
|
// prevents accidentally sending in a number that would
|
// be interpretted as a start offset.
|
return typeof encoding === 'string'
|
? createBuffer(that, size).fill(fill, encoding)
|
: createBuffer(that, size).fill(fill)
|
}
|
return createBuffer(that, size)
|
}
|
|
/**
|
* Creates a new filled Buffer instance.
|
* alloc(size[, fill[, encoding]])
|
**/
|
Buffer$1.alloc = function (size, fill, encoding) {
|
return alloc(null, size, fill, encoding)
|
};
|
|
function allocUnsafe (that, size) {
|
assertSize(size);
|
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
|
if (!Buffer$1.TYPED_ARRAY_SUPPORT) {
|
for (var i = 0; i < size; ++i) {
|
that[i] = 0;
|
}
|
}
|
return that
|
}
|
|
/**
|
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
|
* */
|
Buffer$1.allocUnsafe = function (size) {
|
return allocUnsafe(null, size)
|
};
|
/**
|
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
|
*/
|
Buffer$1.allocUnsafeSlow = function (size) {
|
return allocUnsafe(null, size)
|
};
|
|
function fromString (that, string, encoding) {
|
if (typeof encoding !== 'string' || encoding === '') {
|
encoding = 'utf8';
|
}
|
|
if (!Buffer$1.isEncoding(encoding)) {
|
throw new TypeError('"encoding" must be a valid string encoding')
|
}
|
|
var length = byteLength(string, encoding) | 0;
|
that = createBuffer(that, length);
|
|
var actual = that.write(string, encoding);
|
|
if (actual !== length) {
|
// Writing a hex string, for example, that contains invalid characters will
|
// cause everything after the first invalid character to be ignored. (e.g.
|
// 'abxxcd' will be treated as 'ab')
|
that = that.slice(0, actual);
|
}
|
|
return that
|
}
|
|
function fromArrayLike (that, array) {
|
var length = array.length < 0 ? 0 : checked(array.length) | 0;
|
that = createBuffer(that, length);
|
for (var i = 0; i < length; i += 1) {
|
that[i] = array[i] & 255;
|
}
|
return that
|
}
|
|
function fromArrayBuffer (that, array, byteOffset, length) {
|
array.byteLength; // this throws if `array` is not a valid ArrayBuffer
|
|
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
throw new RangeError('\'offset\' is out of bounds')
|
}
|
|
if (array.byteLength < byteOffset + (length || 0)) {
|
throw new RangeError('\'length\' is out of bounds')
|
}
|
|
if (byteOffset === undefined && length === undefined) {
|
array = new Uint8Array(array);
|
} else if (length === undefined) {
|
array = new Uint8Array(array, byteOffset);
|
} else {
|
array = new Uint8Array(array, byteOffset, length);
|
}
|
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
// Return an augmented `Uint8Array` instance, for best performance
|
that = array;
|
that.__proto__ = Buffer$1.prototype;
|
} else {
|
// Fallback: Return an object instance of the Buffer class
|
that = fromArrayLike(that, array);
|
}
|
return that
|
}
|
|
function fromObject (that, obj) {
|
if (internalIsBuffer(obj)) {
|
var len = checked(obj.length) | 0;
|
that = createBuffer(that, len);
|
|
if (that.length === 0) {
|
return that
|
}
|
|
obj.copy(that, 0, 0, len);
|
return that
|
}
|
|
if (obj) {
|
if ((typeof ArrayBuffer !== 'undefined' &&
|
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
|
if (typeof obj.length !== 'number' || isnan(obj.length)) {
|
return createBuffer(that, 0)
|
}
|
return fromArrayLike(that, obj)
|
}
|
|
if (obj.type === 'Buffer' && isArray$2(obj.data)) {
|
return fromArrayLike(that, obj.data)
|
}
|
}
|
|
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
|
}
|
|
function checked (length) {
|
// Note: cannot use `length < kMaxLength()` here because that fails when
|
// length is NaN (which is otherwise coerced to zero.)
|
if (length >= kMaxLength()) {
|
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
'size: 0x' + kMaxLength().toString(16) + ' bytes')
|
}
|
return length | 0
|
}
|
Buffer$1.isBuffer = isBuffer$1;
|
function internalIsBuffer (b) {
|
return !!(b != null && b._isBuffer)
|
}
|
|
Buffer$1.compare = function compare (a, b) {
|
if (!internalIsBuffer(a) || !internalIsBuffer(b)) {
|
throw new TypeError('Arguments must be Buffers')
|
}
|
|
if (a === b) return 0
|
|
var x = a.length;
|
var y = b.length;
|
|
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
|
if (a[i] !== b[i]) {
|
x = a[i];
|
y = b[i];
|
break
|
}
|
}
|
|
if (x < y) return -1
|
if (y < x) return 1
|
return 0
|
};
|
|
Buffer$1.isEncoding = function isEncoding (encoding) {
|
switch (String(encoding).toLowerCase()) {
|
case 'hex':
|
case 'utf8':
|
case 'utf-8':
|
case 'ascii':
|
case 'latin1':
|
case 'binary':
|
case 'base64':
|
case 'ucs2':
|
case 'ucs-2':
|
case 'utf16le':
|
case 'utf-16le':
|
return true
|
default:
|
return false
|
}
|
};
|
|
Buffer$1.concat = function concat (list, length) {
|
if (!isArray$2(list)) {
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
}
|
|
if (list.length === 0) {
|
return Buffer$1.alloc(0)
|
}
|
|
var i;
|
if (length === undefined) {
|
length = 0;
|
for (i = 0; i < list.length; ++i) {
|
length += list[i].length;
|
}
|
}
|
|
var buffer = Buffer$1.allocUnsafe(length);
|
var pos = 0;
|
for (i = 0; i < list.length; ++i) {
|
var buf = list[i];
|
if (!internalIsBuffer(buf)) {
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
}
|
buf.copy(buffer, pos);
|
pos += buf.length;
|
}
|
return buffer
|
};
|
|
function byteLength (string, encoding) {
|
if (internalIsBuffer(string)) {
|
return string.length
|
}
|
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
|
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
|
return string.byteLength
|
}
|
if (typeof string !== 'string') {
|
string = '' + string;
|
}
|
|
var len = string.length;
|
if (len === 0) return 0
|
|
// Use a for loop to avoid recursion
|
var loweredCase = false;
|
for (;;) {
|
switch (encoding) {
|
case 'ascii':
|
case 'latin1':
|
case 'binary':
|
return len
|
case 'utf8':
|
case 'utf-8':
|
case undefined:
|
return utf8ToBytes(string).length
|
case 'ucs2':
|
case 'ucs-2':
|
case 'utf16le':
|
case 'utf-16le':
|
return len * 2
|
case 'hex':
|
return len >>> 1
|
case 'base64':
|
return base64ToBytes(string).length
|
default:
|
if (loweredCase) return utf8ToBytes(string).length // assume utf8
|
encoding = ('' + encoding).toLowerCase();
|
loweredCase = true;
|
}
|
}
|
}
|
Buffer$1.byteLength = byteLength;
|
|
function slowToString (encoding, start, end) {
|
var loweredCase = false;
|
|
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
|
// property of a typed array.
|
|
// This behaves neither like String nor Uint8Array in that we set start/end
|
// to their upper/lower bounds if the value passed is out of range.
|
// undefined is handled specially as per ECMA-262 6th Edition,
|
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
|
if (start === undefined || start < 0) {
|
start = 0;
|
}
|
// Return early if start > this.length. Done here to prevent potential uint32
|
// coercion fail below.
|
if (start > this.length) {
|
return ''
|
}
|
|
if (end === undefined || end > this.length) {
|
end = this.length;
|
}
|
|
if (end <= 0) {
|
return ''
|
}
|
|
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
|
end >>>= 0;
|
start >>>= 0;
|
|
if (end <= start) {
|
return ''
|
}
|
|
if (!encoding) encoding = 'utf8';
|
|
while (true) {
|
switch (encoding) {
|
case 'hex':
|
return hexSlice(this, start, end)
|
|
case 'utf8':
|
case 'utf-8':
|
return utf8Slice(this, start, end)
|
|
case 'ascii':
|
return asciiSlice(this, start, end)
|
|
case 'latin1':
|
case 'binary':
|
return latin1Slice(this, start, end)
|
|
case 'base64':
|
return base64Slice(this, start, end)
|
|
case 'ucs2':
|
case 'ucs-2':
|
case 'utf16le':
|
case 'utf-16le':
|
return utf16leSlice(this, start, end)
|
|
default:
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
encoding = (encoding + '').toLowerCase();
|
loweredCase = true;
|
}
|
}
|
}
|
|
// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
|
// Buffer instances.
|
Buffer$1.prototype._isBuffer = true;
|
|
function swap$1 (b, n, m) {
|
var i = b[n];
|
b[n] = b[m];
|
b[m] = i;
|
}
|
|
Buffer$1.prototype.swap16 = function swap16 () {
|
var len = this.length;
|
if (len % 2 !== 0) {
|
throw new RangeError('Buffer size must be a multiple of 16-bits')
|
}
|
for (var i = 0; i < len; i += 2) {
|
swap$1(this, i, i + 1);
|
}
|
return this
|
};
|
|
Buffer$1.prototype.swap32 = function swap32 () {
|
var len = this.length;
|
if (len % 4 !== 0) {
|
throw new RangeError('Buffer size must be a multiple of 32-bits')
|
}
|
for (var i = 0; i < len; i += 4) {
|
swap$1(this, i, i + 3);
|
swap$1(this, i + 1, i + 2);
|
}
|
return this
|
};
|
|
Buffer$1.prototype.swap64 = function swap64 () {
|
var len = this.length;
|
if (len % 8 !== 0) {
|
throw new RangeError('Buffer size must be a multiple of 64-bits')
|
}
|
for (var i = 0; i < len; i += 8) {
|
swap$1(this, i, i + 7);
|
swap$1(this, i + 1, i + 6);
|
swap$1(this, i + 2, i + 5);
|
swap$1(this, i + 3, i + 4);
|
}
|
return this
|
};
|
|
Buffer$1.prototype.toString = function toString () {
|
var length = this.length | 0;
|
if (length === 0) return ''
|
if (arguments.length === 0) return utf8Slice(this, 0, length)
|
return slowToString.apply(this, arguments)
|
};
|
|
Buffer$1.prototype.equals = function equals (b) {
|
if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
if (this === b) return true
|
return Buffer$1.compare(this, b) === 0
|
};
|
|
Buffer$1.prototype.inspect = function inspect () {
|
var str = '';
|
var max = INSPECT_MAX_BYTES;
|
if (this.length > 0) {
|
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
|
if (this.length > max) str += ' ... ';
|
}
|
return '<Buffer ' + str + '>'
|
};
|
|
Buffer$1.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
|
if (!internalIsBuffer(target)) {
|
throw new TypeError('Argument must be a Buffer')
|
}
|
|
if (start === undefined) {
|
start = 0;
|
}
|
if (end === undefined) {
|
end = target ? target.length : 0;
|
}
|
if (thisStart === undefined) {
|
thisStart = 0;
|
}
|
if (thisEnd === undefined) {
|
thisEnd = this.length;
|
}
|
|
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
|
throw new RangeError('out of range index')
|
}
|
|
if (thisStart >= thisEnd && start >= end) {
|
return 0
|
}
|
if (thisStart >= thisEnd) {
|
return -1
|
}
|
if (start >= end) {
|
return 1
|
}
|
|
start >>>= 0;
|
end >>>= 0;
|
thisStart >>>= 0;
|
thisEnd >>>= 0;
|
|
if (this === target) return 0
|
|
var x = thisEnd - thisStart;
|
var y = end - start;
|
var len = Math.min(x, y);
|
|
var thisCopy = this.slice(thisStart, thisEnd);
|
var targetCopy = target.slice(start, end);
|
|
for (var i = 0; i < len; ++i) {
|
if (thisCopy[i] !== targetCopy[i]) {
|
x = thisCopy[i];
|
y = targetCopy[i];
|
break
|
}
|
}
|
|
if (x < y) return -1
|
if (y < x) return 1
|
return 0
|
};
|
|
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
|
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
|
//
|
// Arguments:
|
// - buffer - a Buffer to search
|
// - val - a string, Buffer, or number
|
// - byteOffset - an index into `buffer`; will be clamped to an int32
|
// - encoding - an optional encoding, relevant is val is a string
|
// - dir - true for indexOf, false for lastIndexOf
|
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
|
// Empty buffer means no match
|
if (buffer.length === 0) return -1
|
|
// Normalize byteOffset
|
if (typeof byteOffset === 'string') {
|
encoding = byteOffset;
|
byteOffset = 0;
|
} else if (byteOffset > 0x7fffffff) {
|
byteOffset = 0x7fffffff;
|
} else if (byteOffset < -0x80000000) {
|
byteOffset = -0x80000000;
|
}
|
byteOffset = +byteOffset; // Coerce to Number.
|
if (isNaN(byteOffset)) {
|
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
|
byteOffset = dir ? 0 : (buffer.length - 1);
|
}
|
|
// Normalize byteOffset: negative offsets start from the end of the buffer
|
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
|
if (byteOffset >= buffer.length) {
|
if (dir) return -1
|
else byteOffset = buffer.length - 1;
|
} else if (byteOffset < 0) {
|
if (dir) byteOffset = 0;
|
else return -1
|
}
|
|
// Normalize val
|
if (typeof val === 'string') {
|
val = Buffer$1.from(val, encoding);
|
}
|
|
// Finally, search either indexOf (if dir is true) or lastIndexOf
|
if (internalIsBuffer(val)) {
|
// Special case: looking for empty string/buffer always fails
|
if (val.length === 0) {
|
return -1
|
}
|
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
|
} else if (typeof val === 'number') {
|
val = val & 0xFF; // Search for a byte value [0-255]
|
if (Buffer$1.TYPED_ARRAY_SUPPORT &&
|
typeof Uint8Array.prototype.indexOf === 'function') {
|
if (dir) {
|
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
|
} else {
|
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
|
}
|
}
|
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
|
}
|
|
throw new TypeError('val must be string, number or Buffer')
|
}
|
|
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
|
var indexSize = 1;
|
var arrLength = arr.length;
|
var valLength = val.length;
|
|
if (encoding !== undefined) {
|
encoding = String(encoding).toLowerCase();
|
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
|
encoding === 'utf16le' || encoding === 'utf-16le') {
|
if (arr.length < 2 || val.length < 2) {
|
return -1
|
}
|
indexSize = 2;
|
arrLength /= 2;
|
valLength /= 2;
|
byteOffset /= 2;
|
}
|
}
|
|
function read (buf, i) {
|
if (indexSize === 1) {
|
return buf[i]
|
} else {
|
return buf.readUInt16BE(i * indexSize)
|
}
|
}
|
|
var i;
|
if (dir) {
|
var foundIndex = -1;
|
for (i = byteOffset; i < arrLength; i++) {
|
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
|
if (foundIndex === -1) foundIndex = i;
|
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
|
} else {
|
if (foundIndex !== -1) i -= i - foundIndex;
|
foundIndex = -1;
|
}
|
}
|
} else {
|
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
|
for (i = byteOffset; i >= 0; i--) {
|
var found = true;
|
for (var j = 0; j < valLength; j++) {
|
if (read(arr, i + j) !== read(val, j)) {
|
found = false;
|
break
|
}
|
}
|
if (found) return i
|
}
|
}
|
|
return -1
|
}
|
|
Buffer$1.prototype.includes = function includes (val, byteOffset, encoding) {
|
return this.indexOf(val, byteOffset, encoding) !== -1
|
};
|
|
Buffer$1.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
|
};
|
|
Buffer$1.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
|
};
|
|
function hexWrite (buf, string, offset, length) {
|
offset = Number(offset) || 0;
|
var remaining = buf.length - offset;
|
if (!length) {
|
length = remaining;
|
} else {
|
length = Number(length);
|
if (length > remaining) {
|
length = remaining;
|
}
|
}
|
|
// must be an even number of digits
|
var strLen = string.length;
|
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
|
|
if (length > strLen / 2) {
|
length = strLen / 2;
|
}
|
for (var i = 0; i < length; ++i) {
|
var parsed = parseInt(string.substr(i * 2, 2), 16);
|
if (isNaN(parsed)) return i
|
buf[offset + i] = parsed;
|
}
|
return i
|
}
|
|
function utf8Write (buf, string, offset, length) {
|
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
|
}
|
|
function asciiWrite (buf, string, offset, length) {
|
return blitBuffer(asciiToBytes(string), buf, offset, length)
|
}
|
|
function latin1Write (buf, string, offset, length) {
|
return asciiWrite(buf, string, offset, length)
|
}
|
|
function base64Write (buf, string, offset, length) {
|
return blitBuffer(base64ToBytes(string), buf, offset, length)
|
}
|
|
function ucs2Write (buf, string, offset, length) {
|
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
|
}
|
|
Buffer$1.prototype.write = function write (string, offset, length, encoding) {
|
// Buffer#write(string)
|
if (offset === undefined) {
|
encoding = 'utf8';
|
length = this.length;
|
offset = 0;
|
// Buffer#write(string, encoding)
|
} else if (length === undefined && typeof offset === 'string') {
|
encoding = offset;
|
length = this.length;
|
offset = 0;
|
// Buffer#write(string, offset[, length][, encoding])
|
} else if (isFinite(offset)) {
|
offset = offset | 0;
|
if (isFinite(length)) {
|
length = length | 0;
|
if (encoding === undefined) encoding = 'utf8';
|
} else {
|
encoding = length;
|
length = undefined;
|
}
|
// legacy write(string, encoding, offset, length) - remove in v0.13
|
} else {
|
throw new Error(
|
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
|
)
|
}
|
|
var remaining = this.length - offset;
|
if (length === undefined || length > remaining) length = remaining;
|
|
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
|
throw new RangeError('Attempt to write outside buffer bounds')
|
}
|
|
if (!encoding) encoding = 'utf8';
|
|
var loweredCase = false;
|
for (;;) {
|
switch (encoding) {
|
case 'hex':
|
return hexWrite(this, string, offset, length)
|
|
case 'utf8':
|
case 'utf-8':
|
return utf8Write(this, string, offset, length)
|
|
case 'ascii':
|
return asciiWrite(this, string, offset, length)
|
|
case 'latin1':
|
case 'binary':
|
return latin1Write(this, string, offset, length)
|
|
case 'base64':
|
// Warning: maxLength not taken into account in base64Write
|
return base64Write(this, string, offset, length)
|
|
case 'ucs2':
|
case 'ucs-2':
|
case 'utf16le':
|
case 'utf-16le':
|
return ucs2Write(this, string, offset, length)
|
|
default:
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
encoding = ('' + encoding).toLowerCase();
|
loweredCase = true;
|
}
|
}
|
};
|
|
Buffer$1.prototype.toJSON = function toJSON () {
|
return {
|
type: 'Buffer',
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
}
|
};
|
|
function base64Slice (buf, start, end) {
|
if (start === 0 && end === buf.length) {
|
return fromByteArray(buf)
|
} else {
|
return fromByteArray(buf.slice(start, end))
|
}
|
}
|
|
function utf8Slice (buf, start, end) {
|
end = Math.min(buf.length, end);
|
var res = [];
|
|
var i = start;
|
while (i < end) {
|
var firstByte = buf[i];
|
var codePoint = null;
|
var bytesPerSequence = (firstByte > 0xEF) ? 4
|
: (firstByte > 0xDF) ? 3
|
: (firstByte > 0xBF) ? 2
|
: 1;
|
|
if (i + bytesPerSequence <= end) {
|
var secondByte, thirdByte, fourthByte, tempCodePoint;
|
|
switch (bytesPerSequence) {
|
case 1:
|
if (firstByte < 0x80) {
|
codePoint = firstByte;
|
}
|
break
|
case 2:
|
secondByte = buf[i + 1];
|
if ((secondByte & 0xC0) === 0x80) {
|
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
|
if (tempCodePoint > 0x7F) {
|
codePoint = tempCodePoint;
|
}
|
}
|
break
|
case 3:
|
secondByte = buf[i + 1];
|
thirdByte = buf[i + 2];
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
|
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
|
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
|
codePoint = tempCodePoint;
|
}
|
}
|
break
|
case 4:
|
secondByte = buf[i + 1];
|
thirdByte = buf[i + 2];
|
fourthByte = buf[i + 3];
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
|
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
|
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
|
codePoint = tempCodePoint;
|
}
|
}
|
}
|
}
|
|
if (codePoint === null) {
|
// we did not generate a valid codePoint so insert a
|
// replacement char (U+FFFD) and advance only 1 byte
|
codePoint = 0xFFFD;
|
bytesPerSequence = 1;
|
} else if (codePoint > 0xFFFF) {
|
// encode to utf16 (surrogate pair dance)
|
codePoint -= 0x10000;
|
res.push(codePoint >>> 10 & 0x3FF | 0xD800);
|
codePoint = 0xDC00 | codePoint & 0x3FF;
|
}
|
|
res.push(codePoint);
|
i += bytesPerSequence;
|
}
|
|
return decodeCodePointsArray(res)
|
}
|
|
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
|
// the lowest limit is Chrome, with 0x10000 args.
|
// We go 1 magnitude less, for safety
|
var MAX_ARGUMENTS_LENGTH = 0x1000;
|
|
function decodeCodePointsArray (codePoints) {
|
var len = codePoints.length;
|
if (len <= MAX_ARGUMENTS_LENGTH) {
|
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
|
}
|
|
// Decode in chunks to avoid "call stack size exceeded".
|
var res = '';
|
var i = 0;
|
while (i < len) {
|
res += String.fromCharCode.apply(
|
String,
|
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
|
);
|
}
|
return res
|
}
|
|
function asciiSlice (buf, start, end) {
|
var ret = '';
|
end = Math.min(buf.length, end);
|
|
for (var i = start; i < end; ++i) {
|
ret += String.fromCharCode(buf[i] & 0x7F);
|
}
|
return ret
|
}
|
|
function latin1Slice (buf, start, end) {
|
var ret = '';
|
end = Math.min(buf.length, end);
|
|
for (var i = start; i < end; ++i) {
|
ret += String.fromCharCode(buf[i]);
|
}
|
return ret
|
}
|
|
function hexSlice (buf, start, end) {
|
var len = buf.length;
|
|
if (!start || start < 0) start = 0;
|
if (!end || end < 0 || end > len) end = len;
|
|
var out = '';
|
for (var i = start; i < end; ++i) {
|
out += toHex(buf[i]);
|
}
|
return out
|
}
|
|
function utf16leSlice (buf, start, end) {
|
var bytes = buf.slice(start, end);
|
var res = '';
|
for (var i = 0; i < bytes.length; i += 2) {
|
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
|
}
|
return res
|
}
|
|
Buffer$1.prototype.slice = function slice (start, end) {
|
var len = this.length;
|
start = ~~start;
|
end = end === undefined ? len : ~~end;
|
|
if (start < 0) {
|
start += len;
|
if (start < 0) start = 0;
|
} else if (start > len) {
|
start = len;
|
}
|
|
if (end < 0) {
|
end += len;
|
if (end < 0) end = 0;
|
} else if (end > len) {
|
end = len;
|
}
|
|
if (end < start) end = start;
|
|
var newBuf;
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
newBuf = this.subarray(start, end);
|
newBuf.__proto__ = Buffer$1.prototype;
|
} else {
|
var sliceLen = end - start;
|
newBuf = new Buffer$1(sliceLen, undefined);
|
for (var i = 0; i < sliceLen; ++i) {
|
newBuf[i] = this[i + start];
|
}
|
}
|
|
return newBuf
|
};
|
|
/*
|
* Need to make sure that buffer isn't trying to write out of bounds.
|
*/
|
function checkOffset (offset, ext, length) {
|
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
|
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
|
}
|
|
Buffer$1.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
|
offset = offset | 0;
|
byteLength = byteLength | 0;
|
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
|
var val = this[offset];
|
var mul = 1;
|
var i = 0;
|
while (++i < byteLength && (mul *= 0x100)) {
|
val += this[offset + i] * mul;
|
}
|
|
return val
|
};
|
|
Buffer$1.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
|
offset = offset | 0;
|
byteLength = byteLength | 0;
|
if (!noAssert) {
|
checkOffset(offset, byteLength, this.length);
|
}
|
|
var val = this[offset + --byteLength];
|
var mul = 1;
|
while (byteLength > 0 && (mul *= 0x100)) {
|
val += this[offset + --byteLength] * mul;
|
}
|
|
return val
|
};
|
|
Buffer$1.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 1, this.length);
|
return this[offset]
|
};
|
|
Buffer$1.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
return this[offset] | (this[offset + 1] << 8)
|
};
|
|
Buffer$1.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
return (this[offset] << 8) | this[offset + 1]
|
};
|
|
Buffer$1.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
return ((this[offset]) |
|
(this[offset + 1] << 8) |
|
(this[offset + 2] << 16)) +
|
(this[offset + 3] * 0x1000000)
|
};
|
|
Buffer$1.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
return (this[offset] * 0x1000000) +
|
((this[offset + 1] << 16) |
|
(this[offset + 2] << 8) |
|
this[offset + 3])
|
};
|
|
Buffer$1.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
|
offset = offset | 0;
|
byteLength = byteLength | 0;
|
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
|
var val = this[offset];
|
var mul = 1;
|
var i = 0;
|
while (++i < byteLength && (mul *= 0x100)) {
|
val += this[offset + i] * mul;
|
}
|
mul *= 0x80;
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
|
|
return val
|
};
|
|
Buffer$1.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
|
offset = offset | 0;
|
byteLength = byteLength | 0;
|
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
|
var i = byteLength;
|
var mul = 1;
|
var val = this[offset + --i];
|
while (i > 0 && (mul *= 0x100)) {
|
val += this[offset + --i] * mul;
|
}
|
mul *= 0x80;
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
|
|
return val
|
};
|
|
Buffer$1.prototype.readInt8 = function readInt8 (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 1, this.length);
|
if (!(this[offset] & 0x80)) return (this[offset])
|
return ((0xff - this[offset] + 1) * -1)
|
};
|
|
Buffer$1.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
var val = this[offset] | (this[offset + 1] << 8);
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
};
|
|
Buffer$1.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
var val = this[offset + 1] | (this[offset] << 8);
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
};
|
|
Buffer$1.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
return (this[offset]) |
|
(this[offset + 1] << 8) |
|
(this[offset + 2] << 16) |
|
(this[offset + 3] << 24)
|
};
|
|
Buffer$1.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
return (this[offset] << 24) |
|
(this[offset + 1] << 16) |
|
(this[offset + 2] << 8) |
|
(this[offset + 3])
|
};
|
|
Buffer$1.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
return read(this, offset, true, 23, 4)
|
};
|
|
Buffer$1.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
return read(this, offset, false, 23, 4)
|
};
|
|
Buffer$1.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 8, this.length);
|
return read(this, offset, true, 52, 8)
|
};
|
|
Buffer$1.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
if (!noAssert) checkOffset(offset, 8, this.length);
|
return read(this, offset, false, 52, 8)
|
};
|
|
function checkInt (buf, value, offset, ext, max, min) {
|
if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
|
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
}
|
|
Buffer$1.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
byteLength = byteLength | 0;
|
if (!noAssert) {
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
|
checkInt(this, value, offset, byteLength, maxBytes, 0);
|
}
|
|
var mul = 1;
|
var i = 0;
|
this[offset] = value & 0xFF;
|
while (++i < byteLength && (mul *= 0x100)) {
|
this[offset + i] = (value / mul) & 0xFF;
|
}
|
|
return offset + byteLength
|
};
|
|
Buffer$1.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
byteLength = byteLength | 0;
|
if (!noAssert) {
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
|
checkInt(this, value, offset, byteLength, maxBytes, 0);
|
}
|
|
var i = byteLength - 1;
|
var mul = 1;
|
this[offset + i] = value & 0xFF;
|
while (--i >= 0 && (mul *= 0x100)) {
|
this[offset + i] = (value / mul) & 0xFF;
|
}
|
|
return offset + byteLength
|
};
|
|
Buffer$1.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
|
if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
|
this[offset] = (value & 0xff);
|
return offset + 1
|
};
|
|
function objectWriteUInt16 (buf, value, offset, littleEndian) {
|
if (value < 0) value = 0xffff + value + 1;
|
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
|
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
|
(littleEndian ? i : 1 - i) * 8;
|
}
|
}
|
|
Buffer$1.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset] = (value & 0xff);
|
this[offset + 1] = (value >>> 8);
|
} else {
|
objectWriteUInt16(this, value, offset, true);
|
}
|
return offset + 2
|
};
|
|
Buffer$1.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset] = (value >>> 8);
|
this[offset + 1] = (value & 0xff);
|
} else {
|
objectWriteUInt16(this, value, offset, false);
|
}
|
return offset + 2
|
};
|
|
function objectWriteUInt32 (buf, value, offset, littleEndian) {
|
if (value < 0) value = 0xffffffff + value + 1;
|
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
|
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;
|
}
|
}
|
|
Buffer$1.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset + 3] = (value >>> 24);
|
this[offset + 2] = (value >>> 16);
|
this[offset + 1] = (value >>> 8);
|
this[offset] = (value & 0xff);
|
} else {
|
objectWriteUInt32(this, value, offset, true);
|
}
|
return offset + 4
|
};
|
|
Buffer$1.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset] = (value >>> 24);
|
this[offset + 1] = (value >>> 16);
|
this[offset + 2] = (value >>> 8);
|
this[offset + 3] = (value & 0xff);
|
} else {
|
objectWriteUInt32(this, value, offset, false);
|
}
|
return offset + 4
|
};
|
|
Buffer$1.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) {
|
var limit = Math.pow(2, 8 * byteLength - 1);
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit);
|
}
|
|
var i = 0;
|
var mul = 1;
|
var sub = 0;
|
this[offset] = value & 0xFF;
|
while (++i < byteLength && (mul *= 0x100)) {
|
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
|
sub = 1;
|
}
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
|
}
|
|
return offset + byteLength
|
};
|
|
Buffer$1.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) {
|
var limit = Math.pow(2, 8 * byteLength - 1);
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit);
|
}
|
|
var i = byteLength - 1;
|
var mul = 1;
|
var sub = 0;
|
this[offset + i] = value & 0xFF;
|
while (--i >= 0 && (mul *= 0x100)) {
|
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
|
sub = 1;
|
}
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
|
}
|
|
return offset + byteLength
|
};
|
|
Buffer$1.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
|
if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
|
if (value < 0) value = 0xff + value + 1;
|
this[offset] = (value & 0xff);
|
return offset + 1
|
};
|
|
Buffer$1.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset] = (value & 0xff);
|
this[offset + 1] = (value >>> 8);
|
} else {
|
objectWriteUInt16(this, value, offset, true);
|
}
|
return offset + 2
|
};
|
|
Buffer$1.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset] = (value >>> 8);
|
this[offset + 1] = (value & 0xff);
|
} else {
|
objectWriteUInt16(this, value, offset, false);
|
}
|
return offset + 2
|
};
|
|
Buffer$1.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset] = (value & 0xff);
|
this[offset + 1] = (value >>> 8);
|
this[offset + 2] = (value >>> 16);
|
this[offset + 3] = (value >>> 24);
|
} else {
|
objectWriteUInt32(this, value, offset, true);
|
}
|
return offset + 4
|
};
|
|
Buffer$1.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
|
value = +value;
|
offset = offset | 0;
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
|
if (value < 0) value = 0xffffffff + value + 1;
|
if (Buffer$1.TYPED_ARRAY_SUPPORT) {
|
this[offset] = (value >>> 24);
|
this[offset + 1] = (value >>> 16);
|
this[offset + 2] = (value >>> 8);
|
this[offset + 3] = (value & 0xff);
|
} else {
|
objectWriteUInt32(this, value, offset, false);
|
}
|
return offset + 4
|
};
|
|
function checkIEEE754 (buf, value, offset, ext, max, min) {
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
if (offset < 0) throw new RangeError('Index out of range')
|
}
|
|
function writeFloat (buf, value, offset, littleEndian, noAssert) {
|
if (!noAssert) {
|
checkIEEE754(buf, value, offset, 4);
|
}
|
write(buf, value, offset, littleEndian, 23, 4);
|
return offset + 4
|
}
|
|
Buffer$1.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
|
return writeFloat(this, value, offset, true, noAssert)
|
};
|
|
Buffer$1.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
|
return writeFloat(this, value, offset, false, noAssert)
|
};
|
|
function writeDouble (buf, value, offset, littleEndian, noAssert) {
|
if (!noAssert) {
|
checkIEEE754(buf, value, offset, 8);
|
}
|
write(buf, value, offset, littleEndian, 52, 8);
|
return offset + 8
|
}
|
|
Buffer$1.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
|
return writeDouble(this, value, offset, true, noAssert)
|
};
|
|
Buffer$1.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
|
return writeDouble(this, value, offset, false, noAssert)
|
};
|
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
Buffer$1.prototype.copy = function copy (target, targetStart, start, end) {
|
if (!start) start = 0;
|
if (!end && end !== 0) end = this.length;
|
if (targetStart >= target.length) targetStart = target.length;
|
if (!targetStart) targetStart = 0;
|
if (end > 0 && end < start) end = start;
|
|
// Copy 0 bytes; we're done
|
if (end === start) return 0
|
if (target.length === 0 || this.length === 0) return 0
|
|
// Fatal error conditions
|
if (targetStart < 0) {
|
throw new RangeError('targetStart out of bounds')
|
}
|
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
|
if (end < 0) throw new RangeError('sourceEnd out of bounds')
|
|
// Are we oob?
|
if (end > this.length) end = this.length;
|
if (target.length - targetStart < end - start) {
|
end = target.length - targetStart + start;
|
}
|
|
var len = end - start;
|
var i;
|
|
if (this === target && start < targetStart && targetStart < end) {
|
// descending copy from end
|
for (i = len - 1; i >= 0; --i) {
|
target[i + targetStart] = this[i + start];
|
}
|
} else if (len < 1000 || !Buffer$1.TYPED_ARRAY_SUPPORT) {
|
// ascending copy from start
|
for (i = 0; i < len; ++i) {
|
target[i + targetStart] = this[i + start];
|
}
|
} else {
|
Uint8Array.prototype.set.call(
|
target,
|
this.subarray(start, start + len),
|
targetStart
|
);
|
}
|
|
return len
|
};
|
|
// Usage:
|
// buffer.fill(number[, offset[, end]])
|
// buffer.fill(buffer[, offset[, end]])
|
// buffer.fill(string[, offset[, end]][, encoding])
|
Buffer$1.prototype.fill = function fill (val, start, end, encoding) {
|
// Handle string cases:
|
if (typeof val === 'string') {
|
if (typeof start === 'string') {
|
encoding = start;
|
start = 0;
|
end = this.length;
|
} else if (typeof end === 'string') {
|
encoding = end;
|
end = this.length;
|
}
|
if (val.length === 1) {
|
var code = val.charCodeAt(0);
|
if (code < 256) {
|
val = code;
|
}
|
}
|
if (encoding !== undefined && typeof encoding !== 'string') {
|
throw new TypeError('encoding must be a string')
|
}
|
if (typeof encoding === 'string' && !Buffer$1.isEncoding(encoding)) {
|
throw new TypeError('Unknown encoding: ' + encoding)
|
}
|
} else if (typeof val === 'number') {
|
val = val & 255;
|
}
|
|
// Invalid ranges are not set to a default, so can range check early.
|
if (start < 0 || this.length < start || this.length < end) {
|
throw new RangeError('Out of range index')
|
}
|
|
if (end <= start) {
|
return this
|
}
|
|
start = start >>> 0;
|
end = end === undefined ? this.length : end >>> 0;
|
|
if (!val) val = 0;
|
|
var i;
|
if (typeof val === 'number') {
|
for (i = start; i < end; ++i) {
|
this[i] = val;
|
}
|
} else {
|
var bytes = internalIsBuffer(val)
|
? val
|
: utf8ToBytes(new Buffer$1(val, encoding).toString());
|
var len = bytes.length;
|
for (i = 0; i < end - start; ++i) {
|
this[i + start] = bytes[i % len];
|
}
|
}
|
|
return this
|
};
|
|
// HELPER FUNCTIONS
|
// ================
|
|
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;
|
|
function base64clean (str) {
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
str = stringtrim(str).replace(INVALID_BASE64_RE, '');
|
// Node converts strings with length < 2 to ''
|
if (str.length < 2) return ''
|
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
|
while (str.length % 4 !== 0) {
|
str = str + '=';
|
}
|
return str
|
}
|
|
function stringtrim (str) {
|
if (str.trim) return str.trim()
|
return str.replace(/^\s+|\s+$/g, '')
|
}
|
|
function toHex (n) {
|
if (n < 16) return '0' + n.toString(16)
|
return n.toString(16)
|
}
|
|
function utf8ToBytes (string, units) {
|
units = units || Infinity;
|
var codePoint;
|
var length = string.length;
|
var leadSurrogate = null;
|
var bytes = [];
|
|
for (var i = 0; i < length; ++i) {
|
codePoint = string.charCodeAt(i);
|
|
// is surrogate component
|
if (codePoint > 0xD7FF && codePoint < 0xE000) {
|
// last char was a lead
|
if (!leadSurrogate) {
|
// no lead yet
|
if (codePoint > 0xDBFF) {
|
// unexpected trail
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
continue
|
} else if (i + 1 === length) {
|
// unpaired lead
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
continue
|
}
|
|
// valid lead
|
leadSurrogate = codePoint;
|
|
continue
|
}
|
|
// 2 leads in a row
|
if (codePoint < 0xDC00) {
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
leadSurrogate = codePoint;
|
continue
|
}
|
|
// valid surrogate pair
|
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
|
} else if (leadSurrogate) {
|
// valid bmp char, but last char was a lead
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
}
|
|
leadSurrogate = null;
|
|
// encode utf8
|
if (codePoint < 0x80) {
|
if ((units -= 1) < 0) break
|
bytes.push(codePoint);
|
} else if (codePoint < 0x800) {
|
if ((units -= 2) < 0) break
|
bytes.push(
|
codePoint >> 0x6 | 0xC0,
|
codePoint & 0x3F | 0x80
|
);
|
} else if (codePoint < 0x10000) {
|
if ((units -= 3) < 0) break
|
bytes.push(
|
codePoint >> 0xC | 0xE0,
|
codePoint >> 0x6 & 0x3F | 0x80,
|
codePoint & 0x3F | 0x80
|
);
|
} else if (codePoint < 0x110000) {
|
if ((units -= 4) < 0) break
|
bytes.push(
|
codePoint >> 0x12 | 0xF0,
|
codePoint >> 0xC & 0x3F | 0x80,
|
codePoint >> 0x6 & 0x3F | 0x80,
|
codePoint & 0x3F | 0x80
|
);
|
} else {
|
throw new Error('Invalid code point')
|
}
|
}
|
|
return bytes
|
}
|
|
function asciiToBytes (str) {
|
var byteArray = [];
|
for (var i = 0; i < str.length; ++i) {
|
// Node's code seems to be doing this and not & 0x7F..
|
byteArray.push(str.charCodeAt(i) & 0xFF);
|
}
|
return byteArray
|
}
|
|
function utf16leToBytes (str, units) {
|
var c, hi, lo;
|
var byteArray = [];
|
for (var i = 0; i < str.length; ++i) {
|
if ((units -= 2) < 0) break
|
|
c = str.charCodeAt(i);
|
hi = c >> 8;
|
lo = c % 256;
|
byteArray.push(lo);
|
byteArray.push(hi);
|
}
|
|
return byteArray
|
}
|
|
|
function base64ToBytes (str) {
|
return toByteArray(base64clean(str))
|
}
|
|
function blitBuffer (src, dst, offset, length) {
|
for (var i = 0; i < length; ++i) {
|
if ((i + offset >= dst.length) || (i >= src.length)) break
|
dst[i + offset] = src[i];
|
}
|
return i
|
}
|
|
function isnan (val) {
|
return val !== val // eslint-disable-line no-self-compare
|
}
|
|
|
// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence
|
// The _isBuffer check is for Safari 5-7 support, because it's missing
|
// Object.prototype.constructor. Remove this eventually
|
function isBuffer$1(obj) {
|
return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))
|
}
|
|
function isFastBuffer (obj) {
|
return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
|
}
|
|
// For Node v0.10 support. Remove this eventually.
|
function isSlowBuffer (obj) {
|
return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))
|
}
|
|
// shim for using process in browser
|
// based off https://github.com/defunctzombie/node-process/blob/master/browser.js
|
|
function defaultSetTimout() {
|
throw new Error('setTimeout has not been defined');
|
}
|
function defaultClearTimeout () {
|
throw new Error('clearTimeout has not been defined');
|
}
|
var cachedSetTimeout = defaultSetTimout;
|
var cachedClearTimeout = defaultClearTimeout;
|
if (typeof global$1.setTimeout === 'function') {
|
cachedSetTimeout = setTimeout;
|
}
|
if (typeof global$1.clearTimeout === 'function') {
|
cachedClearTimeout = clearTimeout;
|
}
|
|
function runTimeout(fun) {
|
if (cachedSetTimeout === setTimeout) {
|
//normal enviroments in sane situations
|
return setTimeout(fun, 0);
|
}
|
// if setTimeout wasn't available but was latter defined
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
cachedSetTimeout = setTimeout;
|
return setTimeout(fun, 0);
|
}
|
try {
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
return cachedSetTimeout(fun, 0);
|
} catch(e){
|
try {
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
return cachedSetTimeout.call(null, fun, 0);
|
} catch(e){
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
return cachedSetTimeout.call(this, fun, 0);
|
}
|
}
|
|
|
}
|
function runClearTimeout(marker) {
|
if (cachedClearTimeout === clearTimeout) {
|
//normal enviroments in sane situations
|
return clearTimeout(marker);
|
}
|
// if clearTimeout wasn't available but was latter defined
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
cachedClearTimeout = clearTimeout;
|
return clearTimeout(marker);
|
}
|
try {
|
// when when somebody has screwed with setTimeout but no I.E. maddness
|
return cachedClearTimeout(marker);
|
} catch (e){
|
try {
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
return cachedClearTimeout.call(null, marker);
|
} catch (e){
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
return cachedClearTimeout.call(this, marker);
|
}
|
}
|
|
|
|
}
|
var queue = [];
|
var draining = false;
|
var currentQueue;
|
var queueIndex = -1;
|
|
function cleanUpNextTick() {
|
if (!draining || !currentQueue) {
|
return;
|
}
|
draining = false;
|
if (currentQueue.length) {
|
queue = currentQueue.concat(queue);
|
} else {
|
queueIndex = -1;
|
}
|
if (queue.length) {
|
drainQueue();
|
}
|
}
|
|
function drainQueue() {
|
if (draining) {
|
return;
|
}
|
var timeout = runTimeout(cleanUpNextTick);
|
draining = true;
|
|
var len = queue.length;
|
while(len) {
|
currentQueue = queue;
|
queue = [];
|
while (++queueIndex < len) {
|
if (currentQueue) {
|
currentQueue[queueIndex].run();
|
}
|
}
|
queueIndex = -1;
|
len = queue.length;
|
}
|
currentQueue = null;
|
draining = false;
|
runClearTimeout(timeout);
|
}
|
function nextTick(fun) {
|
var args = new Array(arguments.length - 1);
|
if (arguments.length > 1) {
|
for (var i = 1; i < arguments.length; i++) {
|
args[i - 1] = arguments[i];
|
}
|
}
|
queue.push(new Item(fun, args));
|
if (queue.length === 1 && !draining) {
|
runTimeout(drainQueue);
|
}
|
}
|
// v8 likes predictible objects
|
function Item(fun, array) {
|
this.fun = fun;
|
this.array = array;
|
}
|
Item.prototype.run = function () {
|
this.fun.apply(null, this.array);
|
};
|
var title = 'browser';
|
var platform = 'browser';
|
var browser = true;
|
var env = {};
|
var argv = [];
|
var version$1 = ''; // empty string to avoid regexp issues
|
var versions = {};
|
var release = {};
|
var config = {};
|
|
function noop() {}
|
|
var on = noop;
|
var addListener = noop;
|
var once = noop;
|
var off = noop;
|
var removeListener = noop;
|
var removeAllListeners = noop;
|
var emit = noop;
|
|
function binding(name) {
|
throw new Error('process.binding is not supported');
|
}
|
|
function cwd () { return '/' }
|
function chdir (dir) {
|
throw new Error('process.chdir is not supported');
|
}function umask() { return 0; }
|
|
// from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
|
var performance = global$1.performance || {};
|
var performanceNow =
|
performance.now ||
|
performance.mozNow ||
|
performance.msNow ||
|
performance.oNow ||
|
performance.webkitNow ||
|
function(){ return (new Date()).getTime() };
|
|
// generate timestamp or delta
|
// see http://nodejs.org/api/process.html#process_process_hrtime
|
function hrtime(previousTimestamp){
|
var clocktime = performanceNow.call(performance)*1e-3;
|
var seconds = Math.floor(clocktime);
|
var nanoseconds = Math.floor((clocktime%1)*1e9);
|
if (previousTimestamp) {
|
seconds = seconds - previousTimestamp[0];
|
nanoseconds = nanoseconds - previousTimestamp[1];
|
if (nanoseconds<0) {
|
seconds--;
|
nanoseconds += 1e9;
|
}
|
}
|
return [seconds,nanoseconds]
|
}
|
|
var startTime = new Date();
|
function uptime() {
|
var currentTime = new Date();
|
var dif = currentTime - startTime;
|
return dif / 1000;
|
}
|
|
var browser$1 = {
|
nextTick: nextTick,
|
title: title,
|
browser: browser,
|
env: env,
|
argv: argv,
|
version: version$1,
|
versions: versions,
|
on: on,
|
addListener: addListener,
|
once: once,
|
off: off,
|
removeListener: removeListener,
|
removeAllListeners: removeAllListeners,
|
emit: emit,
|
binding: binding,
|
cwd: cwd,
|
chdir: chdir,
|
umask: umask,
|
hrtime: hrtime,
|
platform: platform,
|
release: release,
|
config: config,
|
uptime: uptime
|
};
|
|
var inherits;
|
if (typeof Object.create === 'function'){
|
inherits = function inherits(ctor, superCtor) {
|
// implementation from standard node.js 'util' module
|
ctor.super_ = superCtor;
|
ctor.prototype = Object.create(superCtor.prototype, {
|
constructor: {
|
value: ctor,
|
enumerable: false,
|
writable: true,
|
configurable: true
|
}
|
});
|
};
|
} else {
|
inherits = function inherits(ctor, superCtor) {
|
ctor.super_ = superCtor;
|
var TempCtor = function () {};
|
TempCtor.prototype = superCtor.prototype;
|
ctor.prototype = new TempCtor();
|
ctor.prototype.constructor = ctor;
|
};
|
}
|
var inherits$1 = inherits;
|
|
var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
|
function getOwnPropertyDescriptors(obj) {
|
var keys = Object.keys(obj);
|
var descriptors = {};
|
for (var i = 0; i < keys.length; i++) {
|
descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
|
}
|
return descriptors;
|
};
|
|
var formatRegExp = /%[sdj%]/g;
|
function format$1(f) {
|
if (!isString$1(f)) {
|
var objects = [];
|
for (var i = 0; i < arguments.length; i++) {
|
objects.push(inspect(arguments[i]));
|
}
|
return objects.join(' ');
|
}
|
|
var i = 1;
|
var args = arguments;
|
var len = args.length;
|
var str = String(f).replace(formatRegExp, function(x) {
|
if (x === '%%') return '%';
|
if (i >= len) return x;
|
switch (x) {
|
case '%s': return String(args[i++]);
|
case '%d': return Number(args[i++]);
|
case '%j':
|
try {
|
return JSON.stringify(args[i++]);
|
} catch (_) {
|
return '[Circular]';
|
}
|
default:
|
return x;
|
}
|
});
|
for (var x = args[i]; i < len; x = args[++i]) {
|
if (isNull(x) || !isObject$1(x)) {
|
str += ' ' + x;
|
} else {
|
str += ' ' + inspect(x);
|
}
|
}
|
return str;
|
}
|
|
// Mark that a method should not be used.
|
// Returns a modified function which warns once by default.
|
// If --no-deprecation is set, then it is a no-op.
|
function deprecate(fn, msg) {
|
// Allow for deprecating things in the process of starting up.
|
if (isUndefined(global$1.process)) {
|
return function() {
|
return deprecate(fn, msg).apply(this, arguments);
|
};
|
}
|
|
if (browser$1.noDeprecation === true) {
|
return fn;
|
}
|
|
var warned = false;
|
function deprecated() {
|
if (!warned) {
|
if (browser$1.throwDeprecation) {
|
throw new Error(msg);
|
} else if (browser$1.traceDeprecation) {
|
console.trace(msg);
|
} else {
|
console.error(msg);
|
}
|
warned = true;
|
}
|
return fn.apply(this, arguments);
|
}
|
|
return deprecated;
|
}
|
|
var debugs = {};
|
var debugEnviron;
|
function debuglog(set) {
|
if (isUndefined(debugEnviron))
|
debugEnviron = browser$1.env.NODE_DEBUG || '';
|
set = set.toUpperCase();
|
if (!debugs[set]) {
|
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
|
var pid = 0;
|
debugs[set] = function() {
|
var msg = format$1.apply(null, arguments);
|
console.error('%s %d: %s', set, pid, msg);
|
};
|
} else {
|
debugs[set] = function() {};
|
}
|
}
|
return debugs[set];
|
}
|
|
/**
|
* Echos the value of a value. Trys to print the value out
|
* in the best way possible given the different types.
|
*
|
* @param {Object} obj The object to print out.
|
* @param {Object} opts Optional options object that alters the output.
|
*/
|
/* legacy: obj, showHidden, depth, colors*/
|
function inspect(obj, opts) {
|
// default options
|
var ctx = {
|
seen: [],
|
stylize: stylizeNoColor
|
};
|
// legacy...
|
if (arguments.length >= 3) ctx.depth = arguments[2];
|
if (arguments.length >= 4) ctx.colors = arguments[3];
|
if (isBoolean(opts)) {
|
// legacy...
|
ctx.showHidden = opts;
|
} else if (opts) {
|
// got an "options" object
|
_extend(ctx, opts);
|
}
|
// set default options
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
if (isUndefined(ctx.colors)) ctx.colors = false;
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
return formatValue(ctx, obj, ctx.depth);
|
}
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
inspect.colors = {
|
'bold' : [1, 22],
|
'italic' : [3, 23],
|
'underline' : [4, 24],
|
'inverse' : [7, 27],
|
'white' : [37, 39],
|
'grey' : [90, 39],
|
'black' : [30, 39],
|
'blue' : [34, 39],
|
'cyan' : [36, 39],
|
'green' : [32, 39],
|
'magenta' : [35, 39],
|
'red' : [31, 39],
|
'yellow' : [33, 39]
|
};
|
|
// Don't use 'blue' not visible on cmd.exe
|
inspect.styles = {
|
'special': 'cyan',
|
'number': 'yellow',
|
'boolean': 'yellow',
|
'undefined': 'grey',
|
'null': 'bold',
|
'string': 'green',
|
'date': 'magenta',
|
// "name": intentionally not styling
|
'regexp': 'red'
|
};
|
|
|
function stylizeWithColor(str, styleType) {
|
var style = inspect.styles[styleType];
|
|
if (style) {
|
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
'\u001b[' + inspect.colors[style][1] + 'm';
|
} else {
|
return str;
|
}
|
}
|
|
|
function stylizeNoColor(str, styleType) {
|
return str;
|
}
|
|
|
function arrayToHash(array) {
|
var hash = {};
|
|
array.forEach(function(val, idx) {
|
hash[val] = true;
|
});
|
|
return hash;
|
}
|
|
|
function formatValue(ctx, value, recurseTimes) {
|
// Provide a hook for user-specified inspect functions.
|
// Check that value is an object with an inspect function on it
|
if (ctx.customInspect &&
|
value &&
|
isFunction(value.inspect) &&
|
// Filter out the util module, it's inspect function is special
|
value.inspect !== inspect &&
|
// Also filter out any prototype objects using the circular check.
|
!(value.constructor && value.constructor.prototype === value)) {
|
var ret = value.inspect(recurseTimes, ctx);
|
if (!isString$1(ret)) {
|
ret = formatValue(ctx, ret, recurseTimes);
|
}
|
return ret;
|
}
|
|
// Primitive types cannot have properties
|
var primitive = formatPrimitive(ctx, value);
|
if (primitive) {
|
return primitive;
|
}
|
|
// Look up the keys of the object.
|
var keys = Object.keys(value);
|
var visibleKeys = arrayToHash(keys);
|
|
if (ctx.showHidden) {
|
keys = Object.getOwnPropertyNames(value);
|
}
|
|
// IE doesn't make error fields non-enumerable
|
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
|
if (isError(value)
|
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
|
return formatError(value);
|
}
|
|
// Some type of object without properties can be shortcutted.
|
if (keys.length === 0) {
|
if (isFunction(value)) {
|
var name = value.name ? ': ' + value.name : '';
|
return ctx.stylize('[Function' + name + ']', 'special');
|
}
|
if (isRegExp(value)) {
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
}
|
if (isDate(value)) {
|
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
}
|
if (isError(value)) {
|
return formatError(value);
|
}
|
}
|
|
var base = '', array = false, braces = ['{', '}'];
|
|
// Make Array say that they are Array
|
if (isArray$1(value)) {
|
array = true;
|
braces = ['[', ']'];
|
}
|
|
// Make functions say that they are functions
|
if (isFunction(value)) {
|
var n = value.name ? ': ' + value.name : '';
|
base = ' [Function' + n + ']';
|
}
|
|
// Make RegExps say that they are RegExps
|
if (isRegExp(value)) {
|
base = ' ' + RegExp.prototype.toString.call(value);
|
}
|
|
// Make dates with properties first say the date
|
if (isDate(value)) {
|
base = ' ' + Date.prototype.toUTCString.call(value);
|
}
|
|
// Make error with message first say the error
|
if (isError(value)) {
|
base = ' ' + formatError(value);
|
}
|
|
if (keys.length === 0 && (!array || value.length == 0)) {
|
return braces[0] + base + braces[1];
|
}
|
|
if (recurseTimes < 0) {
|
if (isRegExp(value)) {
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
} else {
|
return ctx.stylize('[Object]', 'special');
|
}
|
}
|
|
ctx.seen.push(value);
|
|
var output;
|
if (array) {
|
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
} else {
|
output = keys.map(function(key) {
|
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
});
|
}
|
|
ctx.seen.pop();
|
|
return reduceToSingleString(output, base, braces);
|
}
|
|
|
function formatPrimitive(ctx, value) {
|
if (isUndefined(value))
|
return ctx.stylize('undefined', 'undefined');
|
if (isString$1(value)) {
|
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
.replace(/'/g, "\\'")
|
.replace(/\\"/g, '"') + '\'';
|
return ctx.stylize(simple, 'string');
|
}
|
if (isNumber(value))
|
return ctx.stylize('' + value, 'number');
|
if (isBoolean(value))
|
return ctx.stylize('' + value, 'boolean');
|
// For some reason typeof null is "object", so special case here.
|
if (isNull(value))
|
return ctx.stylize('null', 'null');
|
}
|
|
|
function formatError(value) {
|
return '[' + Error.prototype.toString.call(value) + ']';
|
}
|
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
var output = [];
|
for (var i = 0, l = value.length; i < l; ++i) {
|
if (hasOwnProperty$2(value, String(i))) {
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
String(i), true));
|
} else {
|
output.push('');
|
}
|
}
|
keys.forEach(function(key) {
|
if (!key.match(/^\d+$/)) {
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
key, true));
|
}
|
});
|
return output;
|
}
|
|
|
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
var name, str, desc;
|
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
if (desc.get) {
|
if (desc.set) {
|
str = ctx.stylize('[Getter/Setter]', 'special');
|
} else {
|
str = ctx.stylize('[Getter]', 'special');
|
}
|
} else {
|
if (desc.set) {
|
str = ctx.stylize('[Setter]', 'special');
|
}
|
}
|
if (!hasOwnProperty$2(visibleKeys, key)) {
|
name = '[' + key + ']';
|
}
|
if (!str) {
|
if (ctx.seen.indexOf(desc.value) < 0) {
|
if (isNull(recurseTimes)) {
|
str = formatValue(ctx, desc.value, null);
|
} else {
|
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
}
|
if (str.indexOf('\n') > -1) {
|
if (array) {
|
str = str.split('\n').map(function(line) {
|
return ' ' + line;
|
}).join('\n').substr(2);
|
} else {
|
str = '\n' + str.split('\n').map(function(line) {
|
return ' ' + line;
|
}).join('\n');
|
}
|
}
|
} else {
|
str = ctx.stylize('[Circular]', 'special');
|
}
|
}
|
if (isUndefined(name)) {
|
if (array && key.match(/^\d+$/)) {
|
return str;
|
}
|
name = JSON.stringify('' + key);
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
name = name.substr(1, name.length - 2);
|
name = ctx.stylize(name, 'name');
|
} else {
|
name = name.replace(/'/g, "\\'")
|
.replace(/\\"/g, '"')
|
.replace(/(^"|"$)/g, "'");
|
name = ctx.stylize(name, 'string');
|
}
|
}
|
|
return name + ': ' + str;
|
}
|
|
|
function reduceToSingleString(output, base, braces) {
|
var length = output.reduce(function(prev, cur) {
|
if (cur.indexOf('\n') >= 0) ;
|
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
}, 0);
|
|
if (length > 60) {
|
return braces[0] +
|
(base === '' ? '' : base + '\n ') +
|
' ' +
|
output.join(',\n ') +
|
' ' +
|
braces[1];
|
}
|
|
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
}
|
|
|
// NOTE: These type checking functions intentionally don't use `instanceof`
|
// because it is fragile and can be easily faked with `Object.create()`.
|
function isArray$1(ar) {
|
return Array.isArray(ar);
|
}
|
|
function isBoolean(arg) {
|
return typeof arg === 'boolean';
|
}
|
|
function isNull(arg) {
|
return arg === null;
|
}
|
|
function isNullOrUndefined(arg) {
|
return arg == null;
|
}
|
|
function isNumber(arg) {
|
return typeof arg === 'number';
|
}
|
|
function isString$1(arg) {
|
return typeof arg === 'string';
|
}
|
|
function isSymbol(arg) {
|
return typeof arg === 'symbol';
|
}
|
|
function isUndefined(arg) {
|
return arg === void 0;
|
}
|
|
function isRegExp(re) {
|
return isObject$1(re) && objectToString(re) === '[object RegExp]';
|
}
|
|
function isObject$1(arg) {
|
return typeof arg === 'object' && arg !== null;
|
}
|
|
function isDate(d) {
|
return isObject$1(d) && objectToString(d) === '[object Date]';
|
}
|
|
function isError(e) {
|
return isObject$1(e) &&
|
(objectToString(e) === '[object Error]' || e instanceof Error);
|
}
|
|
function isFunction(arg) {
|
return typeof arg === 'function';
|
}
|
|
function isPrimitive(arg) {
|
return arg === null ||
|
typeof arg === 'boolean' ||
|
typeof arg === 'number' ||
|
typeof arg === 'string' ||
|
typeof arg === 'symbol' || // ES6 symbol
|
typeof arg === 'undefined';
|
}
|
|
function isBuffer(maybeBuf) {
|
return Buffer$1.isBuffer(maybeBuf);
|
}
|
|
function objectToString(o) {
|
return Object.prototype.toString.call(o);
|
}
|
|
|
function pad(n) {
|
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
}
|
|
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
'Oct', 'Nov', 'Dec'];
|
|
// 26 Feb 16:19:34
|
function timestamp() {
|
var d = new Date();
|
var time = [pad(d.getHours()),
|
pad(d.getMinutes()),
|
pad(d.getSeconds())].join(':');
|
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
}
|
|
|
// log is just a thin wrapper to console.log that prepends a timestamp
|
function log() {
|
console.log('%s - %s', timestamp(), format$1.apply(null, arguments));
|
}
|
|
function _extend(origin, add) {
|
// Don't do anything if add isn't an object
|
if (!add || !isObject$1(add)) return origin;
|
|
var keys = Object.keys(add);
|
var i = keys.length;
|
while (i--) {
|
origin[keys[i]] = add[keys[i]];
|
}
|
return origin;
|
}
|
function hasOwnProperty$2(obj, prop) {
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
}
|
|
var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
|
|
function promisify(original) {
|
if (typeof original !== 'function')
|
throw new TypeError('The "original" argument must be of type Function');
|
|
if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
|
var fn = original[kCustomPromisifiedSymbol];
|
if (typeof fn !== 'function') {
|
throw new TypeError('The "util.promisify.custom" argument must be of type Function');
|
}
|
Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
value: fn, enumerable: false, writable: false, configurable: true
|
});
|
return fn;
|
}
|
|
function fn() {
|
var promiseResolve, promiseReject;
|
var promise = new Promise(function (resolve, reject) {
|
promiseResolve = resolve;
|
promiseReject = reject;
|
});
|
|
var args = [];
|
for (var i = 0; i < arguments.length; i++) {
|
args.push(arguments[i]);
|
}
|
args.push(function (err, value) {
|
if (err) {
|
promiseReject(err);
|
} else {
|
promiseResolve(value);
|
}
|
});
|
|
try {
|
original.apply(this, args);
|
} catch (err) {
|
promiseReject(err);
|
}
|
|
return promise;
|
}
|
|
Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
|
|
if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
value: fn, enumerable: false, writable: false, configurable: true
|
});
|
return Object.defineProperties(
|
fn,
|
getOwnPropertyDescriptors(original)
|
);
|
}
|
|
promisify.custom = kCustomPromisifiedSymbol;
|
|
function callbackifyOnRejected(reason, cb) {
|
// `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
|
// Because `null` is a special error value in callbacks which means "no error
|
// occurred", we error-wrap so the callback consumer can distinguish between
|
// "the promise rejected with null" or "the promise fulfilled with undefined".
|
if (!reason) {
|
var newReason = new Error('Promise was rejected with a falsy value');
|
newReason.reason = reason;
|
reason = newReason;
|
}
|
return cb(reason);
|
}
|
|
function callbackify(original) {
|
if (typeof original !== 'function') {
|
throw new TypeError('The "original" argument must be of type Function');
|
}
|
|
// We DO NOT return the promise as it gives the user a false sense that
|
// the promise is actually somehow related to the callback's execution
|
// and that the callback throwing will reject the promise.
|
function callbackified() {
|
var args = [];
|
for (var i = 0; i < arguments.length; i++) {
|
args.push(arguments[i]);
|
}
|
|
var maybeCb = args.pop();
|
if (typeof maybeCb !== 'function') {
|
throw new TypeError('The last argument must be of type Function');
|
}
|
var self = this;
|
var cb = function() {
|
return maybeCb.apply(self, arguments);
|
};
|
// In true node style we process the callback on `nextTick` with all the
|
// implications (stack, `uncaughtException`, `async_hooks`)
|
original.apply(this, args)
|
.then(function(ret) { browser$1.nextTick(cb.bind(null, null, ret)); },
|
function(rej) { browser$1.nextTick(callbackifyOnRejected.bind(null, rej, cb)); });
|
}
|
|
Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
|
Object.defineProperties(callbackified, getOwnPropertyDescriptors(original));
|
return callbackified;
|
}
|
|
var _polyfillNode_util = {
|
inherits: inherits$1,
|
_extend: _extend,
|
log: log,
|
isBuffer: isBuffer,
|
isPrimitive: isPrimitive,
|
isFunction: isFunction,
|
isError: isError,
|
isDate: isDate,
|
isObject: isObject$1,
|
isRegExp: isRegExp,
|
isUndefined: isUndefined,
|
isSymbol: isSymbol,
|
isString: isString$1,
|
isNumber: isNumber,
|
isNullOrUndefined: isNullOrUndefined,
|
isNull: isNull,
|
isBoolean: isBoolean,
|
isArray: isArray$1,
|
inspect: inspect,
|
deprecate: deprecate,
|
format: format$1,
|
debuglog: debuglog,
|
promisify: promisify,
|
callbackify: callbackify,
|
};
|
|
var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
|
__proto__: null,
|
_extend: _extend,
|
callbackify: callbackify,
|
debuglog: debuglog,
|
default: _polyfillNode_util,
|
deprecate: deprecate,
|
format: format$1,
|
inherits: inherits$1,
|
inspect: inspect,
|
isArray: isArray$1,
|
isBoolean: isBoolean,
|
isBuffer: isBuffer,
|
isDate: isDate,
|
isError: isError,
|
isFunction: isFunction,
|
isNull: isNull,
|
isNullOrUndefined: isNullOrUndefined,
|
isNumber: isNumber,
|
isObject: isObject$1,
|
isPrimitive: isPrimitive,
|
isRegExp: isRegExp,
|
isString: isString$1,
|
isSymbol: isSymbol,
|
isUndefined: isUndefined,
|
log: log,
|
promisify: promisify
|
});
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
//
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
// copy of this software and associated documentation files (the
|
// "Software"), to deal in the Software without restriction, including
|
// without limitation the rights to use, copy, modify, merge, publish,
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
// persons to whom the Software is furnished to do so, subject to the
|
// following conditions:
|
//
|
// The above copyright notice and this permission notice shall be included
|
// in all copies or substantial portions of the Software.
|
//
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
// If obj.hasOwnProperty has been overridden, then calling
|
// obj.hasOwnProperty(prop) will break.
|
// See: https://github.com/joyent/node/issues/1707
|
function hasOwnProperty$1(obj, prop) {
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
}
|
var isArray = Array.isArray || function (xs) {
|
return Object.prototype.toString.call(xs) === '[object Array]';
|
};
|
function stringifyPrimitive(v) {
|
switch (typeof v) {
|
case 'string':
|
return v;
|
|
case 'boolean':
|
return v ? 'true' : 'false';
|
|
case 'number':
|
return isFinite(v) ? v : '';
|
|
default:
|
return '';
|
}
|
}
|
|
function stringify$5 (obj, sep, eq, name) {
|
sep = sep || '&';
|
eq = eq || '=';
|
if (obj === null) {
|
obj = undefined;
|
}
|
|
if (typeof obj === 'object') {
|
return map(objectKeys(obj), function(k) {
|
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
|
if (isArray(obj[k])) {
|
return map(obj[k], function(v) {
|
return ks + encodeURIComponent(stringifyPrimitive(v));
|
}).join(sep);
|
} else {
|
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
|
}
|
}).join(sep);
|
|
}
|
|
if (!name) return '';
|
return encodeURIComponent(stringifyPrimitive(name)) + eq +
|
encodeURIComponent(stringifyPrimitive(obj));
|
}
|
function map (xs, f) {
|
if (xs.map) return xs.map(f);
|
var res = [];
|
for (var i = 0; i < xs.length; i++) {
|
res.push(f(xs[i], i));
|
}
|
return res;
|
}
|
|
var objectKeys = Object.keys || function (obj) {
|
var res = [];
|
for (var key in obj) {
|
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
|
}
|
return res;
|
};
|
|
function parse$6(qs, sep, eq, options) {
|
sep = sep || '&';
|
eq = eq || '=';
|
var obj = {};
|
|
if (typeof qs !== 'string' || qs.length === 0) {
|
return obj;
|
}
|
|
var regexp = /\+/g;
|
qs = qs.split(sep);
|
|
var maxKeys = 1000;
|
if (options && typeof options.maxKeys === 'number') {
|
maxKeys = options.maxKeys;
|
}
|
|
var len = qs.length;
|
// maxKeys <= 0 means that we should not limit keys count
|
if (maxKeys > 0 && len > maxKeys) {
|
len = maxKeys;
|
}
|
|
for (var i = 0; i < len; ++i) {
|
var x = qs[i].replace(regexp, '%20'),
|
idx = x.indexOf(eq),
|
kstr, vstr, k, v;
|
|
if (idx >= 0) {
|
kstr = x.substr(0, idx);
|
vstr = x.substr(idx + 1);
|
} else {
|
kstr = x;
|
vstr = '';
|
}
|
|
k = decodeURIComponent(kstr);
|
v = decodeURIComponent(vstr);
|
|
if (!hasOwnProperty$1(obj, k)) {
|
obj[k] = v;
|
} else if (isArray(obj[k])) {
|
obj[k].push(v);
|
} else {
|
obj[k] = [obj[k], v];
|
}
|
}
|
|
return obj;
|
}
|
|
// WHATWG API
|
const URL$1 = global$1.URL;
|
const URLSearchParams = global$1.URLSearchParams;
|
var _polyfillNode_url = {
|
parse: urlParse,
|
resolve: urlResolve,
|
resolveObject: urlResolveObject,
|
fileURLToPath: urlFileURLToPath,
|
format: urlFormat,
|
Url: Url,
|
|
// WHATWG API
|
URL: URL$1,
|
URLSearchParams,
|
};
|
function Url() {
|
this.protocol = null;
|
this.slashes = null;
|
this.auth = null;
|
this.host = null;
|
this.port = null;
|
this.hostname = null;
|
this.hash = null;
|
this.search = null;
|
this.query = null;
|
this.pathname = null;
|
this.path = null;
|
this.href = null;
|
}
|
|
// Reference: RFC 3986, RFC 1808, RFC 2396
|
|
// define these here so at least they only have to be
|
// compiled once on the first module load.
|
var protocolPattern = /^([a-z0-9.+-]+:)/i,
|
portPattern = /:[0-9]*$/,
|
|
// Special case for a simple path URL
|
simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
|
|
// RFC 2396: characters reserved for delimiting URLs.
|
// We actually just auto-escape these.
|
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
|
|
// RFC 2396: characters not allowed for various reasons.
|
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
|
|
// Allowed by RFCs, but cause of XSS attacks. Always escape these.
|
autoEscape = ['\''].concat(unwise),
|
// Characters that are never ever allowed in a hostname.
|
// Note that any invalid chars are also handled, but these
|
// are the ones that are *expected* to be seen, so we fast-path
|
// them.
|
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
|
hostEndingChars = ['/', '?', '#'],
|
hostnameMaxLen = 255,
|
hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
|
hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
|
// protocols that can allow "unsafe" and "unwise" chars.
|
unsafeProtocol = {
|
'javascript': true,
|
'javascript:': true
|
},
|
// protocols that never have a hostname.
|
hostlessProtocol = {
|
'javascript': true,
|
'javascript:': true
|
},
|
// protocols that always contain a // bit.
|
slashedProtocol = {
|
'http': true,
|
'https': true,
|
'ftp': true,
|
'gopher': true,
|
'file': true,
|
'http:': true,
|
'https:': true,
|
'ftp:': true,
|
'gopher:': true,
|
'file:': true
|
};
|
|
function urlParse(url, parseQueryString, slashesDenoteHost) {
|
if (url && isObject$1(url) && url instanceof Url) return url;
|
|
var u = new Url;
|
u.parse(url, parseQueryString, slashesDenoteHost);
|
return u;
|
}
|
Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
|
return parse$5(this, url, parseQueryString, slashesDenoteHost);
|
};
|
|
function parse$5(self, url, parseQueryString, slashesDenoteHost) {
|
if (!isString$1(url)) {
|
throw new TypeError('Parameter \'url\' must be a string, not ' + typeof url);
|
}
|
|
// Copy chrome, IE, opera backslash-handling behavior.
|
// Back slashes before the query string get converted to forward slashes
|
// See: https://code.google.com/p/chromium/issues/detail?id=25916
|
var queryIndex = url.indexOf('?'),
|
splitter =
|
(queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
|
uSplit = url.split(splitter),
|
slashRegex = /\\/g;
|
uSplit[0] = uSplit[0].replace(slashRegex, '/');
|
url = uSplit.join(splitter);
|
|
var rest = url;
|
|
// trim before proceeding.
|
// This is to support parse stuff like " http://foo.com \n"
|
rest = rest.trim();
|
|
if (!slashesDenoteHost && url.split('#').length === 1) {
|
// Try fast path regexp
|
var simplePath = simplePathPattern.exec(rest);
|
if (simplePath) {
|
self.path = rest;
|
self.href = rest;
|
self.pathname = simplePath[1];
|
if (simplePath[2]) {
|
self.search = simplePath[2];
|
if (parseQueryString) {
|
self.query = parse$6(self.search.substr(1));
|
} else {
|
self.query = self.search.substr(1);
|
}
|
} else if (parseQueryString) {
|
self.search = '';
|
self.query = {};
|
}
|
return self;
|
}
|
}
|
|
var proto = protocolPattern.exec(rest);
|
if (proto) {
|
proto = proto[0];
|
var lowerProto = proto.toLowerCase();
|
self.protocol = lowerProto;
|
rest = rest.substr(proto.length);
|
}
|
|
// figure out if it's got a host
|
// user@server is *always* interpreted as a hostname, and url
|
// resolution will treat //foo/bar as host=foo,path=bar because that's
|
// how the browser resolves relative URLs.
|
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
|
var slashes = rest.substr(0, 2) === '//';
|
if (slashes && !(proto && hostlessProtocol[proto])) {
|
rest = rest.substr(2);
|
self.slashes = true;
|
}
|
}
|
var i, hec, l, p;
|
if (!hostlessProtocol[proto] &&
|
(slashes || (proto && !slashedProtocol[proto]))) {
|
|
// there's a hostname.
|
// the first instance of /, ?, ;, or # ends the host.
|
//
|
// If there is an @ in the hostname, then non-host chars *are* allowed
|
// to the left of the last @ sign, unless some host-ending character
|
// comes *before* the @-sign.
|
// URLs are obnoxious.
|
//
|
// ex:
|
// http://a@b@c/ => user:a@b host:c
|
// http://a@b?@c => user:a host:c path:/?@c
|
|
// v0.12 TODO(isaacs): This is not quite how Chrome does things.
|
// Review our test case against browsers more comprehensively.
|
|
// find the first instance of any hostEndingChars
|
var hostEnd = -1;
|
for (i = 0; i < hostEndingChars.length; i++) {
|
hec = rest.indexOf(hostEndingChars[i]);
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
|
hostEnd = hec;
|
}
|
|
// at this point, either we have an explicit point where the
|
// auth portion cannot go past, or the last @ char is the decider.
|
var auth, atSign;
|
if (hostEnd === -1) {
|
// atSign can be anywhere.
|
atSign = rest.lastIndexOf('@');
|
} else {
|
// atSign must be in auth portion.
|
// http://a@b/c@d => host:b auth:a path:/c@d
|
atSign = rest.lastIndexOf('@', hostEnd);
|
}
|
|
// Now we have a portion which is definitely the auth.
|
// Pull that off.
|
if (atSign !== -1) {
|
auth = rest.slice(0, atSign);
|
rest = rest.slice(atSign + 1);
|
self.auth = decodeURIComponent(auth);
|
}
|
|
// the host is the remaining to the left of the first non-host char
|
hostEnd = -1;
|
for (i = 0; i < nonHostChars.length; i++) {
|
hec = rest.indexOf(nonHostChars[i]);
|
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
|
hostEnd = hec;
|
}
|
// if we still have not hit it, then the entire thing is a host.
|
if (hostEnd === -1)
|
hostEnd = rest.length;
|
|
self.host = rest.slice(0, hostEnd);
|
rest = rest.slice(hostEnd);
|
|
// pull out port.
|
parseHost(self);
|
|
// we've indicated that there is a hostname,
|
// so even if it's empty, it has to be present.
|
self.hostname = self.hostname || '';
|
|
// if hostname begins with [ and ends with ]
|
// assume that it's an IPv6 address.
|
var ipv6Hostname = self.hostname[0] === '[' &&
|
self.hostname[self.hostname.length - 1] === ']';
|
|
// validate a little.
|
if (!ipv6Hostname) {
|
var hostparts = self.hostname.split(/\./);
|
for (i = 0, l = hostparts.length; i < l; i++) {
|
var part = hostparts[i];
|
if (!part) continue;
|
if (!part.match(hostnamePartPattern)) {
|
var newpart = '';
|
for (var j = 0, k = part.length; j < k; j++) {
|
if (part.charCodeAt(j) > 127) {
|
// we replace non-ASCII char with a temporary placeholder
|
// we need this to make sure size of hostname is not
|
// broken by replacing non-ASCII by nothing
|
newpart += 'x';
|
} else {
|
newpart += part[j];
|
}
|
}
|
// we test again with ASCII char only
|
if (!newpart.match(hostnamePartPattern)) {
|
var validParts = hostparts.slice(0, i);
|
var notHost = hostparts.slice(i + 1);
|
var bit = part.match(hostnamePartStart);
|
if (bit) {
|
validParts.push(bit[1]);
|
notHost.unshift(bit[2]);
|
}
|
if (notHost.length) {
|
rest = '/' + notHost.join('.') + rest;
|
}
|
self.hostname = validParts.join('.');
|
break;
|
}
|
}
|
}
|
}
|
|
if (self.hostname.length > hostnameMaxLen) {
|
self.hostname = '';
|
} else {
|
// hostnames are always lower case.
|
self.hostname = self.hostname.toLowerCase();
|
}
|
|
if (!ipv6Hostname) {
|
// IDNA Support: Returns a punycoded representation of "domain".
|
// It only converts parts of the domain name that
|
// have non-ASCII characters, i.e. it doesn't matter if
|
// you call it with a domain that already is ASCII-only.
|
self.hostname = toASCII(self.hostname);
|
}
|
|
p = self.port ? ':' + self.port : '';
|
var h = self.hostname || '';
|
self.host = h + p;
|
self.href += self.host;
|
|
// strip [ and ] from the hostname
|
// the host field still retains them, though
|
if (ipv6Hostname) {
|
self.hostname = self.hostname.substr(1, self.hostname.length - 2);
|
if (rest[0] !== '/') {
|
rest = '/' + rest;
|
}
|
}
|
}
|
|
// now rest is set to the post-host stuff.
|
// chop off any delim chars.
|
if (!unsafeProtocol[lowerProto]) {
|
|
// First, make 100% sure that any "autoEscape" chars get
|
// escaped, even if encodeURIComponent doesn't think they
|
// need to be.
|
for (i = 0, l = autoEscape.length; i < l; i++) {
|
var ae = autoEscape[i];
|
if (rest.indexOf(ae) === -1)
|
continue;
|
var esc = encodeURIComponent(ae);
|
if (esc === ae) {
|
esc = escape(ae);
|
}
|
rest = rest.split(ae).join(esc);
|
}
|
}
|
|
|
// chop off from the tail first.
|
var hash = rest.indexOf('#');
|
if (hash !== -1) {
|
// got a fragment string.
|
self.hash = rest.substr(hash);
|
rest = rest.slice(0, hash);
|
}
|
var qm = rest.indexOf('?');
|
if (qm !== -1) {
|
self.search = rest.substr(qm);
|
self.query = rest.substr(qm + 1);
|
if (parseQueryString) {
|
self.query = parse$6(self.query);
|
}
|
rest = rest.slice(0, qm);
|
} else if (parseQueryString) {
|
// no query string, but parseQueryString still requested
|
self.search = '';
|
self.query = {};
|
}
|
if (rest) self.pathname = rest;
|
if (slashedProtocol[lowerProto] &&
|
self.hostname && !self.pathname) {
|
self.pathname = '/';
|
}
|
|
//to support http.request
|
if (self.pathname || self.search) {
|
p = self.pathname || '';
|
var s = self.search || '';
|
self.path = p + s;
|
}
|
|
// finally, reconstruct the href based on what has been validated.
|
self.href = format(self);
|
return self;
|
}
|
|
function urlFileURLToPath(path) {
|
if (typeof path === 'string')
|
path = new Url().parse(path);
|
else if (!(path instanceof Url))
|
throw new TypeError('The "path" argument must be of type string or an instance of URL. Received type ' + (typeof path) + String(path));
|
if (path.protocol !== 'file:')
|
throw new TypeError('The URL must be of scheme file');
|
return getPathFromURLPosix(path);
|
}
|
|
function getPathFromURLPosix(url) {
|
const pathname = url.pathname;
|
for (let n = 0; n < pathname.length; n++) {
|
if (pathname[n] === '%') {
|
const third = pathname.codePointAt(n + 2) | 0x20;
|
if (pathname[n + 1] === '2' && third === 102) {
|
throw new TypeError(
|
'must not include encoded / characters'
|
);
|
}
|
}
|
}
|
return decodeURIComponent(pathname);
|
}
|
|
// format a parsed object into a url string
|
function urlFormat(obj) {
|
// ensure it's an object, and not a string url.
|
// If it's an obj, this is a no-op.
|
// this way, you can call url_format() on strings
|
// to clean up potentially wonky urls.
|
if (isString$1(obj)) obj = parse$5({}, obj);
|
return format(obj);
|
}
|
|
function format(self) {
|
var auth = self.auth || '';
|
if (auth) {
|
auth = encodeURIComponent(auth);
|
auth = auth.replace(/%3A/i, ':');
|
auth += '@';
|
}
|
|
var protocol = self.protocol || '',
|
pathname = self.pathname || '',
|
hash = self.hash || '',
|
host = false,
|
query = '';
|
|
if (self.host) {
|
host = auth + self.host;
|
} else if (self.hostname) {
|
host = auth + (self.hostname.indexOf(':') === -1 ?
|
self.hostname :
|
'[' + this.hostname + ']');
|
if (self.port) {
|
host += ':' + self.port;
|
}
|
}
|
|
if (self.query &&
|
isObject$1(self.query) &&
|
Object.keys(self.query).length) {
|
query = stringify$5(self.query);
|
}
|
|
var search = self.search || (query && ('?' + query)) || '';
|
|
if (protocol && protocol.substr(-1) !== ':') protocol += ':';
|
|
// only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
|
// unless they had them to begin with.
|
if (self.slashes ||
|
(!protocol || slashedProtocol[protocol]) && host !== false) {
|
host = '//' + (host || '');
|
if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
|
} else if (!host) {
|
host = '';
|
}
|
|
if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
|
if (search && search.charAt(0) !== '?') search = '?' + search;
|
|
pathname = pathname.replace(/[?#]/g, function(match) {
|
return encodeURIComponent(match);
|
});
|
search = search.replace('#', '%23');
|
|
return protocol + host + pathname + search + hash;
|
}
|
|
Url.prototype.format = function() {
|
return format(this);
|
};
|
|
function urlResolve(source, relative) {
|
return urlParse(source, false, true).resolve(relative);
|
}
|
|
Url.prototype.resolve = function(relative) {
|
return this.resolveObject(urlParse(relative, false, true)).format();
|
};
|
|
function urlResolveObject(source, relative) {
|
if (!source) return relative;
|
return urlParse(source, false, true).resolveObject(relative);
|
}
|
|
Url.prototype.resolveObject = function(relative) {
|
if (isString$1(relative)) {
|
var rel = new Url();
|
rel.parse(relative, false, true);
|
relative = rel;
|
}
|
|
var result = new Url();
|
var tkeys = Object.keys(this);
|
for (var tk = 0; tk < tkeys.length; tk++) {
|
var tkey = tkeys[tk];
|
result[tkey] = this[tkey];
|
}
|
|
// hash is always overridden, no matter what.
|
// even href="" will remove it.
|
result.hash = relative.hash;
|
|
// if the relative url is empty, then there's nothing left to do here.
|
if (relative.href === '') {
|
result.href = result.format();
|
return result;
|
}
|
|
// hrefs like //foo/bar always cut to the protocol.
|
if (relative.slashes && !relative.protocol) {
|
// take everything except the protocol from relative
|
var rkeys = Object.keys(relative);
|
for (var rk = 0; rk < rkeys.length; rk++) {
|
var rkey = rkeys[rk];
|
if (rkey !== 'protocol')
|
result[rkey] = relative[rkey];
|
}
|
|
//urlParse appends trailing / to urls like http://www.example.com
|
if (slashedProtocol[result.protocol] &&
|
result.hostname && !result.pathname) {
|
result.path = result.pathname = '/';
|
}
|
|
result.href = result.format();
|
return result;
|
}
|
var relPath;
|
if (relative.protocol && relative.protocol !== result.protocol) {
|
// if it's a known url protocol, then changing
|
// the protocol does weird things
|
// first, if it's not file:, then we MUST have a host,
|
// and if there was a path
|
// to begin with, then we MUST have a path.
|
// if it is file:, then the host is dropped,
|
// because that's known to be hostless.
|
// anything else is assumed to be absolute.
|
if (!slashedProtocol[relative.protocol]) {
|
var keys = Object.keys(relative);
|
for (var v = 0; v < keys.length; v++) {
|
var k = keys[v];
|
result[k] = relative[k];
|
}
|
result.href = result.format();
|
return result;
|
}
|
|
result.protocol = relative.protocol;
|
if (!relative.host && !hostlessProtocol[relative.protocol]) {
|
relPath = (relative.pathname || '').split('/');
|
while (relPath.length && !(relative.host = relPath.shift()));
|
if (!relative.host) relative.host = '';
|
if (!relative.hostname) relative.hostname = '';
|
if (relPath[0] !== '') relPath.unshift('');
|
if (relPath.length < 2) relPath.unshift('');
|
result.pathname = relPath.join('/');
|
} else {
|
result.pathname = relative.pathname;
|
}
|
result.search = relative.search;
|
result.query = relative.query;
|
result.host = relative.host || '';
|
result.auth = relative.auth;
|
result.hostname = relative.hostname || relative.host;
|
result.port = relative.port;
|
// to support http.request
|
if (result.pathname || result.search) {
|
var p = result.pathname || '';
|
var s = result.search || '';
|
result.path = p + s;
|
}
|
result.slashes = result.slashes || relative.slashes;
|
result.href = result.format();
|
return result;
|
}
|
|
var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
|
isRelAbs = (
|
relative.host ||
|
relative.pathname && relative.pathname.charAt(0) === '/'
|
),
|
mustEndAbs = (isRelAbs || isSourceAbs ||
|
(result.host && relative.pathname)),
|
removeAllDots = mustEndAbs,
|
srcPath = result.pathname && result.pathname.split('/') || [],
|
psychotic = result.protocol && !slashedProtocol[result.protocol];
|
relPath = relative.pathname && relative.pathname.split('/') || [];
|
// if the url is a non-slashed url, then relative
|
// links like ../.. should be able
|
// to crawl up to the hostname, as well. This is strange.
|
// result.protocol has already been set by now.
|
// Later on, put the first path part into the host field.
|
if (psychotic) {
|
result.hostname = '';
|
result.port = null;
|
if (result.host) {
|
if (srcPath[0] === '') srcPath[0] = result.host;
|
else srcPath.unshift(result.host);
|
}
|
result.host = '';
|
if (relative.protocol) {
|
relative.hostname = null;
|
relative.port = null;
|
if (relative.host) {
|
if (relPath[0] === '') relPath[0] = relative.host;
|
else relPath.unshift(relative.host);
|
}
|
relative.host = null;
|
}
|
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
|
}
|
var authInHost;
|
if (isRelAbs) {
|
// it's absolute.
|
result.host = (relative.host || relative.host === '') ?
|
relative.host : result.host;
|
result.hostname = (relative.hostname || relative.hostname === '') ?
|
relative.hostname : result.hostname;
|
result.search = relative.search;
|
result.query = relative.query;
|
srcPath = relPath;
|
// fall through to the dot-handling below.
|
} else if (relPath.length) {
|
// it's relative
|
// throw away the existing file, and take the new path instead.
|
if (!srcPath) srcPath = [];
|
srcPath.pop();
|
srcPath = srcPath.concat(relPath);
|
result.search = relative.search;
|
result.query = relative.query;
|
} else if (!isNullOrUndefined(relative.search)) {
|
// just pull out the search.
|
// like href='?foo'.
|
// Put this after the other two cases because it simplifies the booleans
|
if (psychotic) {
|
result.hostname = result.host = srcPath.shift();
|
//occationaly the auth can get stuck only in host
|
//this especially happens in cases like
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
authInHost = result.host && result.host.indexOf('@') > 0 ?
|
result.host.split('@') : false;
|
if (authInHost) {
|
result.auth = authInHost.shift();
|
result.host = result.hostname = authInHost.shift();
|
}
|
}
|
result.search = relative.search;
|
result.query = relative.query;
|
//to support http.request
|
if (!isNull(result.pathname) || !isNull(result.search)) {
|
result.path = (result.pathname ? result.pathname : '') +
|
(result.search ? result.search : '');
|
}
|
result.href = result.format();
|
return result;
|
}
|
|
if (!srcPath.length) {
|
// no path at all. easy.
|
// we've already handled the other stuff above.
|
result.pathname = null;
|
//to support http.request
|
if (result.search) {
|
result.path = '/' + result.search;
|
} else {
|
result.path = null;
|
}
|
result.href = result.format();
|
return result;
|
}
|
|
// if a url ENDs in . or .., then it must get a trailing slash.
|
// however, if it ends in anything else non-slashy,
|
// then it must NOT get a trailing slash.
|
var last = srcPath.slice(-1)[0];
|
var hasTrailingSlash = (
|
(result.host || relative.host || srcPath.length > 1) &&
|
(last === '.' || last === '..') || last === '');
|
|
// strip single dots, resolve double dots to parent dir
|
// if the path tries to go above the root, `up` ends up > 0
|
var up = 0;
|
for (var i = srcPath.length; i >= 0; i--) {
|
last = srcPath[i];
|
if (last === '.') {
|
srcPath.splice(i, 1);
|
} else if (last === '..') {
|
srcPath.splice(i, 1);
|
up++;
|
} else if (up) {
|
srcPath.splice(i, 1);
|
up--;
|
}
|
}
|
|
// if the path is allowed to go above the root, restore leading ..s
|
if (!mustEndAbs && !removeAllDots) {
|
for (; up--; up) {
|
srcPath.unshift('..');
|
}
|
}
|
|
if (mustEndAbs && srcPath[0] !== '' &&
|
(!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
|
srcPath.unshift('');
|
}
|
|
if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
|
srcPath.push('');
|
}
|
|
var isAbsolute = srcPath[0] === '' ||
|
(srcPath[0] && srcPath[0].charAt(0) === '/');
|
|
// put the host back
|
if (psychotic) {
|
result.hostname = result.host = isAbsolute ? '' :
|
srcPath.length ? srcPath.shift() : '';
|
//occationaly the auth can get stuck only in host
|
//this especially happens in cases like
|
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
|
authInHost = result.host && result.host.indexOf('@') > 0 ?
|
result.host.split('@') : false;
|
if (authInHost) {
|
result.auth = authInHost.shift();
|
result.host = result.hostname = authInHost.shift();
|
}
|
}
|
|
mustEndAbs = mustEndAbs || (result.host && srcPath.length);
|
|
if (mustEndAbs && !isAbsolute) {
|
srcPath.unshift('');
|
}
|
|
if (!srcPath.length) {
|
result.pathname = null;
|
result.path = null;
|
} else {
|
result.pathname = srcPath.join('/');
|
}
|
|
//to support request.http
|
if (!isNull(result.pathname) || !isNull(result.search)) {
|
result.path = (result.pathname ? result.pathname : '') +
|
(result.search ? result.search : '');
|
}
|
result.auth = relative.auth || result.auth;
|
result.slashes = result.slashes || relative.slashes;
|
result.href = result.format();
|
return result;
|
};
|
|
Url.prototype.parseHost = function() {
|
return parseHost(this);
|
};
|
|
function parseHost(self) {
|
var host = self.host;
|
var port = portPattern.exec(host);
|
if (port) {
|
port = port[0];
|
if (port !== ':') {
|
self.port = port.substr(1);
|
}
|
host = host.substr(0, host.length - port.length);
|
}
|
if (host) self.hostname = host;
|
}
|
|
var _polyfillNode_url$1 = /*#__PURE__*/Object.freeze({
|
__proto__: null,
|
URL: URL$1,
|
URLSearchParams: URLSearchParams,
|
Url: Url,
|
default: _polyfillNode_url,
|
fileURLToPath: urlFileURLToPath,
|
format: urlFormat,
|
parse: urlParse,
|
resolve: urlResolve,
|
resolveObject: urlResolveObject
|
});
|
|
function isRelativeUrl(url) {
|
const firstChar = url.charAt(0);
|
return firstChar === "." || firstChar === "~" || firstChar === "@";
|
}
|
const externalRE = /^(https?:)?\/\//;
|
function isExternalUrl(url) {
|
return externalRE.test(url);
|
}
|
const dataUrlRE = /^\s*data:/i;
|
function isDataUrl(url) {
|
return dataUrlRE.test(url);
|
}
|
function parseUrl(url) {
|
const firstChar = url.charAt(0);
|
if (firstChar === "~") {
|
const secondChar = url.charAt(1);
|
url = url.slice(secondChar === "/" ? 2 : 1);
|
}
|
return parseUriParts(url);
|
}
|
function parseUriParts(urlString) {
|
return urlParse(isString$2(urlString) ? urlString : "", false, true);
|
}
|
|
var __defProp$9 = Object.defineProperty;
|
var __defProps$9 = Object.defineProperties;
|
var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$9 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$9.call(b, prop))
|
__defNormalProp$9(a, prop, b[prop]);
|
if (__getOwnPropSymbols$9)
|
for (var prop of __getOwnPropSymbols$9(b)) {
|
if (__propIsEnum$9.call(b, prop))
|
__defNormalProp$9(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
|
const defaultAssetUrlOptions = {
|
base: null,
|
includeAbsolute: false,
|
tags: {
|
video: ["src", "poster"],
|
source: ["src"],
|
img: ["src"],
|
image: ["xlink:href", "href"],
|
use: ["xlink:href", "href"]
|
}
|
};
|
const normalizeOptions = (options) => {
|
if (Object.keys(options).some((key) => isArray$3(options[key]))) {
|
return __spreadProps$9(__spreadValues$9({}, defaultAssetUrlOptions), {
|
tags: options
|
});
|
}
|
return __spreadValues$9(__spreadValues$9({}, defaultAssetUrlOptions), options);
|
};
|
const createAssetUrlTransformWithOptions = (options) => {
|
return (node, context) => transformAssetUrl(node, context, options);
|
};
|
const transformAssetUrl = (node, context, options = defaultAssetUrlOptions) => {
|
if (node.type === 1) {
|
if (!node.props.length) {
|
return;
|
}
|
const tags = options.tags || defaultAssetUrlOptions.tags;
|
const attrs = tags[node.tag];
|
const wildCardAttrs = tags["*"];
|
if (!attrs && !wildCardAttrs) {
|
return;
|
}
|
const assetAttrs = (attrs || []).concat(wildCardAttrs || []);
|
node.props.forEach((attr, index) => {
|
if (attr.type !== 6 || !assetAttrs.includes(attr.name) || !attr.value || isExternalUrl(attr.value.content) || isDataUrl(attr.value.content) || attr.value.content[0] === "#" || !options.includeAbsolute && !isRelativeUrl(attr.value.content)) {
|
return;
|
}
|
const url = parseUrl(attr.value.content);
|
if (options.base && attr.value.content[0] === ".") {
|
const base = parseUrl(options.base);
|
const protocol = base.protocol || "";
|
const host = base.host ? protocol + "//" + base.host : "";
|
const basePath = base.path || "/";
|
attr.value.content = host + (path.posix || path).join(basePath, url.path + (url.hash || ""));
|
return;
|
}
|
const exp = getImportsExpressionExp(url.path, url.hash, attr.loc, context);
|
node.props[index] = {
|
type: 7,
|
name: "bind",
|
arg: createSimpleExpression(attr.name, true, attr.loc),
|
exp,
|
modifiers: [],
|
loc: attr.loc
|
};
|
});
|
}
|
};
|
function getImportsExpressionExp(path2, hash, loc, context) {
|
if (path2) {
|
let name;
|
let exp;
|
const existingIndex = context.imports.findIndex((i) => i.path === path2);
|
if (existingIndex > -1) {
|
name = `_imports_${existingIndex}`;
|
exp = context.imports[existingIndex].exp;
|
} else {
|
name = `_imports_${context.imports.length}`;
|
exp = createSimpleExpression(
|
name,
|
false,
|
loc,
|
3
|
);
|
context.imports.push({ exp, path: path2 });
|
}
|
if (!hash) {
|
return exp;
|
}
|
const hashExp = `${name} + '${hash}'`;
|
const finalExp = createSimpleExpression(
|
hashExp,
|
false,
|
loc,
|
3
|
);
|
if (!context.hoistStatic) {
|
return finalExp;
|
}
|
const existingHoistIndex = context.hoists.findIndex((h) => {
|
return h && h.type === 4 && !h.isStatic && h.content === hashExp;
|
});
|
if (existingHoistIndex > -1) {
|
return createSimpleExpression(
|
`_hoisted_${existingHoistIndex + 1}`,
|
false,
|
loc,
|
3
|
);
|
}
|
return context.hoist(finalExp);
|
} else {
|
return createSimpleExpression(`''`, false, loc, 3);
|
}
|
}
|
|
const srcsetTags = ["img", "source"];
|
const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g;
|
const createSrcsetTransformWithOptions = (options) => {
|
return (node, context) => transformSrcset(node, context, options);
|
};
|
const transformSrcset = (node, context, options = defaultAssetUrlOptions) => {
|
if (node.type === 1) {
|
if (srcsetTags.includes(node.tag) && node.props.length) {
|
node.props.forEach((attr, index) => {
|
if (attr.name === "srcset" && attr.type === 6) {
|
if (!attr.value)
|
return;
|
const value = attr.value.content;
|
if (!value)
|
return;
|
const imageCandidates = value.split(",").map((s) => {
|
const [url, descriptor] = s.replace(escapedSpaceCharacters, " ").trim().split(" ", 2);
|
return { url, descriptor };
|
});
|
for (let i = 0; i < imageCandidates.length; i++) {
|
const { url } = imageCandidates[i];
|
if (isDataUrl(url)) {
|
imageCandidates[i + 1].url = url + "," + imageCandidates[i + 1].url;
|
imageCandidates.splice(i, 1);
|
}
|
}
|
const shouldProcessUrl = (url) => {
|
return !isExternalUrl(url) && !isDataUrl(url) && (options.includeAbsolute || isRelativeUrl(url));
|
};
|
if (!imageCandidates.some(({ url }) => shouldProcessUrl(url))) {
|
return;
|
}
|
if (options.base) {
|
const base = options.base;
|
const set = [];
|
let needImportTransform = false;
|
imageCandidates.forEach((candidate) => {
|
let { url, descriptor } = candidate;
|
descriptor = descriptor ? ` ${descriptor}` : ``;
|
if (url[0] === ".") {
|
candidate.url = (path.posix || path).join(base, url);
|
set.push(candidate.url + descriptor);
|
} else if (shouldProcessUrl(url)) {
|
needImportTransform = true;
|
} else {
|
set.push(url + descriptor);
|
}
|
});
|
if (!needImportTransform) {
|
attr.value.content = set.join(", ");
|
return;
|
}
|
}
|
const compoundExpression = createCompoundExpression([], attr.loc);
|
imageCandidates.forEach(({ url, descriptor }, index2) => {
|
if (shouldProcessUrl(url)) {
|
const { path: path2 } = parseUrl(url);
|
let exp2;
|
if (path2) {
|
const existingImportsIndex = context.imports.findIndex(
|
(i) => i.path === path2
|
);
|
if (existingImportsIndex > -1) {
|
exp2 = createSimpleExpression(
|
`_imports_${existingImportsIndex}`,
|
false,
|
attr.loc,
|
3
|
);
|
} else {
|
exp2 = createSimpleExpression(
|
`_imports_${context.imports.length}`,
|
false,
|
attr.loc,
|
3
|
);
|
context.imports.push({ exp: exp2, path: path2 });
|
}
|
compoundExpression.children.push(exp2);
|
}
|
} else {
|
const exp2 = createSimpleExpression(
|
`"${url}"`,
|
false,
|
attr.loc,
|
3
|
);
|
compoundExpression.children.push(exp2);
|
}
|
const isNotLast = imageCandidates.length - 1 > index2;
|
if (descriptor && isNotLast) {
|
compoundExpression.children.push(` + ' ${descriptor}, ' + `);
|
} else if (descriptor) {
|
compoundExpression.children.push(` + ' ${descriptor}'`);
|
} else if (isNotLast) {
|
compoundExpression.children.push(` + ', ' + `);
|
}
|
});
|
let exp = compoundExpression;
|
if (context.hoistStatic) {
|
exp = context.hoist(compoundExpression);
|
exp.constType = 3;
|
}
|
node.props[index] = {
|
type: 7,
|
name: "bind",
|
arg: createSimpleExpression("srcset", true, attr.loc),
|
exp,
|
modifiers: [],
|
loc: attr.loc
|
};
|
}
|
});
|
}
|
}
|
};
|
|
const SSR_INTERPOLATE = Symbol(`ssrInterpolate`);
|
const SSR_RENDER_VNODE = Symbol(`ssrRenderVNode`);
|
const SSR_RENDER_COMPONENT = Symbol(`ssrRenderComponent`);
|
const SSR_RENDER_SLOT = Symbol(`ssrRenderSlot`);
|
const SSR_RENDER_SLOT_INNER = Symbol(`ssrRenderSlotInner`);
|
const SSR_RENDER_CLASS = Symbol(`ssrRenderClass`);
|
const SSR_RENDER_STYLE = Symbol(`ssrRenderStyle`);
|
const SSR_RENDER_ATTRS = Symbol(`ssrRenderAttrs`);
|
const SSR_RENDER_ATTR = Symbol(`ssrRenderAttr`);
|
const SSR_RENDER_DYNAMIC_ATTR = Symbol(`ssrRenderDynamicAttr`);
|
const SSR_RENDER_LIST = Symbol(`ssrRenderList`);
|
const SSR_INCLUDE_BOOLEAN_ATTR = Symbol(`ssrIncludeBooleanAttr`);
|
const SSR_LOOSE_EQUAL = Symbol(`ssrLooseEqual`);
|
const SSR_LOOSE_CONTAIN = Symbol(`ssrLooseContain`);
|
const SSR_RENDER_DYNAMIC_MODEL = Symbol(`ssrRenderDynamicModel`);
|
const SSR_GET_DYNAMIC_MODEL_PROPS = Symbol(`ssrGetDynamicModelProps`);
|
const SSR_RENDER_TELEPORT = Symbol(`ssrRenderTeleport`);
|
const SSR_RENDER_SUSPENSE = Symbol(`ssrRenderSuspense`);
|
const SSR_GET_DIRECTIVE_PROPS = Symbol(`ssrGetDirectiveProps`);
|
const ssrHelpers = {
|
[SSR_INTERPOLATE]: `ssrInterpolate`,
|
[SSR_RENDER_VNODE]: `ssrRenderVNode`,
|
[SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
|
[SSR_RENDER_SLOT]: `ssrRenderSlot`,
|
[SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
|
[SSR_RENDER_CLASS]: `ssrRenderClass`,
|
[SSR_RENDER_STYLE]: `ssrRenderStyle`,
|
[SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
|
[SSR_RENDER_ATTR]: `ssrRenderAttr`,
|
[SSR_RENDER_DYNAMIC_ATTR]: `ssrRenderDynamicAttr`,
|
[SSR_RENDER_LIST]: `ssrRenderList`,
|
[SSR_INCLUDE_BOOLEAN_ATTR]: `ssrIncludeBooleanAttr`,
|
[SSR_LOOSE_EQUAL]: `ssrLooseEqual`,
|
[SSR_LOOSE_CONTAIN]: `ssrLooseContain`,
|
[SSR_RENDER_DYNAMIC_MODEL]: `ssrRenderDynamicModel`,
|
[SSR_GET_DYNAMIC_MODEL_PROPS]: `ssrGetDynamicModelProps`,
|
[SSR_RENDER_TELEPORT]: `ssrRenderTeleport`,
|
[SSR_RENDER_SUSPENSE]: `ssrRenderSuspense`,
|
[SSR_GET_DIRECTIVE_PROPS]: `ssrGetDirectiveProps`
|
};
|
registerRuntimeHelpers(ssrHelpers);
|
|
const ssrTransformIf = createStructuralDirectiveTransform(
|
/^(if|else|else-if)$/,
|
processIf
|
);
|
function ssrProcessIf(node, context, disableNestedFragments = false) {
|
const [rootBranch] = node.branches;
|
const ifStatement = createIfStatement(
|
rootBranch.condition,
|
processIfBranch(rootBranch, context, disableNestedFragments)
|
);
|
context.pushStatement(ifStatement);
|
let currentIf = ifStatement;
|
for (let i = 1; i < node.branches.length; i++) {
|
const branch = node.branches[i];
|
const branchBlockStatement = processIfBranch(
|
branch,
|
context,
|
disableNestedFragments
|
);
|
if (branch.condition) {
|
currentIf = currentIf.alternate = createIfStatement(
|
branch.condition,
|
branchBlockStatement
|
);
|
} else {
|
currentIf.alternate = branchBlockStatement;
|
}
|
}
|
if (!currentIf.alternate) {
|
currentIf.alternate = createBlockStatement([
|
createCallExpression(`_push`, ["`<!---->`"])
|
]);
|
}
|
}
|
function processIfBranch(branch, context, disableNestedFragments = false) {
|
const { children } = branch;
|
const needFragmentWrapper = !disableNestedFragments && (children.length !== 1 || children[0].type !== 1) && // optimize away nested fragments when the only child is a ForNode
|
!(children.length === 1 && children[0].type === 11);
|
return processChildrenAsStatement(branch, context, needFragmentWrapper);
|
}
|
|
const ssrTransformFor = createStructuralDirectiveTransform(
|
"for",
|
processFor
|
);
|
function ssrProcessFor(node, context, disableNestedFragments = false) {
|
const needFragmentWrapper = !disableNestedFragments && (node.children.length !== 1 || node.children[0].type !== 1);
|
const renderLoop = createFunctionExpression(
|
createForLoopParams(node.parseResult)
|
);
|
renderLoop.body = processChildrenAsStatement(
|
node,
|
context,
|
needFragmentWrapper
|
);
|
if (!disableNestedFragments) {
|
context.pushStringPart(`<!--[-->`);
|
}
|
context.pushStatement(
|
createCallExpression(context.helper(SSR_RENDER_LIST), [
|
node.source,
|
renderLoop
|
])
|
);
|
if (!disableNestedFragments) {
|
context.pushStringPart(`<!--]-->`);
|
}
|
}
|
|
const ssrTransformSlotOutlet = (node, context) => {
|
if (isSlotOutlet(node)) {
|
const { slotName, slotProps } = processSlotOutlet(node, context);
|
const args = [
|
`_ctx.$slots`,
|
slotName,
|
slotProps || `{}`,
|
// fallback content placeholder. will be replaced in the process phase
|
`null`,
|
`_push`,
|
`_parent`
|
];
|
if (context.scopeId && context.slotted !== false) {
|
args.push(`"${context.scopeId}-s"`);
|
}
|
let method = SSR_RENDER_SLOT;
|
const parent = context.parent;
|
if (parent && parent.type === 1 && parent.tagType === 1 && resolveComponentType(parent, context, true) === TRANSITION && parent.children.filter((c) => c.type === 1).length === 1) {
|
method = SSR_RENDER_SLOT_INNER;
|
if (!(context.scopeId && context.slotted !== false)) {
|
args.push("null");
|
}
|
args.push("true");
|
}
|
node.ssrCodegenNode = createCallExpression(context.helper(method), args);
|
}
|
};
|
function ssrProcessSlotOutlet(node, context) {
|
const renderCall = node.ssrCodegenNode;
|
if (node.children.length) {
|
const fallbackRenderFn = createFunctionExpression([]);
|
fallbackRenderFn.body = processChildrenAsStatement(node, context);
|
renderCall.arguments[3] = fallbackRenderFn;
|
}
|
if (context.withSlotScopeId) {
|
const slotScopeId = renderCall.arguments[6];
|
renderCall.arguments[6] = slotScopeId ? `${slotScopeId} + _scopeId` : `_scopeId`;
|
}
|
context.pushStatement(node.ssrCodegenNode);
|
}
|
|
function createSSRCompilerError(code, loc) {
|
return createCompilerError(code, loc, SSRErrorMessages);
|
}
|
const SSRErrorMessages = {
|
[65]: `Unsafe attribute name for SSR.`,
|
[66]: `Missing the 'to' prop on teleport element.`,
|
[67]: `Invalid AST node during SSR transform.`
|
};
|
|
function ssrProcessTeleport(node, context) {
|
const targetProp = findProp(node, "to");
|
if (!targetProp) {
|
context.onError(
|
createSSRCompilerError(66, node.loc)
|
);
|
return;
|
}
|
let target;
|
if (targetProp.type === 6) {
|
target = targetProp.value && createSimpleExpression(targetProp.value.content, true);
|
} else {
|
target = targetProp.exp;
|
}
|
if (!target) {
|
context.onError(
|
createSSRCompilerError(
|
66,
|
targetProp.loc
|
)
|
);
|
return;
|
}
|
const disabledProp = findProp(
|
node,
|
"disabled",
|
false,
|
true
|
/* allow empty */
|
);
|
const disabled = disabledProp ? disabledProp.type === 6 ? `true` : disabledProp.exp || `false` : `false`;
|
const contentRenderFn = createFunctionExpression(
|
[`_push`],
|
void 0,
|
// Body is added later
|
true,
|
// newline
|
false,
|
// isSlot
|
node.loc
|
);
|
contentRenderFn.body = processChildrenAsStatement(node, context);
|
context.pushStatement(
|
createCallExpression(context.helper(SSR_RENDER_TELEPORT), [
|
`_push`,
|
contentRenderFn,
|
target,
|
disabled,
|
`_parent`
|
])
|
);
|
}
|
|
const wipMap$2 = /* @__PURE__ */ new WeakMap();
|
function ssrTransformSuspense(node, context) {
|
return () => {
|
if (node.children.length) {
|
const wipEntry = {
|
slotsExp: null,
|
// to be immediately set
|
wipSlots: []
|
};
|
wipMap$2.set(node, wipEntry);
|
wipEntry.slotsExp = buildSlots(node, context, (_props, children, loc) => {
|
const fn = createFunctionExpression(
|
[],
|
void 0,
|
// no return, assign body later
|
true,
|
// newline
|
false,
|
// suspense slots are not treated as normal slots
|
loc
|
);
|
wipEntry.wipSlots.push({
|
fn,
|
children
|
});
|
return fn;
|
}).slots;
|
}
|
};
|
}
|
function ssrProcessSuspense(node, context) {
|
const wipEntry = wipMap$2.get(node);
|
if (!wipEntry) {
|
return;
|
}
|
const { slotsExp, wipSlots } = wipEntry;
|
for (let i = 0; i < wipSlots.length; i++) {
|
const slot = wipSlots[i];
|
slot.fn.body = processChildrenAsStatement(slot, context);
|
}
|
context.pushStatement(
|
createCallExpression(context.helper(SSR_RENDER_SUSPENSE), [
|
`_push`,
|
slotsExp
|
])
|
);
|
}
|
|
const rawChildrenMap = /* @__PURE__ */ new WeakMap();
|
const ssrTransformElement = (node, context) => {
|
if (node.type !== 1 || node.tagType !== 0) {
|
return;
|
}
|
return function ssrPostTransformElement() {
|
const openTag = [`<${node.tag}`];
|
const needTagForRuntime = node.tag === "textarea" || node.tag.indexOf("-") > 0;
|
const hasDynamicVBind = hasDynamicKeyVBind(node);
|
const hasCustomDir = node.props.some(
|
(p) => p.type === 7 && !isBuiltInDirective(p.name)
|
);
|
const needMergeProps = hasDynamicVBind || hasCustomDir;
|
if (needMergeProps) {
|
const { props, directives } = buildProps(
|
node,
|
context,
|
node.props,
|
false,
|
false,
|
true
|
/* ssr */
|
);
|
if (props || directives.length) {
|
const mergedProps = buildSSRProps(props, directives, context);
|
const propsExp = createCallExpression(
|
context.helper(SSR_RENDER_ATTRS),
|
[mergedProps]
|
);
|
if (node.tag === "textarea") {
|
const existingText = node.children[0];
|
if (!existingText || existingText.type !== 5) {
|
const tempId = `_temp${context.temps++}`;
|
propsExp.arguments = [
|
createAssignmentExpression(
|
createSimpleExpression(tempId, false),
|
mergedProps
|
)
|
];
|
rawChildrenMap.set(
|
node,
|
createCallExpression(context.helper(SSR_INTERPOLATE), [
|
createConditionalExpression(
|
createSimpleExpression(`"value" in ${tempId}`, false),
|
createSimpleExpression(`${tempId}.value`, false),
|
createSimpleExpression(
|
existingText ? existingText.content : ``,
|
true
|
),
|
false
|
)
|
])
|
);
|
}
|
} else if (node.tag === "input") {
|
const vModel = findVModel(node);
|
if (vModel) {
|
const tempId = `_temp${context.temps++}`;
|
const tempExp = createSimpleExpression(tempId, false);
|
propsExp.arguments = [
|
createSequenceExpression([
|
createAssignmentExpression(tempExp, mergedProps),
|
createCallExpression(context.helper(MERGE_PROPS), [
|
tempExp,
|
createCallExpression(
|
context.helper(SSR_GET_DYNAMIC_MODEL_PROPS),
|
[
|
tempExp,
|
// existing props
|
vModel.exp
|
// model
|
]
|
)
|
])
|
])
|
];
|
}
|
}
|
if (needTagForRuntime) {
|
propsExp.arguments.push(`"${node.tag}"`);
|
}
|
openTag.push(propsExp);
|
}
|
}
|
let dynamicClassBinding = void 0;
|
let staticClassBinding = void 0;
|
let dynamicStyleBinding = void 0;
|
for (let i = 0; i < node.props.length; i++) {
|
const prop = node.props[i];
|
if (node.tag === "input" && isTrueFalseValue(prop)) {
|
continue;
|
}
|
if (prop.type === 7) {
|
if (prop.name === "html" && prop.exp) {
|
rawChildrenMap.set(node, prop.exp);
|
} else if (prop.name === "text" && prop.exp) {
|
node.children = [createInterpolation(prop.exp, prop.loc)];
|
} else if (prop.name === "slot") {
|
context.onError(
|
createCompilerError(40, prop.loc)
|
);
|
} else if (isTextareaWithValue(node, prop) && prop.exp) {
|
if (!needMergeProps) {
|
node.children = [createInterpolation(prop.exp, prop.loc)];
|
}
|
} else if (!needMergeProps && prop.name !== "on") {
|
const directiveTransform = context.directiveTransforms[prop.name];
|
if (directiveTransform) {
|
const { props, ssrTagParts } = directiveTransform(
|
prop,
|
node,
|
context
|
);
|
if (ssrTagParts) {
|
openTag.push(...ssrTagParts);
|
}
|
for (let j = 0; j < props.length; j++) {
|
const { key, value } = props[j];
|
if (isStaticExp(key)) {
|
let attrName = key.content;
|
if (attrName === "key" || attrName === "ref") {
|
continue;
|
}
|
if (attrName === "class") {
|
openTag.push(
|
` class="`,
|
dynamicClassBinding = createCallExpression(
|
context.helper(SSR_RENDER_CLASS),
|
[value]
|
),
|
`"`
|
);
|
} else if (attrName === "style") {
|
if (dynamicStyleBinding) {
|
mergeCall(dynamicStyleBinding, value);
|
} else {
|
openTag.push(
|
` style="`,
|
dynamicStyleBinding = createCallExpression(
|
context.helper(SSR_RENDER_STYLE),
|
[value]
|
),
|
`"`
|
);
|
}
|
} else {
|
attrName = node.tag.indexOf("-") > 0 ? attrName : propsToAttrMap[attrName] || attrName.toLowerCase();
|
if (isBooleanAttr(attrName)) {
|
openTag.push(
|
createConditionalExpression(
|
createCallExpression(
|
context.helper(SSR_INCLUDE_BOOLEAN_ATTR),
|
[value]
|
),
|
createSimpleExpression(" " + attrName, true),
|
createSimpleExpression("", true),
|
false
|
/* no newline */
|
)
|
);
|
} else if (isSSRSafeAttrName(attrName)) {
|
openTag.push(
|
createCallExpression(context.helper(SSR_RENDER_ATTR), [
|
key,
|
value
|
])
|
);
|
} else {
|
context.onError(
|
createSSRCompilerError(
|
65,
|
key.loc
|
)
|
);
|
}
|
}
|
} else {
|
const args = [key, value];
|
if (needTagForRuntime) {
|
args.push(`"${node.tag}"`);
|
}
|
openTag.push(
|
createCallExpression(
|
context.helper(SSR_RENDER_DYNAMIC_ATTR),
|
args
|
)
|
);
|
}
|
}
|
}
|
}
|
} else {
|
if (node.tag === "textarea" && prop.name === "value" && prop.value) {
|
rawChildrenMap.set(node, escapeHtml(prop.value.content));
|
} else if (!needMergeProps) {
|
if (prop.name === "key" || prop.name === "ref") {
|
continue;
|
}
|
if (prop.name === "class" && prop.value) {
|
staticClassBinding = JSON.stringify(prop.value.content);
|
}
|
openTag.push(
|
` ${prop.name}` + (prop.value ? `="${escapeHtml(prop.value.content)}"` : ``)
|
);
|
}
|
}
|
}
|
if (dynamicClassBinding && staticClassBinding) {
|
mergeCall(dynamicClassBinding, staticClassBinding);
|
removeStaticBinding(openTag, "class");
|
}
|
if (context.scopeId) {
|
openTag.push(` ${context.scopeId}`);
|
}
|
node.ssrCodegenNode = createTemplateLiteral(openTag);
|
};
|
};
|
function buildSSRProps(props, directives, context) {
|
let mergePropsArgs = [];
|
if (props) {
|
if (props.type === 14) {
|
mergePropsArgs = props.arguments;
|
} else {
|
mergePropsArgs.push(props);
|
}
|
}
|
if (directives.length) {
|
for (const dir of directives) {
|
mergePropsArgs.push(
|
createCallExpression(context.helper(SSR_GET_DIRECTIVE_PROPS), [
|
`_ctx`,
|
...buildDirectiveArgs(dir, context).elements
|
])
|
);
|
}
|
}
|
return mergePropsArgs.length > 1 ? createCallExpression(context.helper(MERGE_PROPS), mergePropsArgs) : mergePropsArgs[0];
|
}
|
function isTrueFalseValue(prop) {
|
if (prop.type === 7) {
|
return prop.name === "bind" && prop.arg && isStaticExp(prop.arg) && (prop.arg.content === "true-value" || prop.arg.content === "false-value");
|
} else {
|
return prop.name === "true-value" || prop.name === "false-value";
|
}
|
}
|
function isTextareaWithValue(node, prop) {
|
return !!(node.tag === "textarea" && prop.name === "bind" && isStaticArgOf(prop.arg, "value"));
|
}
|
function mergeCall(call, arg) {
|
const existing = call.arguments[0];
|
if (existing.type === 17) {
|
existing.elements.push(arg);
|
} else {
|
call.arguments[0] = createArrayExpression([existing, arg]);
|
}
|
}
|
function removeStaticBinding(tag, binding) {
|
const regExp = new RegExp(`^ ${binding}=".+"$`);
|
const i = tag.findIndex((e) => typeof e === "string" && regExp.test(e));
|
if (i > -1) {
|
tag.splice(i, 1);
|
}
|
}
|
function findVModel(node) {
|
return node.props.find(
|
(p) => p.type === 7 && p.name === "model" && p.exp
|
);
|
}
|
function ssrProcessElement(node, context) {
|
const isVoidTag = context.options.isVoidTag || NO;
|
const elementsToAdd = node.ssrCodegenNode.elements;
|
for (let j = 0; j < elementsToAdd.length; j++) {
|
context.pushStringPart(elementsToAdd[j]);
|
}
|
if (context.withSlotScopeId) {
|
context.pushStringPart(createSimpleExpression(`_scopeId`, false));
|
}
|
context.pushStringPart(`>`);
|
const rawChildren = rawChildrenMap.get(node);
|
if (rawChildren) {
|
context.pushStringPart(rawChildren);
|
} else if (node.children.length) {
|
processChildren(node, context);
|
}
|
if (!isVoidTag(node.tag)) {
|
context.pushStringPart(`</${node.tag}>`);
|
}
|
}
|
|
const wipMap$1 = /* @__PURE__ */ new WeakMap();
|
function ssrTransformTransitionGroup(node, context) {
|
return () => {
|
const tag = findProp(node, "tag");
|
if (tag) {
|
const otherProps = node.props.filter((p) => p !== tag);
|
const { props, directives } = buildProps(
|
node,
|
context,
|
otherProps,
|
true,
|
false,
|
true
|
/* ssr (skip event listeners) */
|
);
|
let propsExp = null;
|
if (props || directives.length) {
|
propsExp = createCallExpression(context.helper(SSR_RENDER_ATTRS), [
|
buildSSRProps(props, directives, context)
|
]);
|
}
|
wipMap$1.set(node, {
|
tag,
|
propsExp
|
});
|
}
|
};
|
}
|
function ssrProcessTransitionGroup(node, context) {
|
const entry = wipMap$1.get(node);
|
if (entry) {
|
const { tag, propsExp } = entry;
|
if (tag.type === 7) {
|
context.pushStringPart(`<`);
|
context.pushStringPart(tag.exp);
|
if (propsExp) {
|
context.pushStringPart(propsExp);
|
}
|
context.pushStringPart(`>`);
|
processChildren(
|
node,
|
context,
|
false,
|
/**
|
* TransitionGroup has the special runtime behavior of flattening and
|
* concatenating all children into a single fragment (in order for them to
|
* be patched using the same key map) so we need to account for that here
|
* by disabling nested fragment wrappers from being generated.
|
*/
|
true
|
);
|
context.pushStringPart(`</`);
|
context.pushStringPart(tag.exp);
|
context.pushStringPart(`>`);
|
} else {
|
context.pushStringPart(`<${tag.value.content}`);
|
if (propsExp) {
|
context.pushStringPart(propsExp);
|
}
|
context.pushStringPart(`>`);
|
processChildren(node, context, false, true);
|
context.pushStringPart(`</${tag.value.content}>`);
|
}
|
} else {
|
processChildren(node, context, true, true);
|
}
|
}
|
|
var __defProp$8 = Object.defineProperty;
|
var __defProps$8 = Object.defineProperties;
|
var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$8 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$8.call(b, prop))
|
__defNormalProp$8(a, prop, b[prop]);
|
if (__getOwnPropSymbols$8)
|
for (var prop of __getOwnPropSymbols$8(b)) {
|
if (__propIsEnum$8.call(b, prop))
|
__defNormalProp$8(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
|
const wipMap = /* @__PURE__ */ new WeakMap();
|
const WIP_SLOT = Symbol();
|
const componentTypeMap = /* @__PURE__ */ new WeakMap();
|
const ssrTransformComponent = (node, context) => {
|
if (node.type !== 1 || node.tagType !== 1) {
|
return;
|
}
|
const component = resolveComponentType(
|
node,
|
context,
|
true
|
/* ssr */
|
);
|
const isDynamicComponent = isObject$2(component) && component.callee === RESOLVE_DYNAMIC_COMPONENT;
|
componentTypeMap.set(node, component);
|
if (isSymbol$1(component)) {
|
if (component === SUSPENSE) {
|
return ssrTransformSuspense(node, context);
|
}
|
if (component === TRANSITION_GROUP) {
|
return ssrTransformTransitionGroup(node, context);
|
}
|
return;
|
}
|
const vnodeBranches = [];
|
const clonedNode = clone(node);
|
return function ssrPostTransformComponent() {
|
if (clonedNode.children.length) {
|
buildSlots(clonedNode, context, (props, children) => {
|
vnodeBranches.push(createVNodeSlotBranch(props, children, context));
|
return createFunctionExpression(void 0);
|
});
|
}
|
let propsExp = `null`;
|
if (node.props.length) {
|
const { props, directives } = buildProps(
|
node,
|
context,
|
void 0,
|
true,
|
isDynamicComponent
|
);
|
if (props || directives.length) {
|
propsExp = buildSSRProps(props, directives, context);
|
}
|
}
|
const wipEntries = [];
|
wipMap.set(node, wipEntries);
|
const buildSSRSlotFn = (props, children, loc) => {
|
const param0 = props && stringifyExpression(props) || `_`;
|
const fn = createFunctionExpression(
|
[param0, `_push`, `_parent`, `_scopeId`],
|
void 0,
|
// no return, assign body later
|
true,
|
// newline
|
true,
|
// isSlot
|
loc
|
);
|
wipEntries.push({
|
type: WIP_SLOT,
|
fn,
|
children,
|
// also collect the corresponding vnode branch built earlier
|
vnodeBranch: vnodeBranches[wipEntries.length]
|
});
|
return fn;
|
};
|
const slots = node.children.length ? buildSlots(node, context, buildSSRSlotFn).slots : `null`;
|
if (typeof component !== "string") {
|
node.ssrCodegenNode = createCallExpression(
|
context.helper(SSR_RENDER_VNODE),
|
[
|
`_push`,
|
createCallExpression(context.helper(CREATE_VNODE), [
|
component,
|
propsExp,
|
slots
|
]),
|
`_parent`
|
]
|
);
|
} else {
|
node.ssrCodegenNode = createCallExpression(
|
context.helper(SSR_RENDER_COMPONENT),
|
[component, propsExp, slots, `_parent`]
|
);
|
}
|
};
|
};
|
function ssrProcessComponent(node, context, parent) {
|
const component = componentTypeMap.get(node);
|
if (!node.ssrCodegenNode) {
|
if (component === TELEPORT) {
|
return ssrProcessTeleport(node, context);
|
} else if (component === SUSPENSE) {
|
return ssrProcessSuspense(node, context);
|
} else if (component === TRANSITION_GROUP) {
|
return ssrProcessTransitionGroup(node, context);
|
} else {
|
if (parent.type === WIP_SLOT) {
|
context.pushStringPart(``);
|
}
|
if (component === TRANSITION) {
|
node.children = node.children.filter((c) => c.type !== 3);
|
}
|
processChildren(node, context);
|
}
|
} else {
|
const wipEntries = wipMap.get(node) || [];
|
for (let i = 0; i < wipEntries.length; i++) {
|
const { fn, vnodeBranch } = wipEntries[i];
|
fn.body = createIfStatement(
|
createSimpleExpression(`_push`, false),
|
processChildrenAsStatement(
|
wipEntries[i],
|
context,
|
false,
|
true
|
/* withSlotScopeId */
|
),
|
vnodeBranch
|
);
|
}
|
if (context.withSlotScopeId) {
|
node.ssrCodegenNode.arguments.push(`_scopeId`);
|
}
|
if (typeof component === "string") {
|
context.pushStatement(
|
createCallExpression(`_push`, [node.ssrCodegenNode])
|
);
|
} else {
|
context.pushStatement(node.ssrCodegenNode);
|
}
|
}
|
}
|
const rawOptionsMap = /* @__PURE__ */ new WeakMap();
|
const [baseNodeTransforms, baseDirectiveTransforms] = getBaseTransformPreset(true);
|
const vnodeNodeTransforms = [...baseNodeTransforms, ...DOMNodeTransforms];
|
const vnodeDirectiveTransforms = __spreadValues$8(__spreadValues$8({}, baseDirectiveTransforms), DOMDirectiveTransforms);
|
function createVNodeSlotBranch(props, children, parentContext) {
|
const rawOptions = rawOptionsMap.get(parentContext.root);
|
const subOptions = __spreadProps$8(__spreadValues$8({}, rawOptions), {
|
// overwrite with vnode-based transforms
|
nodeTransforms: [
|
...vnodeNodeTransforms,
|
...rawOptions.nodeTransforms || []
|
],
|
directiveTransforms: __spreadValues$8(__spreadValues$8({}, vnodeDirectiveTransforms), rawOptions.directiveTransforms || {})
|
});
|
const wrapperNode = {
|
type: 1,
|
ns: 0,
|
tag: "template",
|
tagType: 3,
|
isSelfClosing: false,
|
// important: provide v-slot="props" on the wrapper for proper
|
// scope analysis
|
props: [
|
{
|
type: 7,
|
name: "slot",
|
exp: props,
|
arg: void 0,
|
modifiers: [],
|
loc: locStub
|
}
|
],
|
children,
|
loc: locStub,
|
codegenNode: void 0
|
};
|
subTransform(wrapperNode, subOptions, parentContext);
|
return createReturnStatement(children);
|
}
|
function subTransform(node, options, parentContext) {
|
const childRoot = createRoot([node]);
|
const childContext = createTransformContext(childRoot, options);
|
childContext.ssr = false;
|
childContext.scopes = __spreadValues$8({}, parentContext.scopes);
|
childContext.identifiers = __spreadValues$8({}, parentContext.identifiers);
|
childContext.imports = parentContext.imports;
|
traverseNode(childRoot, childContext);
|
["helpers", "components", "directives"].forEach((key) => {
|
childContext[key].forEach((value, helperKey) => {
|
if (key === "helpers") {
|
const parentCount = parentContext.helpers.get(helperKey);
|
if (parentCount === void 0) {
|
parentContext.helpers.set(helperKey, value);
|
} else {
|
parentContext.helpers.set(helperKey, value + parentCount);
|
}
|
} else {
|
parentContext[key].add(value);
|
}
|
});
|
});
|
}
|
function clone(v) {
|
if (isArray$3(v)) {
|
return v.map(clone);
|
} else if (isObject$2(v)) {
|
const res = {};
|
for (const key in v) {
|
res[key] = clone(v[key]);
|
}
|
return res;
|
} else {
|
return v;
|
}
|
}
|
|
function ssrCodegenTransform(ast, options) {
|
const context = createSSRTransformContext(ast, options);
|
if (options.ssrCssVars) {
|
const cssContext = createTransformContext(createRoot([]), options);
|
const varsExp = processExpression(
|
createSimpleExpression(options.ssrCssVars, false),
|
cssContext
|
);
|
context.body.push(
|
createCompoundExpression([`const _cssVars = { style: `, varsExp, `}`])
|
);
|
Array.from(cssContext.helpers.keys()).forEach((helper) => {
|
ast.helpers.add(helper);
|
});
|
}
|
const isFragment = ast.children.length > 1 && ast.children.some((c) => !isText$1(c));
|
processChildren(ast, context, isFragment);
|
ast.codegenNode = createBlockStatement(context.body);
|
ast.ssrHelpers = Array.from(
|
/* @__PURE__ */ new Set([
|
...Array.from(ast.helpers).filter((h) => h in ssrHelpers),
|
...context.helpers
|
])
|
);
|
ast.helpers = new Set(Array.from(ast.helpers).filter((h) => !(h in ssrHelpers)));
|
}
|
function createSSRTransformContext(root, options, helpers = /* @__PURE__ */ new Set(), withSlotScopeId = false) {
|
const body = [];
|
let currentString = null;
|
return {
|
root,
|
options,
|
body,
|
helpers,
|
withSlotScopeId,
|
onError: options.onError || ((e) => {
|
throw e;
|
}),
|
helper(name) {
|
helpers.add(name);
|
return name;
|
},
|
pushStringPart(part) {
|
if (!currentString) {
|
const currentCall = createCallExpression(`_push`);
|
body.push(currentCall);
|
currentString = createTemplateLiteral([]);
|
currentCall.arguments.push(currentString);
|
}
|
const bufferedElements = currentString.elements;
|
const lastItem = bufferedElements[bufferedElements.length - 1];
|
if (isString$2(part) && isString$2(lastItem)) {
|
bufferedElements[bufferedElements.length - 1] += part;
|
} else {
|
bufferedElements.push(part);
|
}
|
},
|
pushStatement(statement) {
|
currentString = null;
|
body.push(statement);
|
}
|
};
|
}
|
function createChildContext(parent, withSlotScopeId = parent.withSlotScopeId) {
|
return createSSRTransformContext(
|
parent.root,
|
parent.options,
|
parent.helpers,
|
withSlotScopeId
|
);
|
}
|
function processChildren(parent, context, asFragment = false, disableNestedFragments = false) {
|
if (asFragment) {
|
context.pushStringPart(`<!--[-->`);
|
}
|
const { children } = parent;
|
for (let i = 0; i < children.length; i++) {
|
const child = children[i];
|
switch (child.type) {
|
case 1:
|
switch (child.tagType) {
|
case 0:
|
ssrProcessElement(child, context);
|
break;
|
case 1:
|
ssrProcessComponent(child, context, parent);
|
break;
|
case 2:
|
ssrProcessSlotOutlet(child, context);
|
break;
|
case 3:
|
break;
|
default:
|
context.onError(
|
createSSRCompilerError(
|
67,
|
child.loc
|
)
|
);
|
const exhaustiveCheck2 = child;
|
return exhaustiveCheck2;
|
}
|
break;
|
case 2:
|
context.pushStringPart(escapeHtml(child.content));
|
break;
|
case 3:
|
context.pushStringPart(`<!--${child.content}-->`);
|
break;
|
case 5:
|
context.pushStringPart(
|
createCallExpression(context.helper(SSR_INTERPOLATE), [child.content])
|
);
|
break;
|
case 9:
|
ssrProcessIf(child, context, disableNestedFragments);
|
break;
|
case 11:
|
ssrProcessFor(child, context, disableNestedFragments);
|
break;
|
case 10:
|
break;
|
case 12:
|
case 8:
|
break;
|
default:
|
context.onError(
|
createSSRCompilerError(
|
67,
|
child.loc
|
)
|
);
|
const exhaustiveCheck = child;
|
return exhaustiveCheck;
|
}
|
}
|
if (asFragment) {
|
context.pushStringPart(`<!--]-->`);
|
}
|
}
|
function processChildrenAsStatement(parent, parentContext, asFragment = false, withSlotScopeId = parentContext.withSlotScopeId) {
|
const childContext = createChildContext(parentContext, withSlotScopeId);
|
processChildren(parent, childContext, asFragment);
|
return createBlockStatement(childContext.body);
|
}
|
|
const ssrTransformModel = (dir, node, context) => {
|
const model = dir.exp;
|
function checkDuplicatedValue() {
|
const value = findProp(node, "value");
|
if (value) {
|
context.onError(
|
createDOMCompilerError(
|
60,
|
value.loc
|
)
|
);
|
}
|
}
|
if (node.tagType === 0) {
|
const res = { props: [] };
|
const defaultProps = [
|
// default value binding for text type inputs
|
createObjectProperty(`value`, model)
|
];
|
if (node.tag === "input") {
|
const type = findProp(node, "type");
|
if (type) {
|
const value = findValueBinding(node);
|
if (type.type === 7) {
|
res.ssrTagParts = [
|
createCallExpression(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
|
type.exp,
|
model,
|
value
|
])
|
];
|
} else if (type.value) {
|
switch (type.value.content) {
|
case "radio":
|
res.props = [
|
createObjectProperty(
|
`checked`,
|
createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
|
model,
|
value
|
])
|
)
|
];
|
break;
|
case "checkbox":
|
const trueValueBinding = findProp(node, "true-value");
|
if (trueValueBinding) {
|
const trueValue = trueValueBinding.type === 6 ? JSON.stringify(trueValueBinding.value.content) : trueValueBinding.exp;
|
res.props = [
|
createObjectProperty(
|
`checked`,
|
createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
|
model,
|
trueValue
|
])
|
)
|
];
|
} else {
|
res.props = [
|
createObjectProperty(
|
`checked`,
|
createConditionalExpression(
|
createCallExpression(`Array.isArray`, [model]),
|
createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
|
model,
|
value
|
]),
|
model
|
)
|
)
|
];
|
}
|
break;
|
case "file":
|
context.onError(
|
createDOMCompilerError(
|
59,
|
dir.loc
|
)
|
);
|
break;
|
default:
|
checkDuplicatedValue();
|
res.props = defaultProps;
|
break;
|
}
|
}
|
} else if (hasDynamicKeyVBind(node)) ; else {
|
checkDuplicatedValue();
|
res.props = defaultProps;
|
}
|
} else if (node.tag === "textarea") {
|
checkDuplicatedValue();
|
node.children = [createInterpolation(model, model.loc)];
|
} else if (node.tag === "select") ; else {
|
context.onError(
|
createDOMCompilerError(
|
57,
|
dir.loc
|
)
|
);
|
}
|
return res;
|
} else {
|
return transformModel$1(dir, node, context);
|
}
|
};
|
function findValueBinding(node) {
|
const valueBinding = findProp(node, "value");
|
return valueBinding ? valueBinding.type === 7 ? valueBinding.exp : createSimpleExpression(valueBinding.value.content, true) : createSimpleExpression(`null`, false);
|
}
|
|
const ssrTransformShow = (dir, node, context) => {
|
if (!dir.exp) {
|
context.onError(
|
createDOMCompilerError(61)
|
);
|
}
|
return {
|
props: [
|
createObjectProperty(
|
`style`,
|
createConditionalExpression(
|
dir.exp,
|
createSimpleExpression(`null`, false),
|
createObjectExpression([
|
createObjectProperty(
|
`display`,
|
createSimpleExpression(`none`, true)
|
)
|
]),
|
false
|
/* no newline */
|
)
|
)
|
]
|
};
|
};
|
|
const filterChild = (node) => node.children.filter((n) => n.type !== 3);
|
const hasSingleChild = (node) => filterChild(node).length === 1;
|
const ssrInjectFallthroughAttrs = (node, context) => {
|
if (node.type === 0) {
|
context.identifiers._attrs = 1;
|
}
|
if (node.type === 1 && node.tagType === 1 && (isBuiltInType(node.tag, "Transition") || isBuiltInType(node.tag, "KeepAlive"))) {
|
const rootChildren = filterChild(context.root);
|
if (rootChildren.length === 1 && rootChildren[0] === node) {
|
if (hasSingleChild(node)) {
|
injectFallthroughAttrs(node.children[0]);
|
}
|
return;
|
}
|
}
|
const parent = context.parent;
|
if (!parent || parent.type !== 0) {
|
return;
|
}
|
if (node.type === 10 && hasSingleChild(node)) {
|
let hasEncounteredIf = false;
|
for (const c of filterChild(parent)) {
|
if (c.type === 9 || c.type === 1 && findDir(c, "if")) {
|
if (hasEncounteredIf)
|
return;
|
hasEncounteredIf = true;
|
} else if (
|
// node before v-if
|
!hasEncounteredIf || // non else nodes
|
!(c.type === 1 && findDir(c, /else/, true))
|
) {
|
return;
|
}
|
}
|
injectFallthroughAttrs(node.children[0]);
|
} else if (hasSingleChild(parent)) {
|
injectFallthroughAttrs(node);
|
}
|
};
|
function injectFallthroughAttrs(node) {
|
if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !findDir(node, "for")) {
|
node.props.push({
|
type: 7,
|
name: "bind",
|
arg: void 0,
|
exp: createSimpleExpression(`_attrs`, false),
|
modifiers: [],
|
loc: locStub
|
});
|
}
|
}
|
|
const ssrInjectCssVars = (node, context) => {
|
if (!context.ssrCssVars) {
|
return;
|
}
|
if (node.type === 0) {
|
context.identifiers._cssVars = 1;
|
}
|
const parent = context.parent;
|
if (!parent || parent.type !== 0) {
|
return;
|
}
|
if (node.type === 10) {
|
for (const child of node.children) {
|
injectCssVars(child);
|
}
|
} else {
|
injectCssVars(node);
|
}
|
};
|
function injectCssVars(node) {
|
if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !findDir(node, "for")) {
|
if (isBuiltInType(node.tag, "Suspense")) {
|
for (const child of node.children) {
|
if (child.type === 1 && child.tagType === 3) {
|
child.children.forEach(injectCssVars);
|
} else {
|
injectCssVars(child);
|
}
|
}
|
} else {
|
node.props.push({
|
type: 7,
|
name: "bind",
|
arg: void 0,
|
exp: createSimpleExpression(`_cssVars`, false),
|
modifiers: [],
|
loc: locStub
|
});
|
}
|
}
|
}
|
|
var __defProp$7 = Object.defineProperty;
|
var __defProps$7 = Object.defineProperties;
|
var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$7 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$7.call(b, prop))
|
__defNormalProp$7(a, prop, b[prop]);
|
if (__getOwnPropSymbols$7)
|
for (var prop of __getOwnPropSymbols$7(b)) {
|
if (__propIsEnum$7.call(b, prop))
|
__defNormalProp$7(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
|
function compile(template, options = {}) {
|
options = __spreadProps$7(__spreadValues$7(__spreadValues$7({}, options), parserOptions), {
|
ssr: true,
|
inSSR: true,
|
scopeId: options.mode === "function" ? null : options.scopeId,
|
// always prefix since compiler-ssr doesn't have size concern
|
prefixIdentifiers: true,
|
// disable optimizations that are unnecessary for ssr
|
cacheHandlers: false,
|
hoistStatic: false
|
});
|
const ast = baseParse(template, options);
|
rawOptionsMap.set(ast, options);
|
transform$1(ast, __spreadProps$7(__spreadValues$7({}, options), {
|
hoistStatic: false,
|
nodeTransforms: [
|
ssrTransformIf,
|
ssrTransformFor,
|
trackVForSlotScopes,
|
transformExpression,
|
ssrTransformSlotOutlet,
|
ssrInjectFallthroughAttrs,
|
ssrInjectCssVars,
|
ssrTransformElement,
|
ssrTransformComponent,
|
trackSlotScopes,
|
transformStyle,
|
...options.nodeTransforms || []
|
// user transforms
|
],
|
directiveTransforms: __spreadValues$7({
|
// reusing core v-bind
|
bind: transformBind,
|
on: transformOn$1,
|
// model and show has dedicated SSR handling
|
model: ssrTransformModel,
|
show: ssrTransformShow,
|
// the following are ignored during SSR
|
// on: noopDirectiveTransform,
|
cloak: noopDirectiveTransform,
|
once: noopDirectiveTransform,
|
memo: noopDirectiveTransform
|
}, options.directiveTransforms || {})
|
}));
|
ssrCodegenTransform(ast, options);
|
return generate(ast, options);
|
}
|
|
var CompilerSSR = /*#__PURE__*/Object.freeze({
|
__proto__: null,
|
compile: compile
|
});
|
|
var _polyfillNode_fs = {};
|
|
var _polyfillNode_fs$1 = /*#__PURE__*/Object.freeze({
|
__proto__: null,
|
default: _polyfillNode_fs
|
});
|
|
var require$$0$2 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_fs$1);
|
|
var require$$2$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_path);
|
|
var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_util$1);
|
|
const hasWarned$1 = {};
|
function warnOnce$4(msg) {
|
const isNodeProd = typeof process !== "undefined" && process.env.NODE_ENV === "production";
|
if (!isNodeProd && true && !hasWarned$1[msg]) {
|
hasWarned$1[msg] = true;
|
warn$1(msg);
|
}
|
}
|
function warn$1(msg) {
|
console.warn(
|
`\x1B[1m\x1B[33m[@vue/compiler-sfc]\x1B[0m\x1B[33m ${msg}\x1B[0m
|
`
|
);
|
}
|
|
var __defProp$6 = Object.defineProperty;
|
var __defProps$6 = Object.defineProperties;
|
var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$6 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$6.call(b, prop))
|
__defNormalProp$6(a, prop, b[prop]);
|
if (__getOwnPropSymbols$6)
|
for (var prop of __getOwnPropSymbols$6(b)) {
|
if (__propIsEnum$6.call(b, prop))
|
__defNormalProp$6(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
|
function preprocess$1({ source, filename, preprocessOptions }, preprocessor) {
|
let res = "";
|
let err = null;
|
preprocessor.render(
|
source,
|
__spreadValues$6({ filename }, preprocessOptions),
|
(_err, _res) => {
|
if (_err)
|
err = _err;
|
res = _res;
|
}
|
);
|
if (err)
|
throw err;
|
return res;
|
}
|
function compileTemplate(options) {
|
const { preprocessLang, preprocessCustomRequire } = options;
|
if (preprocessLang && !preprocessCustomRequire) {
|
throw new Error(
|
`[@vue/compiler-sfc] Template preprocessing in the browser build must provide the \`preprocessCustomRequire\` option to return the in-browser version of the preprocessor in the shape of { render(): string }.`
|
);
|
}
|
const preprocessor = preprocessLang ? preprocessCustomRequire ? preprocessCustomRequire(preprocessLang) : void 0 : false;
|
if (preprocessor) {
|
try {
|
return doCompileTemplate(__spreadProps$6(__spreadValues$6({}, options), {
|
source: preprocess$1(options, preprocessor)
|
}));
|
} catch (e) {
|
return {
|
code: `export default function render() {}`,
|
source: options.source,
|
tips: [],
|
errors: [e]
|
};
|
}
|
} else if (preprocessLang) {
|
return {
|
code: `export default function render() {}`,
|
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 doCompileTemplate(options);
|
}
|
}
|
function doCompileTemplate({
|
filename,
|
id,
|
scoped,
|
slotted,
|
inMap,
|
source,
|
ssr = false,
|
ssrCssVars,
|
isProd = false,
|
compiler = ssr ? CompilerSSR : CompilerDOM,
|
compilerOptions = {},
|
transformAssetUrls
|
}) {
|
const errors = [];
|
const warnings = [];
|
let nodeTransforms = [];
|
if (isObject$2(transformAssetUrls)) {
|
const assetOptions = normalizeOptions(transformAssetUrls);
|
nodeTransforms = [
|
createAssetUrlTransformWithOptions(assetOptions),
|
createSrcsetTransformWithOptions(assetOptions)
|
];
|
} else if (transformAssetUrls !== false) {
|
nodeTransforms = [transformAssetUrl, transformSrcset];
|
}
|
if (ssr && !ssrCssVars) {
|
warnOnce$4(
|
`compileTemplate is called with \`ssr: true\` but no corresponding \`cssVars\` option.\`.`
|
);
|
}
|
if (!id) {
|
warnOnce$4(`compileTemplate now requires the \`id\` option.\`.`);
|
id = "";
|
}
|
const shortId = id.replace(/^data-v-/, "");
|
const longId = `data-v-${shortId}`;
|
let { code, ast, preamble, map } = compiler.compile(source, __spreadProps$6(__spreadValues$6({
|
mode: "module",
|
prefixIdentifiers: true,
|
hoistStatic: true,
|
cacheHandlers: true,
|
ssrCssVars: ssr && ssrCssVars && ssrCssVars.length ? genCssVarsFromList(ssrCssVars, shortId, isProd, true) : "",
|
scopeId: scoped ? longId : void 0,
|
slotted,
|
sourceMap: true
|
}, compilerOptions), {
|
nodeTransforms: nodeTransforms.concat(compilerOptions.nodeTransforms || []),
|
filename,
|
onError: (e) => errors.push(e),
|
onWarn: (w) => warnings.push(w)
|
}));
|
if (inMap) {
|
if (map) {
|
map = mapLines(inMap, map);
|
}
|
if (errors.length) {
|
patchErrors(errors, source, inMap);
|
}
|
}
|
const tips = warnings.map((w) => {
|
let msg = w.message;
|
if (w.loc) {
|
msg += `
|
${generateCodeFrame(
|
source,
|
w.loc.start.offset,
|
w.loc.end.offset
|
)}`;
|
}
|
return msg;
|
});
|
return { code, ast, preamble, source, errors, tips, map };
|
}
|
function mapLines(oldMap, newMap) {
|
if (!oldMap)
|
return newMap;
|
if (!newMap)
|
return oldMap;
|
const oldMapConsumer = new SourceMapConsumer$5(oldMap);
|
const newMapConsumer = new SourceMapConsumer$5(newMap);
|
const mergedMapGenerator = new SourceMapGenerator$6();
|
newMapConsumer.eachMapping((m) => {
|
if (m.originalLine == null) {
|
return;
|
}
|
const origPosInOldMap = oldMapConsumer.originalPositionFor({
|
line: m.originalLine,
|
column: m.originalColumn
|
});
|
if (origPosInOldMap.source == null) {
|
return;
|
}
|
mergedMapGenerator.addMapping({
|
generated: {
|
line: m.generatedLine,
|
column: m.generatedColumn
|
},
|
original: {
|
line: origPosInOldMap.line,
|
// map line
|
// use current column, since the oldMap produced by @vue/compiler-sfc
|
// does not
|
column: m.originalColumn
|
},
|
source: origPosInOldMap.source,
|
name: origPosInOldMap.name
|
});
|
});
|
const generator = mergedMapGenerator;
|
oldMapConsumer.sources.forEach((sourceFile) => {
|
generator._sources.add(sourceFile);
|
const sourceContent = oldMapConsumer.sourceContentFor(sourceFile);
|
if (sourceContent != null) {
|
mergedMapGenerator.setSourceContent(sourceFile, sourceContent);
|
}
|
});
|
generator._sourceRoot = oldMap.sourceRoot;
|
generator._file = oldMap.file;
|
return generator.toJSON();
|
}
|
function patchErrors(errors, source, inMap) {
|
const originalSource = inMap.sourcesContent[0];
|
const offset = originalSource.indexOf(source);
|
const lineOffset = originalSource.slice(0, offset).split(/\r?\n/).length - 1;
|
errors.forEach((err) => {
|
if (err.loc) {
|
err.loc.start.line += lineOffset;
|
err.loc.start.offset += offset;
|
if (err.loc.end !== err.loc.start) {
|
err.loc.end.line += lineOffset;
|
err.loc.end.offset += offset;
|
}
|
}
|
});
|
}
|
|
var picocolorsExports = {};
|
var picocolors = {
|
get exports(){ return picocolorsExports; },
|
set exports(v){ picocolorsExports = v; },
|
};
|
|
// MIT lisence
|
// from https://github.com/substack/tty-browserify/blob/1ba769a6429d242f36226538835b4034bf6b7886/index.js
|
|
function isatty() {
|
return false;
|
}
|
|
function ReadStream() {
|
throw new Error('tty.ReadStream is not implemented');
|
}
|
|
function WriteStream() {
|
throw new Error('tty.ReadStream is not implemented');
|
}
|
|
var _polyfillNode_tty = {
|
isatty: isatty,
|
ReadStream: ReadStream,
|
WriteStream: WriteStream
|
};
|
|
var _polyfillNode_tty$1 = /*#__PURE__*/Object.freeze({
|
__proto__: null,
|
ReadStream: ReadStream,
|
WriteStream: WriteStream,
|
default: _polyfillNode_tty,
|
isatty: isatty
|
});
|
|
var require$$0 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_tty$1);
|
|
let tty = require$$0;
|
|
let isColorSupported =
|
!("NO_COLOR" in ({}) || browser$1.argv.includes("--no-color")) &&
|
("FORCE_COLOR" in ({}) ||
|
browser$1.argv.includes("--color") ||
|
"" === "win32" ||
|
(tty.isatty(1) && browser$1.env.TERM !== "dumb") ||
|
"CI" in ({}));
|
|
let formatter =
|
(open, close, replace = open) =>
|
input => {
|
let string = "" + input;
|
let index = string.indexOf(close, open.length);
|
return ~index
|
? open + replaceClose(string, close, replace, index) + close
|
: open + string + close
|
};
|
|
let replaceClose = (string, close, replace, index) => {
|
let start = string.substring(0, index) + replace;
|
let end = string.substring(index + close.length);
|
let nextIndex = end.indexOf(close);
|
return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end
|
};
|
|
let createColors = (enabled = isColorSupported) => ({
|
isColorSupported: enabled,
|
reset: enabled ? s => `\x1b[0m${s}\x1b[0m` : String,
|
bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
|
dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
|
italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
|
underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
|
inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
|
hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
|
strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
|
black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
|
red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
|
green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
|
yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
|
blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
|
magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
|
cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
|
white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
|
gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
|
bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
|
bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
|
bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
|
bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
|
bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
|
bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
|
bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
|
bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
|
});
|
|
picocolors.exports = createColors();
|
picocolorsExports.createColors = createColors;
|
|
const SINGLE_QUOTE = "'".charCodeAt(0);
|
const DOUBLE_QUOTE = '"'.charCodeAt(0);
|
const BACKSLASH = '\\'.charCodeAt(0);
|
const SLASH = '/'.charCodeAt(0);
|
const NEWLINE = '\n'.charCodeAt(0);
|
const SPACE = ' '.charCodeAt(0);
|
const FEED = '\f'.charCodeAt(0);
|
const TAB = '\t'.charCodeAt(0);
|
const CR = '\r'.charCodeAt(0);
|
const OPEN_SQUARE = '['.charCodeAt(0);
|
const CLOSE_SQUARE = ']'.charCodeAt(0);
|
const OPEN_PARENTHESES = '('.charCodeAt(0);
|
const CLOSE_PARENTHESES = ')'.charCodeAt(0);
|
const OPEN_CURLY = '{'.charCodeAt(0);
|
const CLOSE_CURLY = '}'.charCodeAt(0);
|
const SEMICOLON = ';'.charCodeAt(0);
|
const ASTERISK = '*'.charCodeAt(0);
|
const COLON = ':'.charCodeAt(0);
|
const AT = '@'.charCodeAt(0);
|
|
const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
|
const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
|
const RE_BAD_BRACKET = /.[\n"'(/\\]/;
|
const RE_HEX_ESCAPE = /[\da-f]/i;
|
|
var tokenize$1 = function tokenizer(input, options = {}) {
|
let css = input.css.valueOf();
|
let ignore = options.ignoreErrors;
|
|
let code, next, quote, content, escape;
|
let escaped, escapePos, prev, n, currentToken;
|
|
let length = css.length;
|
let pos = 0;
|
let buffer = [];
|
let returned = [];
|
|
function position() {
|
return pos
|
}
|
|
function unclosed(what) {
|
throw input.error('Unclosed ' + what, pos)
|
}
|
|
function endOfFile() {
|
return returned.length === 0 && pos >= length
|
}
|
|
function nextToken(opts) {
|
if (returned.length) return returned.pop()
|
if (pos >= length) return
|
|
let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
|
|
code = css.charCodeAt(pos);
|
|
switch (code) {
|
case NEWLINE:
|
case SPACE:
|
case TAB:
|
case CR:
|
case FEED: {
|
next = pos;
|
do {
|
next += 1;
|
code = css.charCodeAt(next);
|
} while (
|
code === SPACE ||
|
code === NEWLINE ||
|
code === TAB ||
|
code === CR ||
|
code === FEED
|
)
|
|
currentToken = ['space', css.slice(pos, next)];
|
pos = next - 1;
|
break
|
}
|
|
case OPEN_SQUARE:
|
case CLOSE_SQUARE:
|
case OPEN_CURLY:
|
case CLOSE_CURLY:
|
case COLON:
|
case SEMICOLON:
|
case CLOSE_PARENTHESES: {
|
let controlChar = String.fromCharCode(code);
|
currentToken = [controlChar, controlChar, pos];
|
break
|
}
|
|
case OPEN_PARENTHESES: {
|
prev = buffer.length ? buffer.pop()[1] : '';
|
n = css.charCodeAt(pos + 1);
|
if (
|
prev === 'url' &&
|
n !== SINGLE_QUOTE &&
|
n !== DOUBLE_QUOTE &&
|
n !== SPACE &&
|
n !== NEWLINE &&
|
n !== TAB &&
|
n !== FEED &&
|
n !== CR
|
) {
|
next = pos;
|
do {
|
escaped = false;
|
next = css.indexOf(')', next + 1);
|
if (next === -1) {
|
if (ignore || ignoreUnclosed) {
|
next = pos;
|
break
|
} else {
|
unclosed('bracket');
|
}
|
}
|
escapePos = next;
|
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
escapePos -= 1;
|
escaped = !escaped;
|
}
|
} while (escaped)
|
|
currentToken = ['brackets', css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
} else {
|
next = css.indexOf(')', pos + 1);
|
content = css.slice(pos, next + 1);
|
|
if (next === -1 || RE_BAD_BRACKET.test(content)) {
|
currentToken = ['(', '(', pos];
|
} else {
|
currentToken = ['brackets', content, pos, next];
|
pos = next;
|
}
|
}
|
|
break
|
}
|
|
case SINGLE_QUOTE:
|
case DOUBLE_QUOTE: {
|
quote = code === SINGLE_QUOTE ? "'" : '"';
|
next = pos;
|
do {
|
escaped = false;
|
next = css.indexOf(quote, next + 1);
|
if (next === -1) {
|
if (ignore || ignoreUnclosed) {
|
next = pos + 1;
|
break
|
} else {
|
unclosed('string');
|
}
|
}
|
escapePos = next;
|
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
escapePos -= 1;
|
escaped = !escaped;
|
}
|
} while (escaped)
|
|
currentToken = ['string', css.slice(pos, next + 1), pos, next];
|
pos = next;
|
break
|
}
|
|
case AT: {
|
RE_AT_END.lastIndex = pos + 1;
|
RE_AT_END.test(css);
|
if (RE_AT_END.lastIndex === 0) {
|
next = css.length - 1;
|
} else {
|
next = RE_AT_END.lastIndex - 2;
|
}
|
|
currentToken = ['at-word', css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
break
|
}
|
|
case BACKSLASH: {
|
next = pos;
|
escape = true;
|
while (css.charCodeAt(next + 1) === BACKSLASH) {
|
next += 1;
|
escape = !escape;
|
}
|
code = css.charCodeAt(next + 1);
|
if (
|
escape &&
|
code !== SLASH &&
|
code !== SPACE &&
|
code !== NEWLINE &&
|
code !== TAB &&
|
code !== CR &&
|
code !== FEED
|
) {
|
next += 1;
|
if (RE_HEX_ESCAPE.test(css.charAt(next))) {
|
while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
|
next += 1;
|
}
|
if (css.charCodeAt(next + 1) === SPACE) {
|
next += 1;
|
}
|
}
|
}
|
|
currentToken = ['word', css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
break
|
}
|
|
default: {
|
if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
|
next = css.indexOf('*/', pos + 2) + 1;
|
if (next === 0) {
|
if (ignore || ignoreUnclosed) {
|
next = css.length;
|
} else {
|
unclosed('comment');
|
}
|
}
|
|
currentToken = ['comment', css.slice(pos, next + 1), pos, next];
|
pos = next;
|
} else {
|
RE_WORD_END.lastIndex = pos + 1;
|
RE_WORD_END.test(css);
|
if (RE_WORD_END.lastIndex === 0) {
|
next = css.length - 1;
|
} else {
|
next = RE_WORD_END.lastIndex - 2;
|
}
|
|
currentToken = ['word', css.slice(pos, next + 1), pos, next];
|
buffer.push(currentToken);
|
pos = next;
|
}
|
|
break
|
}
|
}
|
|
pos++;
|
return currentToken
|
}
|
|
function back(token) {
|
returned.push(token);
|
}
|
|
return {
|
back,
|
nextToken,
|
endOfFile,
|
position
|
}
|
};
|
|
let pico$1 = picocolorsExports;
|
|
let tokenizer$1 = tokenize$1;
|
|
let Input$5;
|
|
function registerInput(dependant) {
|
Input$5 = dependant;
|
}
|
|
const HIGHLIGHT_THEME = {
|
'brackets': pico$1.cyan,
|
'at-word': pico$1.cyan,
|
'comment': pico$1.gray,
|
'string': pico$1.green,
|
'class': pico$1.yellow,
|
'hash': pico$1.magenta,
|
'call': pico$1.cyan,
|
'(': pico$1.cyan,
|
')': pico$1.cyan,
|
'{': pico$1.yellow,
|
'}': pico$1.yellow,
|
'[': pico$1.yellow,
|
']': pico$1.yellow,
|
':': pico$1.yellow,
|
';': pico$1.yellow
|
};
|
|
function getTokenType([type, value], processor) {
|
if (type === 'word') {
|
if (value[0] === '.') {
|
return 'class'
|
}
|
if (value[0] === '#') {
|
return 'hash'
|
}
|
}
|
|
if (!processor.endOfFile()) {
|
let next = processor.nextToken();
|
processor.back(next);
|
if (next[0] === 'brackets' || next[0] === '(') return 'call'
|
}
|
|
return type
|
}
|
|
function terminalHighlight$2(css) {
|
let processor = tokenizer$1(new Input$5(css), { ignoreErrors: true });
|
let result = '';
|
while (!processor.endOfFile()) {
|
let token = processor.nextToken();
|
let color = HIGHLIGHT_THEME[getTokenType(token, processor)];
|
if (color) {
|
result += token[1]
|
.split(/\r?\n/)
|
.map(i => color(i))
|
.join('\n');
|
} else {
|
result += token[1];
|
}
|
}
|
return result
|
}
|
|
terminalHighlight$2.registerInput = registerInput;
|
|
var terminalHighlight_1 = terminalHighlight$2;
|
|
let pico = picocolorsExports;
|
|
let terminalHighlight$1 = terminalHighlight_1;
|
|
let CssSyntaxError$3 = class CssSyntaxError extends Error {
|
constructor(message, line, column, source, file, plugin) {
|
super(message);
|
this.name = 'CssSyntaxError';
|
this.reason = message;
|
|
if (file) {
|
this.file = file;
|
}
|
if (source) {
|
this.source = source;
|
}
|
if (plugin) {
|
this.plugin = plugin;
|
}
|
if (typeof line !== 'undefined' && typeof column !== 'undefined') {
|
if (typeof line === 'number') {
|
this.line = line;
|
this.column = column;
|
} else {
|
this.line = line.line;
|
this.column = line.column;
|
this.endLine = column.line;
|
this.endColumn = column.column;
|
}
|
}
|
|
this.setMessage();
|
|
if (Error.captureStackTrace) {
|
Error.captureStackTrace(this, CssSyntaxError);
|
}
|
}
|
|
setMessage() {
|
this.message = this.plugin ? this.plugin + ': ' : '';
|
this.message += this.file ? this.file : '<css input>';
|
if (typeof this.line !== 'undefined') {
|
this.message += ':' + this.line + ':' + this.column;
|
}
|
this.message += ': ' + this.reason;
|
}
|
|
showSourceCode(color) {
|
if (!this.source) return ''
|
|
let css = this.source;
|
if (color == null) color = pico.isColorSupported;
|
if (terminalHighlight$1) {
|
if (color) css = terminalHighlight$1(css);
|
}
|
|
let lines = css.split(/\r?\n/);
|
let start = Math.max(this.line - 3, 0);
|
let end = Math.min(this.line + 2, lines.length);
|
|
let maxWidth = String(end).length;
|
|
let mark, aside;
|
if (color) {
|
let { bold, red, gray } = pico.createColors(true);
|
mark = text => bold(red(text));
|
aside = text => gray(text);
|
} else {
|
mark = aside = str => str;
|
}
|
|
return lines
|
.slice(start, end)
|
.map((line, index) => {
|
let number = start + 1 + index;
|
let gutter = ' ' + (' ' + number).slice(-maxWidth) + ' | ';
|
if (number === this.line) {
|
let spacing =
|
aside(gutter.replace(/\d/g, ' ')) +
|
line.slice(0, this.column - 1).replace(/[^\t]/g, ' ');
|
return mark('>') + aside(gutter) + line + '\n ' + spacing + mark('^')
|
}
|
return ' ' + aside(gutter) + line
|
})
|
.join('\n')
|
}
|
|
toString() {
|
let code = this.showSourceCode();
|
if (code) {
|
code = '\n\n' + code + '\n';
|
}
|
return this.name + ': ' + this.message + code
|
}
|
};
|
|
var cssSyntaxError = CssSyntaxError$3;
|
CssSyntaxError$3.default = CssSyntaxError$3;
|
|
var symbols = {};
|
|
symbols.isClean = Symbol('isClean');
|
|
symbols.my = Symbol('my');
|
|
const DEFAULT_RAW = {
|
colon: ': ',
|
indent: ' ',
|
beforeDecl: '\n',
|
beforeRule: '\n',
|
beforeOpen: ' ',
|
beforeClose: '\n',
|
beforeComment: '\n',
|
after: '\n',
|
emptyBody: '',
|
commentLeft: ' ',
|
commentRight: ' ',
|
semicolon: false
|
};
|
|
function capitalize(str) {
|
return str[0].toUpperCase() + str.slice(1)
|
}
|
|
let Stringifier$2 = class Stringifier {
|
constructor(builder) {
|
this.builder = builder;
|
}
|
|
stringify(node, semicolon) {
|
/* c8 ignore start */
|
if (!this[node.type]) {
|
throw new Error(
|
'Unknown AST node type ' +
|
node.type +
|
'. ' +
|
'Maybe you need to change PostCSS stringifier.'
|
)
|
}
|
/* c8 ignore stop */
|
this[node.type](node, semicolon);
|
}
|
|
document(node) {
|
this.body(node);
|
}
|
|
root(node) {
|
this.body(node);
|
if (node.raws.after) this.builder(node.raws.after);
|
}
|
|
comment(node) {
|
let left = this.raw(node, 'left', 'commentLeft');
|
let right = this.raw(node, 'right', 'commentRight');
|
this.builder('/*' + left + node.text + right + '*/', node);
|
}
|
|
decl(node, semicolon) {
|
let between = this.raw(node, 'between', 'colon');
|
let string = node.prop + between + this.rawValue(node, 'value');
|
|
if (node.important) {
|
string += node.raws.important || ' !important';
|
}
|
|
if (semicolon) string += ';';
|
this.builder(string, node);
|
}
|
|
rule(node) {
|
this.block(node, this.rawValue(node, 'selector'));
|
if (node.raws.ownSemicolon) {
|
this.builder(node.raws.ownSemicolon, node, 'end');
|
}
|
}
|
|
atrule(node, semicolon) {
|
let name = '@' + node.name;
|
let params = node.params ? this.rawValue(node, 'params') : '';
|
|
if (typeof node.raws.afterName !== 'undefined') {
|
name += node.raws.afterName;
|
} else if (params) {
|
name += ' ';
|
}
|
|
if (node.nodes) {
|
this.block(node, name + params);
|
} else {
|
let end = (node.raws.between || '') + (semicolon ? ';' : '');
|
this.builder(name + params + end, node);
|
}
|
}
|
|
body(node) {
|
let last = node.nodes.length - 1;
|
while (last > 0) {
|
if (node.nodes[last].type !== 'comment') break
|
last -= 1;
|
}
|
|
let semicolon = this.raw(node, 'semicolon');
|
for (let i = 0; i < node.nodes.length; i++) {
|
let child = node.nodes[i];
|
let before = this.raw(child, 'before');
|
if (before) this.builder(before);
|
this.stringify(child, last !== i || semicolon);
|
}
|
}
|
|
block(node, start) {
|
let between = this.raw(node, 'between', 'beforeOpen');
|
this.builder(start + between + '{', node, 'start');
|
|
let after;
|
if (node.nodes && node.nodes.length) {
|
this.body(node);
|
after = this.raw(node, 'after');
|
} else {
|
after = this.raw(node, 'after', 'emptyBody');
|
}
|
|
if (after) this.builder(after);
|
this.builder('}', node, 'end');
|
}
|
|
raw(node, own, detect) {
|
let value;
|
if (!detect) detect = own;
|
|
// Already had
|
if (own) {
|
value = node.raws[own];
|
if (typeof value !== 'undefined') return value
|
}
|
|
let parent = node.parent;
|
|
if (detect === 'before') {
|
// Hack for first rule in CSS
|
if (!parent || (parent.type === 'root' && parent.first === node)) {
|
return ''
|
}
|
|
// `root` nodes in `document` should use only their own raws
|
if (parent && parent.type === 'document') {
|
return ''
|
}
|
}
|
|
// Floating child without parent
|
if (!parent) return DEFAULT_RAW[detect]
|
|
// Detect style by other nodes
|
let root = node.root();
|
if (!root.rawCache) root.rawCache = {};
|
if (typeof root.rawCache[detect] !== 'undefined') {
|
return root.rawCache[detect]
|
}
|
|
if (detect === 'before' || detect === 'after') {
|
return this.beforeAfter(node, detect)
|
} else {
|
let method = 'raw' + capitalize(detect);
|
if (this[method]) {
|
value = this[method](root, node);
|
} else {
|
root.walk(i => {
|
value = i.raws[own];
|
if (typeof value !== 'undefined') return false
|
});
|
}
|
}
|
|
if (typeof value === 'undefined') value = DEFAULT_RAW[detect];
|
|
root.rawCache[detect] = value;
|
return value
|
}
|
|
rawSemicolon(root) {
|
let value;
|
root.walk(i => {
|
if (i.nodes && i.nodes.length && i.last.type === 'decl') {
|
value = i.raws.semicolon;
|
if (typeof value !== 'undefined') return false
|
}
|
});
|
return value
|
}
|
|
rawEmptyBody(root) {
|
let value;
|
root.walk(i => {
|
if (i.nodes && i.nodes.length === 0) {
|
value = i.raws.after;
|
if (typeof value !== 'undefined') return false
|
}
|
});
|
return value
|
}
|
|
rawIndent(root) {
|
if (root.raws.indent) return root.raws.indent
|
let value;
|
root.walk(i => {
|
let p = i.parent;
|
if (p && p !== root && p.parent && p.parent === root) {
|
if (typeof i.raws.before !== 'undefined') {
|
let parts = i.raws.before.split('\n');
|
value = parts[parts.length - 1];
|
value = value.replace(/\S/g, '');
|
return false
|
}
|
}
|
});
|
return value
|
}
|
|
rawBeforeComment(root, node) {
|
let value;
|
root.walkComments(i => {
|
if (typeof i.raws.before !== 'undefined') {
|
value = i.raws.before;
|
if (value.includes('\n')) {
|
value = value.replace(/[^\n]+$/, '');
|
}
|
return false
|
}
|
});
|
if (typeof value === 'undefined') {
|
value = this.raw(node, null, 'beforeDecl');
|
} else if (value) {
|
value = value.replace(/\S/g, '');
|
}
|
return value
|
}
|
|
rawBeforeDecl(root, node) {
|
let value;
|
root.walkDecls(i => {
|
if (typeof i.raws.before !== 'undefined') {
|
value = i.raws.before;
|
if (value.includes('\n')) {
|
value = value.replace(/[^\n]+$/, '');
|
}
|
return false
|
}
|
});
|
if (typeof value === 'undefined') {
|
value = this.raw(node, null, 'beforeRule');
|
} else if (value) {
|
value = value.replace(/\S/g, '');
|
}
|
return value
|
}
|
|
rawBeforeRule(root) {
|
let value;
|
root.walk(i => {
|
if (i.nodes && (i.parent !== root || root.first !== i)) {
|
if (typeof i.raws.before !== 'undefined') {
|
value = i.raws.before;
|
if (value.includes('\n')) {
|
value = value.replace(/[^\n]+$/, '');
|
}
|
return false
|
}
|
}
|
});
|
if (value) value = value.replace(/\S/g, '');
|
return value
|
}
|
|
rawBeforeClose(root) {
|
let value;
|
root.walk(i => {
|
if (i.nodes && i.nodes.length > 0) {
|
if (typeof i.raws.after !== 'undefined') {
|
value = i.raws.after;
|
if (value.includes('\n')) {
|
value = value.replace(/[^\n]+$/, '');
|
}
|
return false
|
}
|
}
|
});
|
if (value) value = value.replace(/\S/g, '');
|
return value
|
}
|
|
rawBeforeOpen(root) {
|
let value;
|
root.walk(i => {
|
if (i.type !== 'decl') {
|
value = i.raws.between;
|
if (typeof value !== 'undefined') return false
|
}
|
});
|
return value
|
}
|
|
rawColon(root) {
|
let value;
|
root.walkDecls(i => {
|
if (typeof i.raws.between !== 'undefined') {
|
value = i.raws.between.replace(/[^\s:]/g, '');
|
return false
|
}
|
});
|
return value
|
}
|
|
beforeAfter(node, detect) {
|
let value;
|
if (node.type === 'decl') {
|
value = this.raw(node, null, 'beforeDecl');
|
} else if (node.type === 'comment') {
|
value = this.raw(node, null, 'beforeComment');
|
} else if (detect === 'before') {
|
value = this.raw(node, null, 'beforeRule');
|
} else {
|
value = this.raw(node, null, 'beforeClose');
|
}
|
|
let buf = node.parent;
|
let depth = 0;
|
while (buf && buf.type !== 'root') {
|
depth += 1;
|
buf = buf.parent;
|
}
|
|
if (value.includes('\n')) {
|
let indent = this.raw(node, null, 'indent');
|
if (indent.length) {
|
for (let step = 0; step < depth; step++) value += indent;
|
}
|
}
|
|
return value
|
}
|
|
rawValue(node, prop) {
|
let value = node[prop];
|
let raw = node.raws[prop];
|
if (raw && raw.value === value) {
|
return raw.raw
|
}
|
|
return value
|
}
|
};
|
|
var stringifier = Stringifier$2;
|
Stringifier$2.default = Stringifier$2;
|
|
let Stringifier$1 = stringifier;
|
|
function stringify$4(node, builder) {
|
let str = new Stringifier$1(builder);
|
str.stringify(node);
|
}
|
|
var stringify_1 = stringify$4;
|
stringify$4.default = stringify$4;
|
|
let { isClean: isClean$2, my: my$2 } = symbols;
|
let CssSyntaxError$2 = cssSyntaxError;
|
let Stringifier = stringifier;
|
let stringify$3 = stringify_1;
|
|
function cloneNode(obj, parent) {
|
let cloned = new obj.constructor();
|
|
for (let i in obj) {
|
if (!Object.prototype.hasOwnProperty.call(obj, i)) {
|
/* c8 ignore next 2 */
|
continue
|
}
|
if (i === 'proxyCache') continue
|
let value = obj[i];
|
let type = typeof value;
|
|
if (i === 'parent' && type === 'object') {
|
if (parent) cloned[i] = parent;
|
} else if (i === 'source') {
|
cloned[i] = value;
|
} else if (Array.isArray(value)) {
|
cloned[i] = value.map(j => cloneNode(j, cloned));
|
} else {
|
if (type === 'object' && value !== null) value = cloneNode(value);
|
cloned[i] = value;
|
}
|
}
|
|
return cloned
|
}
|
|
let Node$4 = class Node {
|
constructor(defaults = {}) {
|
this.raws = {};
|
this[isClean$2] = false;
|
this[my$2] = true;
|
|
for (let name in defaults) {
|
if (name === 'nodes') {
|
this.nodes = [];
|
for (let node of defaults[name]) {
|
if (typeof node.clone === 'function') {
|
this.append(node.clone());
|
} else {
|
this.append(node);
|
}
|
}
|
} else {
|
this[name] = defaults[name];
|
}
|
}
|
}
|
|
error(message, opts = {}) {
|
if (this.source) {
|
let { start, end } = this.rangeBy(opts);
|
return this.source.input.error(
|
message,
|
{ line: start.line, column: start.column },
|
{ line: end.line, column: end.column },
|
opts
|
)
|
}
|
return new CssSyntaxError$2(message)
|
}
|
|
warn(result, text, opts) {
|
let data = { node: this };
|
for (let i in opts) data[i] = opts[i];
|
return result.warn(text, data)
|
}
|
|
remove() {
|
if (this.parent) {
|
this.parent.removeChild(this);
|
}
|
this.parent = undefined;
|
return this
|
}
|
|
toString(stringifier = stringify$3) {
|
if (stringifier.stringify) stringifier = stringifier.stringify;
|
let result = '';
|
stringifier(this, i => {
|
result += i;
|
});
|
return result
|
}
|
|
assign(overrides = {}) {
|
for (let name in overrides) {
|
this[name] = overrides[name];
|
}
|
return this
|
}
|
|
clone(overrides = {}) {
|
let cloned = cloneNode(this);
|
for (let name in overrides) {
|
cloned[name] = overrides[name];
|
}
|
return cloned
|
}
|
|
cloneBefore(overrides = {}) {
|
let cloned = this.clone(overrides);
|
this.parent.insertBefore(this, cloned);
|
return cloned
|
}
|
|
cloneAfter(overrides = {}) {
|
let cloned = this.clone(overrides);
|
this.parent.insertAfter(this, cloned);
|
return cloned
|
}
|
|
replaceWith(...nodes) {
|
if (this.parent) {
|
let bookmark = this;
|
let foundSelf = false;
|
for (let node of nodes) {
|
if (node === this) {
|
foundSelf = true;
|
} else if (foundSelf) {
|
this.parent.insertAfter(bookmark, node);
|
bookmark = node;
|
} else {
|
this.parent.insertBefore(bookmark, node);
|
}
|
}
|
|
if (!foundSelf) {
|
this.remove();
|
}
|
}
|
|
return this
|
}
|
|
next() {
|
if (!this.parent) return undefined
|
let index = this.parent.index(this);
|
return this.parent.nodes[index + 1]
|
}
|
|
prev() {
|
if (!this.parent) return undefined
|
let index = this.parent.index(this);
|
return this.parent.nodes[index - 1]
|
}
|
|
before(add) {
|
this.parent.insertBefore(this, add);
|
return this
|
}
|
|
after(add) {
|
this.parent.insertAfter(this, add);
|
return this
|
}
|
|
root() {
|
let result = this;
|
while (result.parent && result.parent.type !== 'document') {
|
result = result.parent;
|
}
|
return result
|
}
|
|
raw(prop, defaultType) {
|
let str = new Stringifier();
|
return str.raw(this, prop, defaultType)
|
}
|
|
cleanRaws(keepBetween) {
|
delete this.raws.before;
|
delete this.raws.after;
|
if (!keepBetween) delete this.raws.between;
|
}
|
|
toJSON(_, inputs) {
|
let fixed = {};
|
let emitInputs = inputs == null;
|
inputs = inputs || new Map();
|
let inputsNextIndex = 0;
|
|
for (let name in this) {
|
if (!Object.prototype.hasOwnProperty.call(this, name)) {
|
/* c8 ignore next 2 */
|
continue
|
}
|
if (name === 'parent' || name === 'proxyCache') continue
|
let value = this[name];
|
|
if (Array.isArray(value)) {
|
fixed[name] = value.map(i => {
|
if (typeof i === 'object' && i.toJSON) {
|
return i.toJSON(null, inputs)
|
} else {
|
return i
|
}
|
});
|
} else if (typeof value === 'object' && value.toJSON) {
|
fixed[name] = value.toJSON(null, inputs);
|
} else if (name === 'source') {
|
let inputId = inputs.get(value.input);
|
if (inputId == null) {
|
inputId = inputsNextIndex;
|
inputs.set(value.input, inputsNextIndex);
|
inputsNextIndex++;
|
}
|
fixed[name] = {
|
inputId,
|
start: value.start,
|
end: value.end
|
};
|
} else {
|
fixed[name] = value;
|
}
|
}
|
|
if (emitInputs) {
|
fixed.inputs = [...inputs.keys()].map(input => input.toJSON());
|
}
|
|
return fixed
|
}
|
|
positionInside(index) {
|
let string = this.toString();
|
let column = this.source.start.column;
|
let line = this.source.start.line;
|
|
for (let i = 0; i < index; i++) {
|
if (string[i] === '\n') {
|
column = 1;
|
line += 1;
|
} else {
|
column += 1;
|
}
|
}
|
|
return { line, column }
|
}
|
|
positionBy(opts) {
|
let pos = this.source.start;
|
if (opts.index) {
|
pos = this.positionInside(opts.index);
|
} else if (opts.word) {
|
let index = this.toString().indexOf(opts.word);
|
if (index !== -1) pos = this.positionInside(index);
|
}
|
return pos
|
}
|
|
rangeBy(opts) {
|
let start = {
|
line: this.source.start.line,
|
column: this.source.start.column
|
};
|
let end = this.source.end
|
? {
|
line: this.source.end.line,
|
column: this.source.end.column + 1
|
}
|
: {
|
line: start.line,
|
column: start.column + 1
|
};
|
|
if (opts.word) {
|
let index = this.toString().indexOf(opts.word);
|
if (index !== -1) {
|
start = this.positionInside(index);
|
end = this.positionInside(index + opts.word.length);
|
}
|
} else {
|
if (opts.start) {
|
start = {
|
line: opts.start.line,
|
column: opts.start.column
|
};
|
} else if (opts.index) {
|
start = this.positionInside(opts.index);
|
}
|
|
if (opts.end) {
|
end = {
|
line: opts.end.line,
|
column: opts.end.column
|
};
|
} else if (opts.endIndex) {
|
end = this.positionInside(opts.endIndex);
|
} else if (opts.index) {
|
end = this.positionInside(opts.index + 1);
|
}
|
}
|
|
if (
|
end.line < start.line ||
|
(end.line === start.line && end.column <= start.column)
|
) {
|
end = { line: start.line, column: start.column + 1 };
|
}
|
|
return { start, end }
|
}
|
|
getProxyProcessor() {
|
return {
|
set(node, prop, value) {
|
if (node[prop] === value) return true
|
node[prop] = value;
|
if (
|
prop === 'prop' ||
|
prop === 'value' ||
|
prop === 'name' ||
|
prop === 'params' ||
|
prop === 'important' ||
|
/* c8 ignore next */
|
prop === 'text'
|
) {
|
node.markDirty();
|
}
|
return true
|
},
|
|
get(node, prop) {
|
if (prop === 'proxyOf') {
|
return node
|
} else if (prop === 'root') {
|
return () => node.root().toProxy()
|
} else {
|
return node[prop]
|
}
|
}
|
}
|
}
|
|
toProxy() {
|
if (!this.proxyCache) {
|
this.proxyCache = new Proxy(this, this.getProxyProcessor());
|
}
|
return this.proxyCache
|
}
|
|
addToError(error) {
|
error.postcssNode = this;
|
if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
|
let s = this.source;
|
error.stack = error.stack.replace(
|
/\n\s{4}at /,
|
`$&${s.input.from}:${s.start.line}:${s.start.column}$&`
|
);
|
}
|
return error
|
}
|
|
markDirty() {
|
if (this[isClean$2]) {
|
this[isClean$2] = false;
|
let next = this;
|
while ((next = next.parent)) {
|
next[isClean$2] = false;
|
}
|
}
|
}
|
|
get proxyOf() {
|
return this
|
}
|
};
|
|
var node$2 = Node$4;
|
Node$4.default = Node$4;
|
|
let Node$3 = node$2;
|
|
let Declaration$4 = class Declaration extends Node$3 {
|
constructor(defaults) {
|
if (
|
defaults &&
|
typeof defaults.value !== 'undefined' &&
|
typeof defaults.value !== 'string'
|
) {
|
defaults = { ...defaults, value: String(defaults.value) };
|
}
|
super(defaults);
|
this.type = 'decl';
|
}
|
|
get variable() {
|
return this.prop.startsWith('--') || this.prop[0] === '$'
|
}
|
};
|
|
var declaration = Declaration$4;
|
Declaration$4.default = Declaration$4;
|
|
var require$$2 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_url$1);
|
|
let urlAlphabet =
|
'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
|
let customAlphabet = (alphabet, defaultSize = 21) => {
|
return (size = defaultSize) => {
|
let id = '';
|
let i = size;
|
while (i--) {
|
id += alphabet[(Math.random() * alphabet.length) | 0];
|
}
|
return id
|
}
|
};
|
let nanoid$1 = (size = 21) => {
|
let id = '';
|
let i = size;
|
while (i--) {
|
id += urlAlphabet[(Math.random() * 64) | 0];
|
}
|
return id
|
};
|
var nonSecure = { nanoid: nanoid$1, customAlphabet };
|
|
let { SourceMapConsumer: SourceMapConsumer$4, SourceMapGenerator: SourceMapGenerator$5 } = sourceMap$2;
|
let { existsSync, readFileSync } = require$$0$2;
|
let { dirname: dirname$1, join } = require$$2$1;
|
|
function fromBase64(str) {
|
if (Buffer$1) {
|
return Buffer$1.from(str, 'base64').toString()
|
} else {
|
/* c8 ignore next 2 */
|
return window.atob(str)
|
}
|
}
|
|
let PreviousMap$2 = class PreviousMap {
|
constructor(css, opts) {
|
if (opts.map === false) return
|
this.loadAnnotation(css);
|
this.inline = this.startWith(this.annotation, 'data:');
|
|
let prev = opts.map ? opts.map.prev : undefined;
|
let text = this.loadMap(opts.from, prev);
|
if (!this.mapFile && opts.from) {
|
this.mapFile = opts.from;
|
}
|
if (this.mapFile) this.root = dirname$1(this.mapFile);
|
if (text) this.text = text;
|
}
|
|
consumer() {
|
if (!this.consumerCache) {
|
this.consumerCache = new SourceMapConsumer$4(this.text);
|
}
|
return this.consumerCache
|
}
|
|
withContent() {
|
return !!(
|
this.consumer().sourcesContent &&
|
this.consumer().sourcesContent.length > 0
|
)
|
}
|
|
startWith(string, start) {
|
if (!string) return false
|
return string.substr(0, start.length) === start
|
}
|
|
getAnnotationURL(sourceMapString) {
|
return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, '').trim()
|
}
|
|
loadAnnotation(css) {
|
let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
|
if (!comments) return
|
|
// sourceMappingURLs from comments, strings, etc.
|
let start = css.lastIndexOf(comments.pop());
|
let end = css.indexOf('*/', start);
|
|
if (start > -1 && end > -1) {
|
// Locate the last sourceMappingURL to avoid pickin
|
this.annotation = this.getAnnotationURL(css.substring(start, end));
|
}
|
}
|
|
decodeInline(text) {
|
let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
|
let baseUri = /^data:application\/json;base64,/;
|
let charsetUri = /^data:application\/json;charset=utf-?8,/;
|
let uri = /^data:application\/json,/;
|
|
if (charsetUri.test(text) || uri.test(text)) {
|
return decodeURIComponent(text.substr(RegExp.lastMatch.length))
|
}
|
|
if (baseCharsetUri.test(text) || baseUri.test(text)) {
|
return fromBase64(text.substr(RegExp.lastMatch.length))
|
}
|
|
let encoding = text.match(/data:application\/json;([^,]+),/)[1];
|
throw new Error('Unsupported source map encoding ' + encoding)
|
}
|
|
loadFile(path) {
|
this.root = dirname$1(path);
|
if (existsSync(path)) {
|
this.mapFile = path;
|
return readFileSync(path, 'utf-8').toString().trim()
|
}
|
}
|
|
loadMap(file, prev) {
|
if (prev === false) return false
|
|
if (prev) {
|
if (typeof prev === 'string') {
|
return prev
|
} else if (typeof prev === 'function') {
|
let prevPath = prev(file);
|
if (prevPath) {
|
let map = this.loadFile(prevPath);
|
if (!map) {
|
throw new Error(
|
'Unable to load previous source map: ' + prevPath.toString()
|
)
|
}
|
return map
|
}
|
} else if (prev instanceof SourceMapConsumer$4) {
|
return SourceMapGenerator$5.fromSourceMap(prev).toString()
|
} else if (prev instanceof SourceMapGenerator$5) {
|
return prev.toString()
|
} else if (this.isMap(prev)) {
|
return JSON.stringify(prev)
|
} else {
|
throw new Error(
|
'Unsupported previous source map format: ' + prev.toString()
|
)
|
}
|
} else if (this.inline) {
|
return this.decodeInline(this.annotation)
|
} else if (this.annotation) {
|
let map = this.annotation;
|
if (file) map = join(dirname$1(file), map);
|
return this.loadFile(map)
|
}
|
}
|
|
isMap(map) {
|
if (typeof map !== 'object') return false
|
return (
|
typeof map.mappings === 'string' ||
|
typeof map._mappings === 'string' ||
|
Array.isArray(map.sections)
|
)
|
}
|
};
|
|
var previousMap = PreviousMap$2;
|
PreviousMap$2.default = PreviousMap$2;
|
|
let { SourceMapConsumer: SourceMapConsumer$3, SourceMapGenerator: SourceMapGenerator$4 } = sourceMap$2;
|
let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
|
let { resolve: resolve$1, isAbsolute } = require$$2$1;
|
let { nanoid } = nonSecure;
|
|
let terminalHighlight = terminalHighlight_1;
|
let CssSyntaxError$1 = cssSyntaxError;
|
let PreviousMap$1 = previousMap;
|
|
let fromOffsetCache = Symbol('fromOffsetCache');
|
|
let sourceMapAvailable$1 = Boolean(SourceMapConsumer$3 && SourceMapGenerator$4);
|
let pathAvailable$1 = Boolean(resolve$1 && isAbsolute);
|
|
let Input$4 = class Input {
|
constructor(css, opts = {}) {
|
if (
|
css === null ||
|
typeof css === 'undefined' ||
|
(typeof css === 'object' && !css.toString)
|
) {
|
throw new Error(`PostCSS received ${css} instead of CSS string`)
|
}
|
|
this.css = css.toString();
|
|
if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') {
|
this.hasBOM = true;
|
this.css = this.css.slice(1);
|
} else {
|
this.hasBOM = false;
|
}
|
|
if (opts.from) {
|
if (
|
!pathAvailable$1 ||
|
/^\w+:\/\//.test(opts.from) ||
|
isAbsolute(opts.from)
|
) {
|
this.file = opts.from;
|
} else {
|
this.file = resolve$1(opts.from);
|
}
|
}
|
|
if (pathAvailable$1 && sourceMapAvailable$1) {
|
let map = new PreviousMap$1(this.css, opts);
|
if (map.text) {
|
this.map = map;
|
let file = map.consumer().file;
|
if (!this.file && file) this.file = this.mapResolve(file);
|
}
|
}
|
|
if (!this.file) {
|
this.id = '<input css ' + nanoid(6) + '>';
|
}
|
if (this.map) this.map.file = this.from;
|
}
|
|
fromOffset(offset) {
|
let lastLine, lineToIndex;
|
if (!this[fromOffsetCache]) {
|
let lines = this.css.split('\n');
|
lineToIndex = new Array(lines.length);
|
let prevIndex = 0;
|
|
for (let i = 0, l = lines.length; i < l; i++) {
|
lineToIndex[i] = prevIndex;
|
prevIndex += lines[i].length + 1;
|
}
|
|
this[fromOffsetCache] = lineToIndex;
|
} else {
|
lineToIndex = this[fromOffsetCache];
|
}
|
lastLine = lineToIndex[lineToIndex.length - 1];
|
|
let min = 0;
|
if (offset >= lastLine) {
|
min = lineToIndex.length - 1;
|
} else {
|
let max = lineToIndex.length - 2;
|
let mid;
|
while (min < max) {
|
mid = min + ((max - min) >> 1);
|
if (offset < lineToIndex[mid]) {
|
max = mid - 1;
|
} else if (offset >= lineToIndex[mid + 1]) {
|
min = mid + 1;
|
} else {
|
min = mid;
|
break
|
}
|
}
|
}
|
return {
|
line: min + 1,
|
col: offset - lineToIndex[min] + 1
|
}
|
}
|
|
error(message, line, column, opts = {}) {
|
let result, endLine, endColumn;
|
|
if (line && typeof line === 'object') {
|
let start = line;
|
let end = column;
|
if (typeof start.offset === 'number') {
|
let pos = this.fromOffset(start.offset);
|
line = pos.line;
|
column = pos.col;
|
} else {
|
line = start.line;
|
column = start.column;
|
}
|
if (typeof end.offset === 'number') {
|
let pos = this.fromOffset(end.offset);
|
endLine = pos.line;
|
endColumn = pos.col;
|
} else {
|
endLine = end.line;
|
endColumn = end.column;
|
}
|
} else if (!column) {
|
let pos = this.fromOffset(line);
|
line = pos.line;
|
column = pos.col;
|
}
|
|
let origin = this.origin(line, column, endLine, endColumn);
|
if (origin) {
|
result = new CssSyntaxError$1(
|
message,
|
origin.endLine === undefined
|
? origin.line
|
: { line: origin.line, column: origin.column },
|
origin.endLine === undefined
|
? origin.column
|
: { line: origin.endLine, column: origin.endColumn },
|
origin.source,
|
origin.file,
|
opts.plugin
|
);
|
} else {
|
result = new CssSyntaxError$1(
|
message,
|
endLine === undefined ? line : { line, column },
|
endLine === undefined ? column : { line: endLine, column: endColumn },
|
this.css,
|
this.file,
|
opts.plugin
|
);
|
}
|
|
result.input = { line, column, endLine, endColumn, source: this.css };
|
if (this.file) {
|
if (pathToFileURL$1) {
|
result.input.url = pathToFileURL$1(this.file).toString();
|
}
|
result.input.file = this.file;
|
}
|
|
return result
|
}
|
|
origin(line, column, endLine, endColumn) {
|
if (!this.map) return false
|
let consumer = this.map.consumer();
|
|
let from = consumer.originalPositionFor({ line, column });
|
if (!from.source) return false
|
|
let to;
|
if (typeof endLine === 'number') {
|
to = consumer.originalPositionFor({ line: endLine, column: endColumn });
|
}
|
|
let fromUrl;
|
|
if (isAbsolute(from.source)) {
|
fromUrl = pathToFileURL$1(from.source);
|
} else {
|
fromUrl = new URL(
|
from.source,
|
this.map.consumer().sourceRoot || pathToFileURL$1(this.map.mapFile)
|
);
|
}
|
|
let result = {
|
url: fromUrl.toString(),
|
line: from.line,
|
column: from.column,
|
endLine: to && to.line,
|
endColumn: to && to.column
|
};
|
|
if (fromUrl.protocol === 'file:') {
|
if (fileURLToPath) {
|
result.file = fileURLToPath(fromUrl);
|
} else {
|
/* c8 ignore next 2 */
|
throw new Error(`file: protocol is not available in this PostCSS build`)
|
}
|
}
|
|
let source = consumer.sourceContentFor(from.source);
|
if (source) result.source = source;
|
|
return result
|
}
|
|
mapResolve(file) {
|
if (/^\w+:\/\//.test(file)) {
|
return file
|
}
|
return resolve$1(this.map.consumer().sourceRoot || this.map.root || '.', file)
|
}
|
|
get from() {
|
return this.file || this.id
|
}
|
|
toJSON() {
|
let json = {};
|
for (let name of ['hasBOM', 'css', 'file', 'id']) {
|
if (this[name] != null) {
|
json[name] = this[name];
|
}
|
}
|
if (this.map) {
|
json.map = { ...this.map };
|
if (json.map.consumerCache) {
|
json.map.consumerCache = undefined;
|
}
|
}
|
return json
|
}
|
};
|
|
var input = Input$4;
|
Input$4.default = Input$4;
|
|
if (terminalHighlight && terminalHighlight.registerInput) {
|
terminalHighlight.registerInput(Input$4);
|
}
|
|
let { SourceMapConsumer: SourceMapConsumer$2, SourceMapGenerator: SourceMapGenerator$3 } = sourceMap$2;
|
let { dirname, resolve, relative, sep } = require$$2$1;
|
let { pathToFileURL } = require$$2;
|
|
let Input$3 = input;
|
|
let sourceMapAvailable = Boolean(SourceMapConsumer$2 && SourceMapGenerator$3);
|
let pathAvailable = Boolean(dirname && resolve && relative && sep);
|
|
let MapGenerator$2 = class MapGenerator {
|
constructor(stringify, root, opts, cssString) {
|
this.stringify = stringify;
|
this.mapOpts = opts.map || {};
|
this.root = root;
|
this.opts = opts;
|
this.css = cssString;
|
this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
|
}
|
|
isMap() {
|
if (typeof this.opts.map !== 'undefined') {
|
return !!this.opts.map
|
}
|
return this.previous().length > 0
|
}
|
|
previous() {
|
if (!this.previousMaps) {
|
this.previousMaps = [];
|
if (this.root) {
|
this.root.walk(node => {
|
if (node.source && node.source.input.map) {
|
let map = node.source.input.map;
|
if (!this.previousMaps.includes(map)) {
|
this.previousMaps.push(map);
|
}
|
}
|
});
|
} else {
|
let input = new Input$3(this.css, this.opts);
|
if (input.map) this.previousMaps.push(input.map);
|
}
|
}
|
|
return this.previousMaps
|
}
|
|
isInline() {
|
if (typeof this.mapOpts.inline !== 'undefined') {
|
return this.mapOpts.inline
|
}
|
|
let annotation = this.mapOpts.annotation;
|
if (typeof annotation !== 'undefined' && annotation !== true) {
|
return false
|
}
|
|
if (this.previous().length) {
|
return this.previous().some(i => i.inline)
|
}
|
return true
|
}
|
|
isSourcesContent() {
|
if (typeof this.mapOpts.sourcesContent !== 'undefined') {
|
return this.mapOpts.sourcesContent
|
}
|
if (this.previous().length) {
|
return this.previous().some(i => i.withContent())
|
}
|
return true
|
}
|
|
clearAnnotation() {
|
if (this.mapOpts.annotation === false) return
|
|
if (this.root) {
|
let node;
|
for (let i = this.root.nodes.length - 1; i >= 0; i--) {
|
node = this.root.nodes[i];
|
if (node.type !== 'comment') continue
|
if (node.text.indexOf('# sourceMappingURL=') === 0) {
|
this.root.removeChild(i);
|
}
|
}
|
} else if (this.css) {
|
this.css = this.css.replace(/(\n)?\/\*#[\S\s]*?\*\/$/gm, '');
|
}
|
}
|
|
setSourcesContent() {
|
let already = {};
|
if (this.root) {
|
this.root.walk(node => {
|
if (node.source) {
|
let from = node.source.input.from;
|
if (from && !already[from]) {
|
already[from] = true;
|
let fromUrl = this.usesFileUrls
|
? this.toFileUrl(from)
|
: this.toUrl(this.path(from));
|
this.map.setSourceContent(fromUrl, node.source.input.css);
|
}
|
}
|
});
|
} else if (this.css) {
|
let from = this.opts.from
|
? this.toUrl(this.path(this.opts.from))
|
: '<no source>';
|
this.map.setSourceContent(from, this.css);
|
}
|
}
|
|
applyPrevMaps() {
|
for (let prev of this.previous()) {
|
let from = this.toUrl(this.path(prev.file));
|
let root = prev.root || dirname(prev.file);
|
let map;
|
|
if (this.mapOpts.sourcesContent === false) {
|
map = new SourceMapConsumer$2(prev.text);
|
if (map.sourcesContent) {
|
map.sourcesContent = map.sourcesContent.map(() => null);
|
}
|
} else {
|
map = prev.consumer();
|
}
|
|
this.map.applySourceMap(map, from, this.toUrl(this.path(root)));
|
}
|
}
|
|
isAnnotation() {
|
if (this.isInline()) {
|
return true
|
}
|
if (typeof this.mapOpts.annotation !== 'undefined') {
|
return this.mapOpts.annotation
|
}
|
if (this.previous().length) {
|
return this.previous().some(i => i.annotation)
|
}
|
return true
|
}
|
|
toBase64(str) {
|
if (Buffer$1) {
|
return Buffer$1.from(str).toString('base64')
|
} else {
|
return window.btoa(unescape(encodeURIComponent(str)))
|
}
|
}
|
|
addAnnotation() {
|
let content;
|
|
if (this.isInline()) {
|
content =
|
'data:application/json;base64,' + this.toBase64(this.map.toString());
|
} else if (typeof this.mapOpts.annotation === 'string') {
|
content = this.mapOpts.annotation;
|
} else if (typeof this.mapOpts.annotation === 'function') {
|
content = this.mapOpts.annotation(this.opts.to, this.root);
|
} else {
|
content = this.outputFile() + '.map';
|
}
|
let eol = '\n';
|
if (this.css.includes('\r\n')) eol = '\r\n';
|
|
this.css += eol + '/*# sourceMappingURL=' + content + ' */';
|
}
|
|
outputFile() {
|
if (this.opts.to) {
|
return this.path(this.opts.to)
|
} else if (this.opts.from) {
|
return this.path(this.opts.from)
|
} else {
|
return 'to.css'
|
}
|
}
|
|
generateMap() {
|
if (this.root) {
|
this.generateString();
|
} else if (this.previous().length === 1) {
|
let prev = this.previous()[0].consumer();
|
prev.file = this.outputFile();
|
this.map = SourceMapGenerator$3.fromSourceMap(prev);
|
} else {
|
this.map = new SourceMapGenerator$3({ file: this.outputFile() });
|
this.map.addMapping({
|
source: this.opts.from
|
? this.toUrl(this.path(this.opts.from))
|
: '<no source>',
|
generated: { line: 1, column: 0 },
|
original: { line: 1, column: 0 }
|
});
|
}
|
|
if (this.isSourcesContent()) this.setSourcesContent();
|
if (this.root && this.previous().length > 0) this.applyPrevMaps();
|
if (this.isAnnotation()) this.addAnnotation();
|
|
if (this.isInline()) {
|
return [this.css]
|
} else {
|
return [this.css, this.map]
|
}
|
}
|
|
path(file) {
|
if (file.indexOf('<') === 0) return file
|
if (/^\w+:\/\//.test(file)) return file
|
if (this.mapOpts.absolute) return file
|
|
let from = this.opts.to ? dirname(this.opts.to) : '.';
|
|
if (typeof this.mapOpts.annotation === 'string') {
|
from = dirname(resolve(from, this.mapOpts.annotation));
|
}
|
|
file = relative(from, file);
|
return file
|
}
|
|
toUrl(path) {
|
if (sep === '\\') {
|
path = path.replace(/\\/g, '/');
|
}
|
return encodeURI(path).replace(/[#?]/g, encodeURIComponent)
|
}
|
|
toFileUrl(path) {
|
if (pathToFileURL) {
|
return pathToFileURL(path).toString()
|
} else {
|
throw new Error(
|
'`map.absolute` option is not available in this PostCSS build'
|
)
|
}
|
}
|
|
sourcePath(node) {
|
if (this.mapOpts.from) {
|
return this.toUrl(this.mapOpts.from)
|
} else if (this.usesFileUrls) {
|
return this.toFileUrl(node.source.input.from)
|
} else {
|
return this.toUrl(this.path(node.source.input.from))
|
}
|
}
|
|
generateString() {
|
this.css = '';
|
this.map = new SourceMapGenerator$3({ file: this.outputFile() });
|
|
let line = 1;
|
let column = 1;
|
|
let noSource = '<no source>';
|
let mapping = {
|
source: '',
|
generated: { line: 0, column: 0 },
|
original: { line: 0, column: 0 }
|
};
|
|
let lines, last;
|
this.stringify(this.root, (str, node, type) => {
|
this.css += str;
|
|
if (node && type !== 'end') {
|
mapping.generated.line = line;
|
mapping.generated.column = column - 1;
|
if (node.source && node.source.start) {
|
mapping.source = this.sourcePath(node);
|
mapping.original.line = node.source.start.line;
|
mapping.original.column = node.source.start.column - 1;
|
this.map.addMapping(mapping);
|
} else {
|
mapping.source = noSource;
|
mapping.original.line = 1;
|
mapping.original.column = 0;
|
this.map.addMapping(mapping);
|
}
|
}
|
|
lines = str.match(/\n/g);
|
if (lines) {
|
line += lines.length;
|
last = str.lastIndexOf('\n');
|
column = str.length - last;
|
} else {
|
column += str.length;
|
}
|
|
if (node && type !== 'start') {
|
let p = node.parent || { raws: {} };
|
let childless =
|
node.type === 'decl' || (node.type === 'atrule' && !node.nodes);
|
if (!childless || node !== p.last || p.raws.semicolon) {
|
if (node.source && node.source.end) {
|
mapping.source = this.sourcePath(node);
|
mapping.original.line = node.source.end.line;
|
mapping.original.column = node.source.end.column - 1;
|
mapping.generated.line = line;
|
mapping.generated.column = column - 2;
|
this.map.addMapping(mapping);
|
} else {
|
mapping.source = noSource;
|
mapping.original.line = 1;
|
mapping.original.column = 0;
|
mapping.generated.line = line;
|
mapping.generated.column = column - 1;
|
this.map.addMapping(mapping);
|
}
|
}
|
}
|
});
|
}
|
|
generate() {
|
this.clearAnnotation();
|
if (pathAvailable && sourceMapAvailable && this.isMap()) {
|
return this.generateMap()
|
} else {
|
let result = '';
|
this.stringify(this.root, i => {
|
result += i;
|
});
|
return [result]
|
}
|
}
|
};
|
|
var mapGenerator = MapGenerator$2;
|
|
let Node$2 = node$2;
|
|
let Comment$4 = class Comment extends Node$2 {
|
constructor(defaults) {
|
super(defaults);
|
this.type = 'comment';
|
}
|
};
|
|
var comment$3 = Comment$4;
|
Comment$4.default = Comment$4;
|
|
let { isClean: isClean$1, my: my$1 } = symbols;
|
let Declaration$3 = declaration;
|
let Comment$3 = comment$3;
|
let Node$1 = node$2;
|
|
let parse$4, Rule$4, AtRule$4, Root$6;
|
|
function cleanSource(nodes) {
|
return nodes.map(i => {
|
if (i.nodes) i.nodes = cleanSource(i.nodes);
|
delete i.source;
|
return i
|
})
|
}
|
|
function markDirtyUp(node) {
|
node[isClean$1] = false;
|
if (node.proxyOf.nodes) {
|
for (let i of node.proxyOf.nodes) {
|
markDirtyUp(i);
|
}
|
}
|
}
|
|
let Container$7 = class Container extends Node$1 {
|
push(child) {
|
child.parent = this;
|
this.proxyOf.nodes.push(child);
|
return this
|
}
|
|
each(callback) {
|
if (!this.proxyOf.nodes) return undefined
|
let iterator = this.getIterator();
|
|
let index, result;
|
while (this.indexes[iterator] < this.proxyOf.nodes.length) {
|
index = this.indexes[iterator];
|
result = callback(this.proxyOf.nodes[index], index);
|
if (result === false) break
|
|
this.indexes[iterator] += 1;
|
}
|
|
delete this.indexes[iterator];
|
return result
|
}
|
|
walk(callback) {
|
return this.each((child, i) => {
|
let result;
|
try {
|
result = callback(child, i);
|
} catch (e) {
|
throw child.addToError(e)
|
}
|
if (result !== false && child.walk) {
|
result = child.walk(callback);
|
}
|
|
return result
|
})
|
}
|
|
walkDecls(prop, callback) {
|
if (!callback) {
|
callback = prop;
|
return this.walk((child, i) => {
|
if (child.type === 'decl') {
|
return callback(child, i)
|
}
|
})
|
}
|
if (prop instanceof RegExp) {
|
return this.walk((child, i) => {
|
if (child.type === 'decl' && prop.test(child.prop)) {
|
return callback(child, i)
|
}
|
})
|
}
|
return this.walk((child, i) => {
|
if (child.type === 'decl' && child.prop === prop) {
|
return callback(child, i)
|
}
|
})
|
}
|
|
walkRules(selector, callback) {
|
if (!callback) {
|
callback = selector;
|
|
return this.walk((child, i) => {
|
if (child.type === 'rule') {
|
return callback(child, i)
|
}
|
})
|
}
|
if (selector instanceof RegExp) {
|
return this.walk((child, i) => {
|
if (child.type === 'rule' && selector.test(child.selector)) {
|
return callback(child, i)
|
}
|
})
|
}
|
return this.walk((child, i) => {
|
if (child.type === 'rule' && child.selector === selector) {
|
return callback(child, i)
|
}
|
})
|
}
|
|
walkAtRules(name, callback) {
|
if (!callback) {
|
callback = name;
|
return this.walk((child, i) => {
|
if (child.type === 'atrule') {
|
return callback(child, i)
|
}
|
})
|
}
|
if (name instanceof RegExp) {
|
return this.walk((child, i) => {
|
if (child.type === 'atrule' && name.test(child.name)) {
|
return callback(child, i)
|
}
|
})
|
}
|
return this.walk((child, i) => {
|
if (child.type === 'atrule' && child.name === name) {
|
return callback(child, i)
|
}
|
})
|
}
|
|
walkComments(callback) {
|
return this.walk((child, i) => {
|
if (child.type === 'comment') {
|
return callback(child, i)
|
}
|
})
|
}
|
|
append(...children) {
|
for (let child of children) {
|
let nodes = this.normalize(child, this.last);
|
for (let node of nodes) this.proxyOf.nodes.push(node);
|
}
|
|
this.markDirty();
|
|
return this
|
}
|
|
prepend(...children) {
|
children = children.reverse();
|
for (let child of children) {
|
let nodes = this.normalize(child, this.first, 'prepend').reverse();
|
for (let node of nodes) this.proxyOf.nodes.unshift(node);
|
for (let id in this.indexes) {
|
this.indexes[id] = this.indexes[id] + nodes.length;
|
}
|
}
|
|
this.markDirty();
|
|
return this
|
}
|
|
cleanRaws(keepBetween) {
|
super.cleanRaws(keepBetween);
|
if (this.nodes) {
|
for (let node of this.nodes) node.cleanRaws(keepBetween);
|
}
|
}
|
|
insertBefore(exist, add) {
|
let existIndex = this.index(exist);
|
let type = existIndex === 0 ? 'prepend' : false;
|
let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
|
existIndex = this.index(exist);
|
for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
|
|
let index;
|
for (let id in this.indexes) {
|
index = this.indexes[id];
|
if (existIndex <= index) {
|
this.indexes[id] = index + nodes.length;
|
}
|
}
|
|
this.markDirty();
|
|
return this
|
}
|
|
insertAfter(exist, add) {
|
let existIndex = this.index(exist);
|
let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
|
existIndex = this.index(exist);
|
for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node);
|
|
let index;
|
for (let id in this.indexes) {
|
index = this.indexes[id];
|
if (existIndex < index) {
|
this.indexes[id] = index + nodes.length;
|
}
|
}
|
|
this.markDirty();
|
|
return this
|
}
|
|
removeChild(child) {
|
child = this.index(child);
|
this.proxyOf.nodes[child].parent = undefined;
|
this.proxyOf.nodes.splice(child, 1);
|
|
let index;
|
for (let id in this.indexes) {
|
index = this.indexes[id];
|
if (index >= child) {
|
this.indexes[id] = index - 1;
|
}
|
}
|
|
this.markDirty();
|
|
return this
|
}
|
|
removeAll() {
|
for (let node of this.proxyOf.nodes) node.parent = undefined;
|
this.proxyOf.nodes = [];
|
|
this.markDirty();
|
|
return this
|
}
|
|
replaceValues(pattern, opts, callback) {
|
if (!callback) {
|
callback = opts;
|
opts = {};
|
}
|
|
this.walkDecls(decl => {
|
if (opts.props && !opts.props.includes(decl.prop)) return
|
if (opts.fast && !decl.value.includes(opts.fast)) return
|
|
decl.value = decl.value.replace(pattern, callback);
|
});
|
|
this.markDirty();
|
|
return this
|
}
|
|
every(condition) {
|
return this.nodes.every(condition)
|
}
|
|
some(condition) {
|
return this.nodes.some(condition)
|
}
|
|
index(child) {
|
if (typeof child === 'number') return child
|
if (child.proxyOf) child = child.proxyOf;
|
return this.proxyOf.nodes.indexOf(child)
|
}
|
|
get first() {
|
if (!this.proxyOf.nodes) return undefined
|
return this.proxyOf.nodes[0]
|
}
|
|
get last() {
|
if (!this.proxyOf.nodes) return undefined
|
return this.proxyOf.nodes[this.proxyOf.nodes.length - 1]
|
}
|
|
normalize(nodes, sample) {
|
if (typeof nodes === 'string') {
|
nodes = cleanSource(parse$4(nodes).nodes);
|
} else if (Array.isArray(nodes)) {
|
nodes = nodes.slice(0);
|
for (let i of nodes) {
|
if (i.parent) i.parent.removeChild(i, 'ignore');
|
}
|
} else if (nodes.type === 'root' && this.type !== 'document') {
|
nodes = nodes.nodes.slice(0);
|
for (let i of nodes) {
|
if (i.parent) i.parent.removeChild(i, 'ignore');
|
}
|
} else if (nodes.type) {
|
nodes = [nodes];
|
} else if (nodes.prop) {
|
if (typeof nodes.value === 'undefined') {
|
throw new Error('Value field is missed in node creation')
|
} else if (typeof nodes.value !== 'string') {
|
nodes.value = String(nodes.value);
|
}
|
nodes = [new Declaration$3(nodes)];
|
} else if (nodes.selector) {
|
nodes = [new Rule$4(nodes)];
|
} else if (nodes.name) {
|
nodes = [new AtRule$4(nodes)];
|
} else if (nodes.text) {
|
nodes = [new Comment$3(nodes)];
|
} else {
|
throw new Error('Unknown node type in node creation')
|
}
|
|
let processed = nodes.map(i => {
|
/* c8 ignore next */
|
if (!i[my$1]) Container.rebuild(i);
|
i = i.proxyOf;
|
if (i.parent) i.parent.removeChild(i);
|
if (i[isClean$1]) markDirtyUp(i);
|
if (typeof i.raws.before === 'undefined') {
|
if (sample && typeof sample.raws.before !== 'undefined') {
|
i.raws.before = sample.raws.before.replace(/\S/g, '');
|
}
|
}
|
i.parent = this.proxyOf;
|
return i
|
});
|
|
return processed
|
}
|
|
getProxyProcessor() {
|
return {
|
set(node, prop, value) {
|
if (node[prop] === value) return true
|
node[prop] = value;
|
if (prop === 'name' || prop === 'params' || prop === 'selector') {
|
node.markDirty();
|
}
|
return true
|
},
|
|
get(node, prop) {
|
if (prop === 'proxyOf') {
|
return node
|
} else if (!node[prop]) {
|
return node[prop]
|
} else if (
|
prop === 'each' ||
|
(typeof prop === 'string' && prop.startsWith('walk'))
|
) {
|
return (...args) => {
|
return node[prop](
|
...args.map(i => {
|
if (typeof i === 'function') {
|
return (child, index) => i(child.toProxy(), index)
|
} else {
|
return i
|
}
|
})
|
)
|
}
|
} else if (prop === 'every' || prop === 'some') {
|
return cb => {
|
return node[prop]((child, ...other) =>
|
cb(child.toProxy(), ...other)
|
)
|
}
|
} else if (prop === 'root') {
|
return () => node.root().toProxy()
|
} else if (prop === 'nodes') {
|
return node.nodes.map(i => i.toProxy())
|
} else if (prop === 'first' || prop === 'last') {
|
return node[prop].toProxy()
|
} else {
|
return node[prop]
|
}
|
}
|
}
|
}
|
|
getIterator() {
|
if (!this.lastEach) this.lastEach = 0;
|
if (!this.indexes) this.indexes = {};
|
|
this.lastEach += 1;
|
let iterator = this.lastEach;
|
this.indexes[iterator] = 0;
|
|
return iterator
|
}
|
};
|
|
Container$7.registerParse = dependant => {
|
parse$4 = dependant;
|
};
|
|
Container$7.registerRule = dependant => {
|
Rule$4 = dependant;
|
};
|
|
Container$7.registerAtRule = dependant => {
|
AtRule$4 = dependant;
|
};
|
|
Container$7.registerRoot = dependant => {
|
Root$6 = dependant;
|
};
|
|
var container$1 = Container$7;
|
Container$7.default = Container$7;
|
|
/* c8 ignore start */
|
Container$7.rebuild = node => {
|
if (node.type === 'atrule') {
|
Object.setPrototypeOf(node, AtRule$4.prototype);
|
} else if (node.type === 'rule') {
|
Object.setPrototypeOf(node, Rule$4.prototype);
|
} else if (node.type === 'decl') {
|
Object.setPrototypeOf(node, Declaration$3.prototype);
|
} else if (node.type === 'comment') {
|
Object.setPrototypeOf(node, Comment$3.prototype);
|
} else if (node.type === 'root') {
|
Object.setPrototypeOf(node, Root$6.prototype);
|
}
|
|
node[my$1] = true;
|
|
if (node.nodes) {
|
node.nodes.forEach(child => {
|
Container$7.rebuild(child);
|
});
|
}
|
};
|
|
let Container$6 = container$1;
|
|
let LazyResult$4, Processor$3;
|
|
let Document$3 = class Document extends Container$6 {
|
constructor(defaults) {
|
// type needs to be passed to super, otherwise child roots won't be normalized correctly
|
super({ type: 'document', ...defaults });
|
|
if (!this.nodes) {
|
this.nodes = [];
|
}
|
}
|
|
toResult(opts = {}) {
|
let lazy = new LazyResult$4(new Processor$3(), this, opts);
|
|
return lazy.stringify()
|
}
|
};
|
|
Document$3.registerLazyResult = dependant => {
|
LazyResult$4 = dependant;
|
};
|
|
Document$3.registerProcessor = dependant => {
|
Processor$3 = dependant;
|
};
|
|
var document = Document$3;
|
Document$3.default = Document$3;
|
|
/* eslint-disable no-console */
|
|
let printed = {};
|
|
var warnOnce$3 = function warnOnce(message) {
|
if (printed[message]) return
|
printed[message] = true;
|
|
if (typeof console !== 'undefined' && console.warn) {
|
console.warn(message);
|
}
|
};
|
|
let Warning$2 = class Warning {
|
constructor(text, opts = {}) {
|
this.type = 'warning';
|
this.text = text;
|
|
if (opts.node && opts.node.source) {
|
let range = opts.node.rangeBy(opts);
|
this.line = range.start.line;
|
this.column = range.start.column;
|
this.endLine = range.end.line;
|
this.endColumn = range.end.column;
|
}
|
|
for (let opt in opts) this[opt] = opts[opt];
|
}
|
|
toString() {
|
if (this.node) {
|
return this.node.error(this.text, {
|
plugin: this.plugin,
|
index: this.index,
|
word: this.word
|
}).message
|
}
|
|
if (this.plugin) {
|
return this.plugin + ': ' + this.text
|
}
|
|
return this.text
|
}
|
};
|
|
var warning = Warning$2;
|
Warning$2.default = Warning$2;
|
|
let Warning$1 = warning;
|
|
let Result$3 = class Result {
|
constructor(processor, root, opts) {
|
this.processor = processor;
|
this.messages = [];
|
this.root = root;
|
this.opts = opts;
|
this.css = undefined;
|
this.map = undefined;
|
}
|
|
toString() {
|
return this.css
|
}
|
|
warn(text, opts = {}) {
|
if (!opts.plugin) {
|
if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
|
opts.plugin = this.lastPlugin.postcssPlugin;
|
}
|
}
|
|
let warning = new Warning$1(text, opts);
|
this.messages.push(warning);
|
|
return warning
|
}
|
|
warnings() {
|
return this.messages.filter(i => i.type === 'warning')
|
}
|
|
get content() {
|
return this.css
|
}
|
};
|
|
var result = Result$3;
|
Result$3.default = Result$3;
|
|
let Container$5 = container$1;
|
|
let AtRule$3 = class AtRule extends Container$5 {
|
constructor(defaults) {
|
super(defaults);
|
this.type = 'atrule';
|
}
|
|
append(...children) {
|
if (!this.proxyOf.nodes) this.nodes = [];
|
return super.append(...children)
|
}
|
|
prepend(...children) {
|
if (!this.proxyOf.nodes) this.nodes = [];
|
return super.prepend(...children)
|
}
|
};
|
|
var atRule = AtRule$3;
|
AtRule$3.default = AtRule$3;
|
|
Container$5.registerAtRule(AtRule$3);
|
|
let Container$4 = container$1;
|
|
let LazyResult$3, Processor$2;
|
|
let Root$5 = class Root extends Container$4 {
|
constructor(defaults) {
|
super(defaults);
|
this.type = 'root';
|
if (!this.nodes) this.nodes = [];
|
}
|
|
removeChild(child, ignore) {
|
let index = this.index(child);
|
|
if (!ignore && index === 0 && this.nodes.length > 1) {
|
this.nodes[1].raws.before = this.nodes[index].raws.before;
|
}
|
|
return super.removeChild(child)
|
}
|
|
normalize(child, sample, type) {
|
let nodes = super.normalize(child);
|
|
if (sample) {
|
if (type === 'prepend') {
|
if (this.nodes.length > 1) {
|
sample.raws.before = this.nodes[1].raws.before;
|
} else {
|
delete sample.raws.before;
|
}
|
} else if (this.first !== sample) {
|
for (let node of nodes) {
|
node.raws.before = sample.raws.before;
|
}
|
}
|
}
|
|
return nodes
|
}
|
|
toResult(opts = {}) {
|
let lazy = new LazyResult$3(new Processor$2(), this, opts);
|
return lazy.stringify()
|
}
|
};
|
|
Root$5.registerLazyResult = dependant => {
|
LazyResult$3 = dependant;
|
};
|
|
Root$5.registerProcessor = dependant => {
|
Processor$2 = dependant;
|
};
|
|
var root$2 = Root$5;
|
Root$5.default = Root$5;
|
|
Container$4.registerRoot(Root$5);
|
|
let list$2 = {
|
split(string, separators, last) {
|
let array = [];
|
let current = '';
|
let split = false;
|
|
let func = 0;
|
let inQuote = false;
|
let prevQuote = '';
|
let escape = false;
|
|
for (let letter of string) {
|
if (escape) {
|
escape = false;
|
} else if (letter === '\\') {
|
escape = true;
|
} else if (inQuote) {
|
if (letter === prevQuote) {
|
inQuote = false;
|
}
|
} else if (letter === '"' || letter === "'") {
|
inQuote = true;
|
prevQuote = letter;
|
} else if (letter === '(') {
|
func += 1;
|
} else if (letter === ')') {
|
if (func > 0) func -= 1;
|
} else if (func === 0) {
|
if (separators.includes(letter)) split = true;
|
}
|
|
if (split) {
|
if (current !== '') array.push(current.trim());
|
current = '';
|
split = false;
|
} else {
|
current += letter;
|
}
|
}
|
|
if (last || current !== '') array.push(current.trim());
|
return array
|
},
|
|
space(string) {
|
let spaces = [' ', '\n', '\t'];
|
return list$2.split(string, spaces)
|
},
|
|
comma(string) {
|
return list$2.split(string, [','], true)
|
}
|
};
|
|
var list_1 = list$2;
|
list$2.default = list$2;
|
|
let Container$3 = container$1;
|
let list$1 = list_1;
|
|
let Rule$3 = class Rule extends Container$3 {
|
constructor(defaults) {
|
super(defaults);
|
this.type = 'rule';
|
if (!this.nodes) this.nodes = [];
|
}
|
|
get selectors() {
|
return list$1.comma(this.selector)
|
}
|
|
set selectors(values) {
|
let match = this.selector ? this.selector.match(/,\s*/) : null;
|
let sep = match ? match[0] : ',' + this.raw('between', 'beforeOpen');
|
this.selector = values.join(sep);
|
}
|
};
|
|
var rule = Rule$3;
|
Rule$3.default = Rule$3;
|
|
Container$3.registerRule(Rule$3);
|
|
let Declaration$2 = declaration;
|
let tokenizer = tokenize$1;
|
let Comment$2 = comment$3;
|
let AtRule$2 = atRule;
|
let Root$4 = root$2;
|
let Rule$2 = rule;
|
|
const SAFE_COMMENT_NEIGHBOR = {
|
empty: true,
|
space: true
|
};
|
|
function findLastWithPosition(tokens) {
|
for (let i = tokens.length - 1; i >= 0; i--) {
|
let token = tokens[i];
|
let pos = token[3] || token[2];
|
if (pos) return pos
|
}
|
}
|
|
let Parser$1 = class Parser {
|
constructor(input) {
|
this.input = input;
|
|
this.root = new Root$4();
|
this.current = this.root;
|
this.spaces = '';
|
this.semicolon = false;
|
this.customProperty = false;
|
|
this.createTokenizer();
|
this.root.source = { input, start: { offset: 0, line: 1, column: 1 } };
|
}
|
|
createTokenizer() {
|
this.tokenizer = tokenizer(this.input);
|
}
|
|
parse() {
|
let token;
|
while (!this.tokenizer.endOfFile()) {
|
token = this.tokenizer.nextToken();
|
|
switch (token[0]) {
|
case 'space':
|
this.spaces += token[1];
|
break
|
|
case ';':
|
this.freeSemicolon(token);
|
break
|
|
case '}':
|
this.end(token);
|
break
|
|
case 'comment':
|
this.comment(token);
|
break
|
|
case 'at-word':
|
this.atrule(token);
|
break
|
|
case '{':
|
this.emptyRule(token);
|
break
|
|
default:
|
this.other(token);
|
break
|
}
|
}
|
this.endFile();
|
}
|
|
comment(token) {
|
let node = new Comment$2();
|
this.init(node, token[2]);
|
node.source.end = this.getPosition(token[3] || token[2]);
|
|
let text = token[1].slice(2, -2);
|
if (/^\s*$/.test(text)) {
|
node.text = '';
|
node.raws.left = text;
|
node.raws.right = '';
|
} else {
|
let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
|
node.text = match[2];
|
node.raws.left = match[1];
|
node.raws.right = match[3];
|
}
|
}
|
|
emptyRule(token) {
|
let node = new Rule$2();
|
this.init(node, token[2]);
|
node.selector = '';
|
node.raws.between = '';
|
this.current = node;
|
}
|
|
other(start) {
|
let end = false;
|
let type = null;
|
let colon = false;
|
let bracket = null;
|
let brackets = [];
|
let customProperty = start[1].startsWith('--');
|
|
let tokens = [];
|
let token = start;
|
while (token) {
|
type = token[0];
|
tokens.push(token);
|
|
if (type === '(' || type === '[') {
|
if (!bracket) bracket = token;
|
brackets.push(type === '(' ? ')' : ']');
|
} else if (customProperty && colon && type === '{') {
|
if (!bracket) bracket = token;
|
brackets.push('}');
|
} else if (brackets.length === 0) {
|
if (type === ';') {
|
if (colon) {
|
this.decl(tokens, customProperty);
|
return
|
} else {
|
break
|
}
|
} else if (type === '{') {
|
this.rule(tokens);
|
return
|
} else if (type === '}') {
|
this.tokenizer.back(tokens.pop());
|
end = true;
|
break
|
} else if (type === ':') {
|
colon = true;
|
}
|
} else if (type === brackets[brackets.length - 1]) {
|
brackets.pop();
|
if (brackets.length === 0) bracket = null;
|
}
|
|
token = this.tokenizer.nextToken();
|
}
|
|
if (this.tokenizer.endOfFile()) end = true;
|
if (brackets.length > 0) this.unclosedBracket(bracket);
|
|
if (end && colon) {
|
if (!customProperty) {
|
while (tokens.length) {
|
token = tokens[tokens.length - 1][0];
|
if (token !== 'space' && token !== 'comment') break
|
this.tokenizer.back(tokens.pop());
|
}
|
}
|
this.decl(tokens, customProperty);
|
} else {
|
this.unknownWord(tokens);
|
}
|
}
|
|
rule(tokens) {
|
tokens.pop();
|
|
let node = new Rule$2();
|
this.init(node, tokens[0][2]);
|
|
node.raws.between = this.spacesAndCommentsFromEnd(tokens);
|
this.raw(node, 'selector', tokens);
|
this.current = node;
|
}
|
|
decl(tokens, customProperty) {
|
let node = new Declaration$2();
|
this.init(node, tokens[0][2]);
|
|
let last = tokens[tokens.length - 1];
|
if (last[0] === ';') {
|
this.semicolon = true;
|
tokens.pop();
|
}
|
|
node.source.end = this.getPosition(
|
last[3] || last[2] || findLastWithPosition(tokens)
|
);
|
|
while (tokens[0][0] !== 'word') {
|
if (tokens.length === 1) this.unknownWord(tokens);
|
node.raws.before += tokens.shift()[1];
|
}
|
node.source.start = this.getPosition(tokens[0][2]);
|
|
node.prop = '';
|
while (tokens.length) {
|
let type = tokens[0][0];
|
if (type === ':' || type === 'space' || type === 'comment') {
|
break
|
}
|
node.prop += tokens.shift()[1];
|
}
|
|
node.raws.between = '';
|
|
let token;
|
while (tokens.length) {
|
token = tokens.shift();
|
|
if (token[0] === ':') {
|
node.raws.between += token[1];
|
break
|
} else {
|
if (token[0] === 'word' && /\w/.test(token[1])) {
|
this.unknownWord([token]);
|
}
|
node.raws.between += token[1];
|
}
|
}
|
|
if (node.prop[0] === '_' || node.prop[0] === '*') {
|
node.raws.before += node.prop[0];
|
node.prop = node.prop.slice(1);
|
}
|
|
let firstSpaces = [];
|
let next;
|
while (tokens.length) {
|
next = tokens[0][0];
|
if (next !== 'space' && next !== 'comment') break
|
firstSpaces.push(tokens.shift());
|
}
|
|
this.precheckMissedSemicolon(tokens);
|
|
for (let i = tokens.length - 1; i >= 0; i--) {
|
token = tokens[i];
|
if (token[1].toLowerCase() === '!important') {
|
node.important = true;
|
let string = this.stringFrom(tokens, i);
|
string = this.spacesFromEnd(tokens) + string;
|
if (string !== ' !important') node.raws.important = string;
|
break
|
} else if (token[1].toLowerCase() === 'important') {
|
let cache = tokens.slice(0);
|
let str = '';
|
for (let j = i; j > 0; j--) {
|
let type = cache[j][0];
|
if (str.trim().indexOf('!') === 0 && type !== 'space') {
|
break
|
}
|
str = cache.pop()[1] + str;
|
}
|
if (str.trim().indexOf('!') === 0) {
|
node.important = true;
|
node.raws.important = str;
|
tokens = cache;
|
}
|
}
|
|
if (token[0] !== 'space' && token[0] !== 'comment') {
|
break
|
}
|
}
|
|
let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment');
|
|
if (hasWord) {
|
node.raws.between += firstSpaces.map(i => i[1]).join('');
|
firstSpaces = [];
|
}
|
this.raw(node, 'value', firstSpaces.concat(tokens), customProperty);
|
|
if (node.value.includes(':') && !customProperty) {
|
this.checkMissedSemicolon(tokens);
|
}
|
}
|
|
atrule(token) {
|
let node = new AtRule$2();
|
node.name = token[1].slice(1);
|
if (node.name === '') {
|
this.unnamedAtrule(node, token);
|
}
|
this.init(node, token[2]);
|
|
let type;
|
let prev;
|
let shift;
|
let last = false;
|
let open = false;
|
let params = [];
|
let brackets = [];
|
|
while (!this.tokenizer.endOfFile()) {
|
token = this.tokenizer.nextToken();
|
type = token[0];
|
|
if (type === '(' || type === '[') {
|
brackets.push(type === '(' ? ')' : ']');
|
} else if (type === '{' && brackets.length > 0) {
|
brackets.push('}');
|
} else if (type === brackets[brackets.length - 1]) {
|
brackets.pop();
|
}
|
|
if (brackets.length === 0) {
|
if (type === ';') {
|
node.source.end = this.getPosition(token[2]);
|
this.semicolon = true;
|
break
|
} else if (type === '{') {
|
open = true;
|
break
|
} else if (type === '}') {
|
if (params.length > 0) {
|
shift = params.length - 1;
|
prev = params[shift];
|
while (prev && prev[0] === 'space') {
|
prev = params[--shift];
|
}
|
if (prev) {
|
node.source.end = this.getPosition(prev[3] || prev[2]);
|
}
|
}
|
this.end(token);
|
break
|
} else {
|
params.push(token);
|
}
|
} else {
|
params.push(token);
|
}
|
|
if (this.tokenizer.endOfFile()) {
|
last = true;
|
break
|
}
|
}
|
|
node.raws.between = this.spacesAndCommentsFromEnd(params);
|
if (params.length) {
|
node.raws.afterName = this.spacesAndCommentsFromStart(params);
|
this.raw(node, 'params', params);
|
if (last) {
|
token = params[params.length - 1];
|
node.source.end = this.getPosition(token[3] || token[2]);
|
this.spaces = node.raws.between;
|
node.raws.between = '';
|
}
|
} else {
|
node.raws.afterName = '';
|
node.params = '';
|
}
|
|
if (open) {
|
node.nodes = [];
|
this.current = node;
|
}
|
}
|
|
end(token) {
|
if (this.current.nodes && this.current.nodes.length) {
|
this.current.raws.semicolon = this.semicolon;
|
}
|
this.semicolon = false;
|
|
this.current.raws.after = (this.current.raws.after || '') + this.spaces;
|
this.spaces = '';
|
|
if (this.current.parent) {
|
this.current.source.end = this.getPosition(token[2]);
|
this.current = this.current.parent;
|
} else {
|
this.unexpectedClose(token);
|
}
|
}
|
|
endFile() {
|
if (this.current.parent) this.unclosedBlock();
|
if (this.current.nodes && this.current.nodes.length) {
|
this.current.raws.semicolon = this.semicolon;
|
}
|
this.current.raws.after = (this.current.raws.after || '') + this.spaces;
|
}
|
|
freeSemicolon(token) {
|
this.spaces += token[1];
|
if (this.current.nodes) {
|
let prev = this.current.nodes[this.current.nodes.length - 1];
|
if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
|
prev.raws.ownSemicolon = this.spaces;
|
this.spaces = '';
|
}
|
}
|
}
|
|
// Helpers
|
|
getPosition(offset) {
|
let pos = this.input.fromOffset(offset);
|
return {
|
offset,
|
line: pos.line,
|
column: pos.col
|
}
|
}
|
|
init(node, offset) {
|
this.current.push(node);
|
node.source = {
|
start: this.getPosition(offset),
|
input: this.input
|
};
|
node.raws.before = this.spaces;
|
this.spaces = '';
|
if (node.type !== 'comment') this.semicolon = false;
|
}
|
|
raw(node, prop, tokens, customProperty) {
|
let token, type;
|
let length = tokens.length;
|
let value = '';
|
let clean = true;
|
let next, prev;
|
|
for (let i = 0; i < length; i += 1) {
|
token = tokens[i];
|
type = token[0];
|
if (type === 'space' && i === length - 1 && !customProperty) {
|
clean = false;
|
} else if (type === 'comment') {
|
prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty';
|
next = tokens[i + 1] ? tokens[i + 1][0] : 'empty';
|
if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
|
if (value.slice(-1) === ',') {
|
clean = false;
|
} else {
|
value += token[1];
|
}
|
} else {
|
clean = false;
|
}
|
} else {
|
value += token[1];
|
}
|
}
|
if (!clean) {
|
let raw = tokens.reduce((all, i) => all + i[1], '');
|
node.raws[prop] = { value, raw };
|
}
|
node[prop] = value;
|
}
|
|
spacesAndCommentsFromEnd(tokens) {
|
let lastTokenType;
|
let spaces = '';
|
while (tokens.length) {
|
lastTokenType = tokens[tokens.length - 1][0];
|
if (lastTokenType !== 'space' && lastTokenType !== 'comment') break
|
spaces = tokens.pop()[1] + spaces;
|
}
|
return spaces
|
}
|
|
spacesAndCommentsFromStart(tokens) {
|
let next;
|
let spaces = '';
|
while (tokens.length) {
|
next = tokens[0][0];
|
if (next !== 'space' && next !== 'comment') break
|
spaces += tokens.shift()[1];
|
}
|
return spaces
|
}
|
|
spacesFromEnd(tokens) {
|
let lastTokenType;
|
let spaces = '';
|
while (tokens.length) {
|
lastTokenType = tokens[tokens.length - 1][0];
|
if (lastTokenType !== 'space') break
|
spaces = tokens.pop()[1] + spaces;
|
}
|
return spaces
|
}
|
|
stringFrom(tokens, from) {
|
let result = '';
|
for (let i = from; i < tokens.length; i++) {
|
result += tokens[i][1];
|
}
|
tokens.splice(from, tokens.length - from);
|
return result
|
}
|
|
colon(tokens) {
|
let brackets = 0;
|
let token, type, prev;
|
for (let [i, element] of tokens.entries()) {
|
token = element;
|
type = token[0];
|
|
if (type === '(') {
|
brackets += 1;
|
}
|
if (type === ')') {
|
brackets -= 1;
|
}
|
if (brackets === 0 && type === ':') {
|
if (!prev) {
|
this.doubleColon(token);
|
} else if (prev[0] === 'word' && prev[1] === 'progid') {
|
continue
|
} else {
|
return i
|
}
|
}
|
|
prev = token;
|
}
|
return false
|
}
|
|
// Errors
|
|
unclosedBracket(bracket) {
|
throw this.input.error(
|
'Unclosed bracket',
|
{ offset: bracket[2] },
|
{ offset: bracket[2] + 1 }
|
)
|
}
|
|
unknownWord(tokens) {
|
throw this.input.error(
|
'Unknown word',
|
{ offset: tokens[0][2] },
|
{ offset: tokens[0][2] + tokens[0][1].length }
|
)
|
}
|
|
unexpectedClose(token) {
|
throw this.input.error(
|
'Unexpected }',
|
{ offset: token[2] },
|
{ offset: token[2] + 1 }
|
)
|
}
|
|
unclosedBlock() {
|
let pos = this.current.source.start;
|
throw this.input.error('Unclosed block', pos.line, pos.column)
|
}
|
|
doubleColon(token) {
|
throw this.input.error(
|
'Double colon',
|
{ offset: token[2] },
|
{ offset: token[2] + token[1].length }
|
)
|
}
|
|
unnamedAtrule(node, token) {
|
throw this.input.error(
|
'At-rule without name',
|
{ offset: token[2] },
|
{ offset: token[2] + token[1].length }
|
)
|
}
|
|
precheckMissedSemicolon(/* tokens */) {
|
// Hook for Safe Parser
|
}
|
|
checkMissedSemicolon(tokens) {
|
let colon = this.colon(tokens);
|
if (colon === false) return
|
|
let founded = 0;
|
let token;
|
for (let j = colon - 1; j >= 0; j--) {
|
token = tokens[j];
|
if (token[0] !== 'space') {
|
founded += 1;
|
if (founded === 2) break
|
}
|
}
|
// If the token is a word, e.g. `!important`, `red` or any other valid property's value.
|
// Then we need to return the colon after that word token. [3] is the "end" colon of that word.
|
// And because we need it after that one we do +1 to get the next one.
|
throw this.input.error(
|
'Missed semicolon',
|
token[0] === 'word' ? token[3] + 1 : token[2]
|
)
|
}
|
};
|
|
var parser$1 = Parser$1;
|
|
let Container$2 = container$1;
|
let Parser = parser$1;
|
let Input$2 = input;
|
|
function parse$3(css, opts) {
|
let input = new Input$2(css, opts);
|
let parser = new Parser(input);
|
try {
|
parser.parse();
|
} catch (e) {
|
if (browser$1.env.NODE_ENV !== 'production') {
|
if (e.name === 'CssSyntaxError' && opts && opts.from) {
|
if (/\.scss$/i.test(opts.from)) {
|
e.message +=
|
'\nYou tried to parse SCSS with ' +
|
'the standard CSS parser; ' +
|
'try again with the postcss-scss parser';
|
} else if (/\.sass/i.test(opts.from)) {
|
e.message +=
|
'\nYou tried to parse Sass with ' +
|
'the standard CSS parser; ' +
|
'try again with the postcss-sass parser';
|
} else if (/\.less$/i.test(opts.from)) {
|
e.message +=
|
'\nYou tried to parse Less with ' +
|
'the standard CSS parser; ' +
|
'try again with the postcss-less parser';
|
}
|
}
|
}
|
throw e
|
}
|
|
return parser.root
|
}
|
|
var parse_1 = parse$3;
|
parse$3.default = parse$3;
|
|
Container$2.registerParse(parse$3);
|
|
let { isClean, my } = symbols;
|
let MapGenerator$1 = mapGenerator;
|
let stringify$2 = stringify_1;
|
let Container$1 = container$1;
|
let Document$2 = document;
|
let warnOnce$2 = warnOnce$3;
|
let Result$2 = result;
|
let parse$2 = parse_1;
|
let Root$3 = root$2;
|
|
const TYPE_TO_CLASS_NAME = {
|
document: 'Document',
|
root: 'Root',
|
atrule: 'AtRule',
|
rule: 'Rule',
|
decl: 'Declaration',
|
comment: 'Comment'
|
};
|
|
const PLUGIN_PROPS = {
|
postcssPlugin: true,
|
prepare: true,
|
Once: true,
|
Document: true,
|
Root: true,
|
Declaration: true,
|
Rule: true,
|
AtRule: true,
|
Comment: true,
|
DeclarationExit: true,
|
RuleExit: true,
|
AtRuleExit: true,
|
CommentExit: true,
|
RootExit: true,
|
DocumentExit: true,
|
OnceExit: true
|
};
|
|
const NOT_VISITORS = {
|
postcssPlugin: true,
|
prepare: true,
|
Once: true
|
};
|
|
const CHILDREN = 0;
|
|
function isPromise(obj) {
|
return typeof obj === 'object' && typeof obj.then === 'function'
|
}
|
|
function getEvents(node) {
|
let key = false;
|
let type = TYPE_TO_CLASS_NAME[node.type];
|
if (node.type === 'decl') {
|
key = node.prop.toLowerCase();
|
} else if (node.type === 'atrule') {
|
key = node.name.toLowerCase();
|
}
|
|
if (key && node.append) {
|
return [
|
type,
|
type + '-' + key,
|
CHILDREN,
|
type + 'Exit',
|
type + 'Exit-' + key
|
]
|
} else if (key) {
|
return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key]
|
} else if (node.append) {
|
return [type, CHILDREN, type + 'Exit']
|
} else {
|
return [type, type + 'Exit']
|
}
|
}
|
|
function toStack(node) {
|
let events;
|
if (node.type === 'document') {
|
events = ['Document', CHILDREN, 'DocumentExit'];
|
} else if (node.type === 'root') {
|
events = ['Root', CHILDREN, 'RootExit'];
|
} else {
|
events = getEvents(node);
|
}
|
|
return {
|
node,
|
events,
|
eventIndex: 0,
|
visitors: [],
|
visitorIndex: 0,
|
iterator: 0
|
}
|
}
|
|
function cleanMarks(node) {
|
node[isClean] = false;
|
if (node.nodes) node.nodes.forEach(i => cleanMarks(i));
|
return node
|
}
|
|
let postcss$2 = {};
|
|
let LazyResult$2 = class LazyResult {
|
constructor(processor, css, opts) {
|
this.stringified = false;
|
this.processed = false;
|
|
let root;
|
if (
|
typeof css === 'object' &&
|
css !== null &&
|
(css.type === 'root' || css.type === 'document')
|
) {
|
root = cleanMarks(css);
|
} else if (css instanceof LazyResult || css instanceof Result$2) {
|
root = cleanMarks(css.root);
|
if (css.map) {
|
if (typeof opts.map === 'undefined') opts.map = {};
|
if (!opts.map.inline) opts.map.inline = false;
|
opts.map.prev = css.map;
|
}
|
} else {
|
let parser = parse$2;
|
if (opts.syntax) parser = opts.syntax.parse;
|
if (opts.parser) parser = opts.parser;
|
if (parser.parse) parser = parser.parse;
|
|
try {
|
root = parser(css, opts);
|
} catch (error) {
|
this.processed = true;
|
this.error = error;
|
}
|
|
if (root && !root[my]) {
|
/* c8 ignore next 2 */
|
Container$1.rebuild(root);
|
}
|
}
|
|
this.result = new Result$2(processor, root, opts);
|
this.helpers = { ...postcss$2, result: this.result, postcss: postcss$2 };
|
this.plugins = this.processor.plugins.map(plugin => {
|
if (typeof plugin === 'object' && plugin.prepare) {
|
return { ...plugin, ...plugin.prepare(this.result) }
|
} else {
|
return plugin
|
}
|
});
|
}
|
|
get [Symbol.toStringTag]() {
|
return 'LazyResult'
|
}
|
|
get processor() {
|
return this.result.processor
|
}
|
|
get opts() {
|
return this.result.opts
|
}
|
|
get css() {
|
return this.stringify().css
|
}
|
|
get content() {
|
return this.stringify().content
|
}
|
|
get map() {
|
return this.stringify().map
|
}
|
|
get root() {
|
return this.sync().root
|
}
|
|
get messages() {
|
return this.sync().messages
|
}
|
|
warnings() {
|
return this.sync().warnings()
|
}
|
|
toString() {
|
return this.css
|
}
|
|
then(onFulfilled, onRejected) {
|
if (browser$1.env.NODE_ENV !== 'production') {
|
if (!('from' in this.opts)) {
|
warnOnce$2(
|
'Without `from` option PostCSS could generate wrong source map ' +
|
'and will not find Browserslist config. Set it to CSS file path ' +
|
'or to `undefined` to prevent this warning.'
|
);
|
}
|
}
|
return this.async().then(onFulfilled, onRejected)
|
}
|
|
catch(onRejected) {
|
return this.async().catch(onRejected)
|
}
|
|
finally(onFinally) {
|
return this.async().then(onFinally, onFinally)
|
}
|
|
async() {
|
if (this.error) return Promise.reject(this.error)
|
if (this.processed) return Promise.resolve(this.result)
|
if (!this.processing) {
|
this.processing = this.runAsync();
|
}
|
return this.processing
|
}
|
|
sync() {
|
if (this.error) throw this.error
|
if (this.processed) return this.result
|
this.processed = true;
|
|
if (this.processing) {
|
throw this.getAsyncError()
|
}
|
|
for (let plugin of this.plugins) {
|
let promise = this.runOnRoot(plugin);
|
if (isPromise(promise)) {
|
throw this.getAsyncError()
|
}
|
}
|
|
this.prepareVisitors();
|
if (this.hasListener) {
|
let root = this.result.root;
|
while (!root[isClean]) {
|
root[isClean] = true;
|
this.walkSync(root);
|
}
|
if (this.listeners.OnceExit) {
|
if (root.type === 'document') {
|
for (let subRoot of root.nodes) {
|
this.visitSync(this.listeners.OnceExit, subRoot);
|
}
|
} else {
|
this.visitSync(this.listeners.OnceExit, root);
|
}
|
}
|
}
|
|
return this.result
|
}
|
|
stringify() {
|
if (this.error) throw this.error
|
if (this.stringified) return this.result
|
this.stringified = true;
|
|
this.sync();
|
|
let opts = this.result.opts;
|
let str = stringify$2;
|
if (opts.syntax) str = opts.syntax.stringify;
|
if (opts.stringifier) str = opts.stringifier;
|
if (str.stringify) str = str.stringify;
|
|
let map = new MapGenerator$1(str, this.result.root, this.result.opts);
|
let data = map.generate();
|
this.result.css = data[0];
|
this.result.map = data[1];
|
|
return this.result
|
}
|
|
walkSync(node) {
|
node[isClean] = true;
|
let events = getEvents(node);
|
for (let event of events) {
|
if (event === CHILDREN) {
|
if (node.nodes) {
|
node.each(child => {
|
if (!child[isClean]) this.walkSync(child);
|
});
|
}
|
} else {
|
let visitors = this.listeners[event];
|
if (visitors) {
|
if (this.visitSync(visitors, node.toProxy())) return
|
}
|
}
|
}
|
}
|
|
visitSync(visitors, node) {
|
for (let [plugin, visitor] of visitors) {
|
this.result.lastPlugin = plugin;
|
let promise;
|
try {
|
promise = visitor(node, this.helpers);
|
} catch (e) {
|
throw this.handleError(e, node.proxyOf)
|
}
|
if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
|
return true
|
}
|
if (isPromise(promise)) {
|
throw this.getAsyncError()
|
}
|
}
|
}
|
|
runOnRoot(plugin) {
|
this.result.lastPlugin = plugin;
|
try {
|
if (typeof plugin === 'object' && plugin.Once) {
|
if (this.result.root.type === 'document') {
|
let roots = this.result.root.nodes.map(root =>
|
plugin.Once(root, this.helpers)
|
);
|
|
if (isPromise(roots[0])) {
|
return Promise.all(roots)
|
}
|
|
return roots
|
}
|
|
return plugin.Once(this.result.root, this.helpers)
|
} else if (typeof plugin === 'function') {
|
return plugin(this.result.root, this.result)
|
}
|
} catch (error) {
|
throw this.handleError(error)
|
}
|
}
|
|
getAsyncError() {
|
throw new Error('Use process(css).then(cb) to work with async plugins')
|
}
|
|
handleError(error, node) {
|
let plugin = this.result.lastPlugin;
|
try {
|
if (node) node.addToError(error);
|
this.error = error;
|
if (error.name === 'CssSyntaxError' && !error.plugin) {
|
error.plugin = plugin.postcssPlugin;
|
error.setMessage();
|
} else if (plugin.postcssVersion) {
|
if (browser$1.env.NODE_ENV !== 'production') {
|
let pluginName = plugin.postcssPlugin;
|
let pluginVer = plugin.postcssVersion;
|
let runtimeVer = this.result.processor.version;
|
let a = pluginVer.split('.');
|
let b = runtimeVer.split('.');
|
|
if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
|
// eslint-disable-next-line no-console
|
console.error(
|
'Unknown error from PostCSS plugin. Your current PostCSS ' +
|
'version is ' +
|
runtimeVer +
|
', but ' +
|
pluginName +
|
' uses ' +
|
pluginVer +
|
'. Perhaps this is the source of the error below.'
|
);
|
}
|
}
|
}
|
} catch (err) {
|
/* c8 ignore next 3 */
|
// eslint-disable-next-line no-console
|
if (console && console.error) console.error(err);
|
}
|
return error
|
}
|
|
async runAsync() {
|
this.plugin = 0;
|
for (let i = 0; i < this.plugins.length; i++) {
|
let plugin = this.plugins[i];
|
let promise = this.runOnRoot(plugin);
|
if (isPromise(promise)) {
|
try {
|
await promise;
|
} catch (error) {
|
throw this.handleError(error)
|
}
|
}
|
}
|
|
this.prepareVisitors();
|
if (this.hasListener) {
|
let root = this.result.root;
|
while (!root[isClean]) {
|
root[isClean] = true;
|
let stack = [toStack(root)];
|
while (stack.length > 0) {
|
let promise = this.visitTick(stack);
|
if (isPromise(promise)) {
|
try {
|
await promise;
|
} catch (e) {
|
let node = stack[stack.length - 1].node;
|
throw this.handleError(e, node)
|
}
|
}
|
}
|
}
|
|
if (this.listeners.OnceExit) {
|
for (let [plugin, visitor] of this.listeners.OnceExit) {
|
this.result.lastPlugin = plugin;
|
try {
|
if (root.type === 'document') {
|
let roots = root.nodes.map(subRoot =>
|
visitor(subRoot, this.helpers)
|
);
|
|
await Promise.all(roots);
|
} else {
|
await visitor(root, this.helpers);
|
}
|
} catch (e) {
|
throw this.handleError(e)
|
}
|
}
|
}
|
}
|
|
this.processed = true;
|
return this.stringify()
|
}
|
|
prepareVisitors() {
|
this.listeners = {};
|
let add = (plugin, type, cb) => {
|
if (!this.listeners[type]) this.listeners[type] = [];
|
this.listeners[type].push([plugin, cb]);
|
};
|
for (let plugin of this.plugins) {
|
if (typeof plugin === 'object') {
|
for (let event in plugin) {
|
if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
|
throw new Error(
|
`Unknown event ${event} in ${plugin.postcssPlugin}. ` +
|
`Try to update PostCSS (${this.processor.version} now).`
|
)
|
}
|
if (!NOT_VISITORS[event]) {
|
if (typeof plugin[event] === 'object') {
|
for (let filter in plugin[event]) {
|
if (filter === '*') {
|
add(plugin, event, plugin[event][filter]);
|
} else {
|
add(
|
plugin,
|
event + '-' + filter.toLowerCase(),
|
plugin[event][filter]
|
);
|
}
|
}
|
} else if (typeof plugin[event] === 'function') {
|
add(plugin, event, plugin[event]);
|
}
|
}
|
}
|
}
|
}
|
this.hasListener = Object.keys(this.listeners).length > 0;
|
}
|
|
visitTick(stack) {
|
let visit = stack[stack.length - 1];
|
let { node, visitors } = visit;
|
|
if (node.type !== 'root' && node.type !== 'document' && !node.parent) {
|
stack.pop();
|
return
|
}
|
|
if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
|
let [plugin, visitor] = visitors[visit.visitorIndex];
|
visit.visitorIndex += 1;
|
if (visit.visitorIndex === visitors.length) {
|
visit.visitors = [];
|
visit.visitorIndex = 0;
|
}
|
this.result.lastPlugin = plugin;
|
try {
|
return visitor(node.toProxy(), this.helpers)
|
} catch (e) {
|
throw this.handleError(e, node)
|
}
|
}
|
|
if (visit.iterator !== 0) {
|
let iterator = visit.iterator;
|
let child;
|
while ((child = node.nodes[node.indexes[iterator]])) {
|
node.indexes[iterator] += 1;
|
if (!child[isClean]) {
|
child[isClean] = true;
|
stack.push(toStack(child));
|
return
|
}
|
}
|
visit.iterator = 0;
|
delete node.indexes[iterator];
|
}
|
|
let events = visit.events;
|
while (visit.eventIndex < events.length) {
|
let event = events[visit.eventIndex];
|
visit.eventIndex += 1;
|
if (event === CHILDREN) {
|
if (node.nodes && node.nodes.length) {
|
node[isClean] = true;
|
visit.iterator = node.getIterator();
|
}
|
return
|
} else if (this.listeners[event]) {
|
visit.visitors = this.listeners[event];
|
return
|
}
|
}
|
stack.pop();
|
}
|
};
|
|
LazyResult$2.registerPostcss = dependant => {
|
postcss$2 = dependant;
|
};
|
|
var lazyResult = LazyResult$2;
|
LazyResult$2.default = LazyResult$2;
|
|
Root$3.registerLazyResult(LazyResult$2);
|
Document$2.registerLazyResult(LazyResult$2);
|
|
let MapGenerator = mapGenerator;
|
let stringify$1 = stringify_1;
|
let warnOnce$1 = warnOnce$3;
|
let parse$1 = parse_1;
|
const Result$1 = result;
|
|
let NoWorkResult$1 = class NoWorkResult {
|
constructor(processor, css, opts) {
|
css = css.toString();
|
this.stringified = false;
|
|
this._processor = processor;
|
this._css = css;
|
this._opts = opts;
|
this._map = undefined;
|
let root;
|
|
let str = stringify$1;
|
this.result = new Result$1(this._processor, root, this._opts);
|
this.result.css = css;
|
|
let self = this;
|
Object.defineProperty(this.result, 'root', {
|
get() {
|
return self.root
|
}
|
});
|
|
let map = new MapGenerator(str, root, this._opts, css);
|
if (map.isMap()) {
|
let [generatedCSS, generatedMap] = map.generate();
|
if (generatedCSS) {
|
this.result.css = generatedCSS;
|
}
|
if (generatedMap) {
|
this.result.map = generatedMap;
|
}
|
}
|
}
|
|
get [Symbol.toStringTag]() {
|
return 'NoWorkResult'
|
}
|
|
get processor() {
|
return this.result.processor
|
}
|
|
get opts() {
|
return this.result.opts
|
}
|
|
get css() {
|
return this.result.css
|
}
|
|
get content() {
|
return this.result.css
|
}
|
|
get map() {
|
return this.result.map
|
}
|
|
get root() {
|
if (this._root) {
|
return this._root
|
}
|
|
let root;
|
let parser = parse$1;
|
|
try {
|
root = parser(this._css, this._opts);
|
} catch (error) {
|
this.error = error;
|
}
|
|
if (this.error) {
|
throw this.error
|
} else {
|
this._root = root;
|
return root
|
}
|
}
|
|
get messages() {
|
return []
|
}
|
|
warnings() {
|
return []
|
}
|
|
toString() {
|
return this._css
|
}
|
|
then(onFulfilled, onRejected) {
|
if (browser$1.env.NODE_ENV !== 'production') {
|
if (!('from' in this._opts)) {
|
warnOnce$1(
|
'Without `from` option PostCSS could generate wrong source map ' +
|
'and will not find Browserslist config. Set it to CSS file path ' +
|
'or to `undefined` to prevent this warning.'
|
);
|
}
|
}
|
|
return this.async().then(onFulfilled, onRejected)
|
}
|
|
catch(onRejected) {
|
return this.async().catch(onRejected)
|
}
|
|
finally(onFinally) {
|
return this.async().then(onFinally, onFinally)
|
}
|
|
async() {
|
if (this.error) return Promise.reject(this.error)
|
return Promise.resolve(this.result)
|
}
|
|
sync() {
|
if (this.error) throw this.error
|
return this.result
|
}
|
};
|
|
var noWorkResult = NoWorkResult$1;
|
NoWorkResult$1.default = NoWorkResult$1;
|
|
let NoWorkResult = noWorkResult;
|
let LazyResult$1 = lazyResult;
|
let Document$1 = document;
|
let Root$2 = root$2;
|
|
let Processor$1 = class Processor {
|
constructor(plugins = []) {
|
this.version = '8.4.21';
|
this.plugins = this.normalize(plugins);
|
}
|
|
use(plugin) {
|
this.plugins = this.plugins.concat(this.normalize([plugin]));
|
return this
|
}
|
|
process(css, opts = {}) {
|
if (
|
this.plugins.length === 0 &&
|
typeof opts.parser === 'undefined' &&
|
typeof opts.stringifier === 'undefined' &&
|
typeof opts.syntax === 'undefined'
|
) {
|
return new NoWorkResult(this, css, opts)
|
} else {
|
return new LazyResult$1(this, css, opts)
|
}
|
}
|
|
normalize(plugins) {
|
let normalized = [];
|
for (let i of plugins) {
|
if (i.postcss === true) {
|
i = i();
|
} else if (i.postcss) {
|
i = i.postcss;
|
}
|
|
if (typeof i === 'object' && Array.isArray(i.plugins)) {
|
normalized = normalized.concat(i.plugins);
|
} else if (typeof i === 'object' && i.postcssPlugin) {
|
normalized.push(i);
|
} else if (typeof i === 'function') {
|
normalized.push(i);
|
} else if (typeof i === 'object' && (i.parse || i.stringify)) {
|
if (browser$1.env.NODE_ENV !== 'production') {
|
throw new Error(
|
'PostCSS syntaxes cannot be used as plugins. Instead, please use ' +
|
'one of the syntax/parser/stringifier options as outlined ' +
|
'in your PostCSS runner documentation.'
|
)
|
}
|
} else {
|
throw new Error(i + ' is not a PostCSS plugin')
|
}
|
}
|
return normalized
|
}
|
};
|
|
var processor$1 = Processor$1;
|
Processor$1.default = Processor$1;
|
|
Root$2.registerProcessor(Processor$1);
|
Document$1.registerProcessor(Processor$1);
|
|
let Declaration$1 = declaration;
|
let PreviousMap = previousMap;
|
let Comment$1 = comment$3;
|
let AtRule$1 = atRule;
|
let Input$1 = input;
|
let Root$1 = root$2;
|
let Rule$1 = rule;
|
|
function fromJSON$1(json, inputs) {
|
if (Array.isArray(json)) return json.map(n => fromJSON$1(n))
|
|
let { inputs: ownInputs, ...defaults } = json;
|
if (ownInputs) {
|
inputs = [];
|
for (let input of ownInputs) {
|
let inputHydrated = { ...input, __proto__: Input$1.prototype };
|
if (inputHydrated.map) {
|
inputHydrated.map = {
|
...inputHydrated.map,
|
__proto__: PreviousMap.prototype
|
};
|
}
|
inputs.push(inputHydrated);
|
}
|
}
|
if (defaults.nodes) {
|
defaults.nodes = json.nodes.map(n => fromJSON$1(n, inputs));
|
}
|
if (defaults.source) {
|
let { inputId, ...source } = defaults.source;
|
defaults.source = source;
|
if (inputId != null) {
|
defaults.source.input = inputs[inputId];
|
}
|
}
|
if (defaults.type === 'root') {
|
return new Root$1(defaults)
|
} else if (defaults.type === 'decl') {
|
return new Declaration$1(defaults)
|
} else if (defaults.type === 'rule') {
|
return new Rule$1(defaults)
|
} else if (defaults.type === 'comment') {
|
return new Comment$1(defaults)
|
} else if (defaults.type === 'atrule') {
|
return new AtRule$1(defaults)
|
} else {
|
throw new Error('Unknown node type: ' + json.type)
|
}
|
}
|
|
var fromJSON_1 = fromJSON$1;
|
fromJSON$1.default = fromJSON$1;
|
|
let CssSyntaxError = cssSyntaxError;
|
let Declaration = declaration;
|
let LazyResult = lazyResult;
|
let Container = container$1;
|
let Processor = processor$1;
|
let stringify = stringify_1;
|
let fromJSON = fromJSON_1;
|
let Document = document;
|
let Warning = warning;
|
let Comment = comment$3;
|
let AtRule = atRule;
|
let Result = result;
|
let Input = input;
|
let parse = parse_1;
|
let list = list_1;
|
let Rule = rule;
|
let Root = root$2;
|
let Node = node$2;
|
|
function postcss(...plugins) {
|
if (plugins.length === 1 && Array.isArray(plugins[0])) {
|
plugins = plugins[0];
|
}
|
return new Processor(plugins)
|
}
|
|
postcss.plugin = function plugin(name, initializer) {
|
let warningPrinted = false;
|
function creator(...args) {
|
// eslint-disable-next-line no-console
|
if (console && console.warn && !warningPrinted) {
|
warningPrinted = true;
|
// eslint-disable-next-line no-console
|
console.warn(
|
name +
|
': postcss.plugin was deprecated. Migration guide:\n' +
|
'https://evilmartians.com/chronicles/postcss-8-plugin-migration'
|
);
|
if (browser$1.env.LANG && browser$1.env.LANG.startsWith('cn')) {
|
/* c8 ignore next 7 */
|
// eslint-disable-next-line no-console
|
console.warn(
|
name +
|
': 里面 postcss.plugin 被弃用. 迁移指南:\n' +
|
'https://www.w3ctech.com/topic/2226'
|
);
|
}
|
}
|
let transformer = initializer(...args);
|
transformer.postcssPlugin = name;
|
transformer.postcssVersion = new Processor().version;
|
return transformer
|
}
|
|
let cache;
|
Object.defineProperty(creator, 'postcss', {
|
get() {
|
if (!cache) cache = creator();
|
return cache
|
}
|
});
|
|
creator.process = function (css, processOpts, pluginOpts) {
|
return postcss([creator(pluginOpts)]).process(css, processOpts)
|
};
|
|
return creator
|
};
|
|
postcss.stringify = stringify;
|
postcss.parse = parse;
|
postcss.fromJSON = fromJSON;
|
postcss.list = list;
|
|
postcss.comment = defaults => new Comment(defaults);
|
postcss.atRule = defaults => new AtRule(defaults);
|
postcss.decl = defaults => new Declaration(defaults);
|
postcss.rule = defaults => new Rule(defaults);
|
postcss.root = defaults => new Root(defaults);
|
postcss.document = defaults => new Document(defaults);
|
|
postcss.CssSyntaxError = CssSyntaxError;
|
postcss.Declaration = Declaration;
|
postcss.Container = Container;
|
postcss.Processor = Processor;
|
postcss.Document = Document;
|
postcss.Comment = Comment;
|
postcss.Warning = Warning;
|
postcss.AtRule = AtRule;
|
postcss.Result = Result;
|
postcss.Input = Input;
|
postcss.Rule = Rule;
|
postcss.Root = Root;
|
postcss.Node = Node;
|
|
LazyResult.registerPostcss(postcss);
|
|
var postcss_1 = postcss;
|
postcss.default = postcss;
|
|
var postcss$1 = postcss_1;
|
|
postcss$1.stringify;
|
postcss$1.fromJSON;
|
postcss$1.plugin;
|
postcss$1.parse;
|
postcss$1.list;
|
|
postcss$1.document;
|
postcss$1.comment;
|
postcss$1.atRule;
|
postcss$1.rule;
|
postcss$1.decl;
|
postcss$1.root;
|
|
postcss$1.CssSyntaxError;
|
postcss$1.Declaration;
|
postcss$1.Container;
|
postcss$1.Processor;
|
postcss$1.Document;
|
postcss$1.Comment;
|
postcss$1.Warning;
|
postcss$1.AtRule;
|
postcss$1.Result;
|
postcss$1.Input;
|
postcss$1.Rule;
|
postcss$1.Root;
|
postcss$1.Node;
|
|
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 trimPlugin$1 = trimPlugin;
|
|
var distExports = {};
|
var dist = {
|
get exports(){ return distExports; },
|
set exports(v){ distExports = v; },
|
};
|
|
var processorExports = {};
|
var processor = {
|
get exports(){ return processorExports; },
|
set exports(v){ processorExports = v; },
|
};
|
|
var parserExports = {};
|
var parser = {
|
get exports(){ return parserExports; },
|
set exports(v){ parserExports = v; },
|
};
|
|
var rootExports = {};
|
var root$1 = {
|
get exports(){ return rootExports; },
|
set exports(v){ rootExports = v; },
|
};
|
|
var containerExports = {};
|
var container = {
|
get exports(){ return containerExports; },
|
set exports(v){ containerExports = v; },
|
};
|
|
var nodeExports = {};
|
var node$1 = {
|
get exports(){ return nodeExports; },
|
set exports(v){ nodeExports = v; },
|
};
|
|
var util$6 = {};
|
|
var unescExports = {};
|
var unesc = {
|
get exports(){ return unescExports; },
|
set exports(v){ unescExports = v; },
|
};
|
|
(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, unescExports));
|
|
var getPropExports = {};
|
var getProp = {
|
get exports(){ return getPropExports; },
|
set exports(v){ getPropExports = v; },
|
};
|
|
(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, getPropExports));
|
|
var ensureObjectExports = {};
|
var ensureObject = {
|
get exports(){ return ensureObjectExports; },
|
set exports(v){ ensureObjectExports = v; },
|
};
|
|
(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, ensureObjectExports));
|
|
var stripCommentsExports = {};
|
var stripComments = {
|
get exports(){ return stripCommentsExports; },
|
set exports(v){ stripCommentsExports = v; },
|
};
|
|
(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, stripCommentsExports));
|
|
util$6.__esModule = true;
|
util$6.stripComments = util$6.ensureObject = util$6.getProp = util$6.unesc = void 0;
|
|
var _unesc = _interopRequireDefault$1(unescExports);
|
|
util$6.unesc = _unesc["default"];
|
|
var _getProp = _interopRequireDefault$1(getPropExports);
|
|
util$6.getProp = _getProp["default"];
|
|
var _ensureObject = _interopRequireDefault$1(ensureObjectExports);
|
|
util$6.ensureObject = _ensureObject["default"];
|
|
var _stripComments = _interopRequireDefault$1(stripCommentsExports);
|
|
util$6.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$6;
|
|
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, nodeExports));
|
|
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(nodeExports);
|
|
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, containerExports));
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _container = _interopRequireDefault(containerExports);
|
|
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, rootExports));
|
|
var selectorExports = {};
|
var selector$1 = {
|
get exports(){ return selectorExports; },
|
set exports(v){ selectorExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _container = _interopRequireDefault(containerExports);
|
|
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, selectorExports));
|
|
var classNameExports = {};
|
var className$1 = {
|
get exports(){ return classNameExports; },
|
set exports(v){ classNameExports = v; },
|
};
|
|
/*! https://mths.be/cssesc v3.0.0 by @mathias */
|
|
var object = {};
|
var hasOwnProperty = object.hasOwnProperty;
|
var merge$2 = 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$2(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$6;
|
|
var _node = _interopRequireDefault(nodeExports);
|
|
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, classNameExports));
|
|
var commentExports = {};
|
var comment$2 = {
|
get exports(){ return commentExports; },
|
set exports(v){ commentExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _node = _interopRequireDefault(nodeExports);
|
|
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, commentExports));
|
|
var idExports = {};
|
var id$1 = {
|
get exports(){ return idExports; },
|
set exports(v){ idExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _node = _interopRequireDefault(nodeExports);
|
|
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, idExports));
|
|
var tagExports = {};
|
var tag$1 = {
|
get exports(){ return tagExports; },
|
set exports(v){ tagExports = v; },
|
};
|
|
var namespaceExports = {};
|
var namespace = {
|
get exports(){ return namespaceExports; },
|
set exports(v){ namespaceExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _cssesc = _interopRequireDefault(cssesc_1);
|
|
var _util = util$6;
|
|
var _node = _interopRequireDefault(nodeExports);
|
|
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, namespaceExports));
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _namespace = _interopRequireDefault(namespaceExports);
|
|
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, tagExports));
|
|
var stringExports = {};
|
var string$1 = {
|
get exports(){ return stringExports; },
|
set exports(v){ stringExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _node = _interopRequireDefault(nodeExports);
|
|
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, stringExports));
|
|
var pseudoExports = {};
|
var pseudo$1 = {
|
get exports(){ return pseudoExports; },
|
set exports(v){ pseudoExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _container = _interopRequireDefault(containerExports);
|
|
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, pseudoExports));
|
|
var attribute$1 = {};
|
|
/**
|
* For Node.js, simply re-export the core `util.deprecate` function.
|
*/
|
|
var node = require$$0$1.deprecate;
|
|
(function (exports) {
|
|
exports.__esModule = true;
|
exports.unescapeValue = unescapeValue;
|
exports["default"] = void 0;
|
|
var _cssesc = _interopRequireDefault(cssesc_1);
|
|
var _unesc = _interopRequireDefault(unescExports);
|
|
var _namespace = _interopRequireDefault(namespaceExports);
|
|
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;
|
},
|
set:
|
/**
|
* 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.
|
*/
|
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: "insensitive",
|
get: function get() {
|
return this._insensitive;
|
}
|
/**
|
* Set the case insensitive flag.
|
* If the case insensitive flag changes, the raw (escaped) value at `attr.raws.insensitiveFlag`
|
* of the attribute is updated accordingly.
|
*
|
* @param {true | false} insensitive true if the attribute should match case-insensitively.
|
*/
|
,
|
set: function set(insensitive) {
|
if (!insensitive) {
|
this._insensitive = false; // "i" and "I" can be used in "this.raws.insensitiveFlag" to store the original notation.
|
// When setting `attr.insensitive = false` both should be erased to ensure correct serialization.
|
|
if (this.raws && (this.raws.insensitiveFlag === 'I' || this.raws.insensitiveFlag === 'i')) {
|
this.raws.insensitiveFlag = undefined;
|
}
|
}
|
|
this._insensitive = insensitive;
|
}
|
}, {
|
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 universalExports = {};
|
var universal$1 = {
|
get exports(){ return universalExports; },
|
set exports(v){ universalExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _namespace = _interopRequireDefault(namespaceExports);
|
|
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, universalExports));
|
|
var combinatorExports = {};
|
var combinator$2 = {
|
get exports(){ return combinatorExports; },
|
set exports(v){ combinatorExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _node = _interopRequireDefault(nodeExports);
|
|
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, combinatorExports));
|
|
var nestingExports = {};
|
var nesting$1 = {
|
get exports(){ return nestingExports; },
|
set exports(v){ nestingExports = v; },
|
};
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _node = _interopRequireDefault(nodeExports);
|
|
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, nestingExports));
|
|
var sortAscendingExports = {};
|
var sortAscending = {
|
get exports(){ return sortAscendingExports; },
|
set exports(v){ sortAscendingExports = v; },
|
};
|
|
(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, sortAscendingExports));
|
|
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$1 = 44; // `,`.charCodeAt(0);
|
|
tokenTypes.comma = comma$1;
|
var colon = 58; // `:`.charCodeAt(0);
|
|
tokenTypes.colon = colon;
|
var semicolon$1 = 59; // `;`.charCodeAt(0);
|
|
tokenTypes.semicolon = semicolon$1;
|
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(rootExports);
|
|
var _selector = _interopRequireDefault(selectorExports);
|
|
var _className = _interopRequireDefault(classNameExports);
|
|
var _comment = _interopRequireDefault(commentExports);
|
|
var _id = _interopRequireDefault(idExports);
|
|
var _tag = _interopRequireDefault(tagExports);
|
|
var _string = _interopRequireDefault(stringExports);
|
|
var _pseudo = _interopRequireDefault(pseudoExports);
|
|
var _attribute = _interopRequireWildcard(attribute$1);
|
|
var _universal = _interopRequireDefault(universalExports);
|
|
var _combinator = _interopRequireDefault(combinatorExports);
|
|
var _nesting = _interopRequireDefault(nestingExports);
|
|
var _sortAscending = _interopRequireDefault(sortAscendingExports);
|
|
var _tokenize = _interopRequireWildcard(tokenize);
|
|
var tokens = _interopRequireWildcard(tokenTypes);
|
|
var types$1 = _interopRequireWildcard(types);
|
|
var _util = util$6;
|
|
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 || node.quoteMark)) {
|
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, parserExports));
|
|
(function (module, exports) {
|
|
exports.__esModule = true;
|
exports["default"] = void 0;
|
|
var _parser = _interopRequireDefault(parserExports);
|
|
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, processorExports));
|
|
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(classNameExports);
|
|
var _combinator = _interopRequireDefault(combinatorExports);
|
|
var _comment = _interopRequireDefault(commentExports);
|
|
var _id = _interopRequireDefault(idExports);
|
|
var _nesting = _interopRequireDefault(nestingExports);
|
|
var _pseudo = _interopRequireDefault(pseudoExports);
|
|
var _root = _interopRequireDefault(rootExports);
|
|
var _selector = _interopRequireDefault(selectorExports);
|
|
var _string = _interopRequireDefault(stringExports);
|
|
var _tag = _interopRequireDefault(tagExports);
|
|
var _universal = _interopRequireDefault(universalExports);
|
|
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(processorExports);
|
|
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, distExports));
|
|
var selectorParser = /*@__PURE__*/getDefaultExportFromCjs(distExports);
|
|
const animationNameRE = /^(-\w+-)?animation-name$/;
|
const animationRE = /^(-\w+-)?animation$/;
|
const scopedPlugin = (id = "") => {
|
const keyframes = /* @__PURE__ */ 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}`)) {
|
keyframes[node.params] = node.params = node.params + "-" + shortId;
|
}
|
},
|
OnceExit(root) {
|
if (Object.keys(keyframes).length) {
|
root.walkDecls((decl) => {
|
if (animationNameRE.test(decl.prop)) {
|
decl.value = decl.value.split(",").map((v) => keyframes[v.trim()] || v.trim()).join(",");
|
}
|
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 = /* @__PURE__ */ 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, slotted = false) {
|
let node = null;
|
let shouldInject = true;
|
selector.each((n) => {
|
if (n.type === "combinator" && (n.value === ">>>" || n.value === "/deep/")) {
|
n.value = " ";
|
n.spaces.before = n.spaces.after = "";
|
warn$1(
|
`the >>> and /deep/ combinators have been deprecated. Use :deep() instead.`
|
);
|
return false;
|
}
|
if (n.type === "pseudo") {
|
const { value } = n;
|
if (value === ":deep" || value === "::v-deep") {
|
if (n.nodes.length) {
|
let last = n;
|
n.nodes[0].each((ss) => {
|
selector.insertAfter(last, ss);
|
last = ss;
|
});
|
const prev = selector.at(selector.index(n) - 1);
|
if (!prev || !isSpaceCombinator(prev)) {
|
selector.insertAfter(
|
n,
|
selectorParser.combinator({
|
value: " "
|
})
|
);
|
}
|
selector.removeChild(n);
|
} else {
|
warn$1(
|
`::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;
|
}
|
if (value === ":slotted" || value === "::v-slotted") {
|
rewriteSelector(
|
id,
|
n.nodes[0],
|
selectorRoot,
|
true
|
/* slotted */
|
);
|
let last = n;
|
n.nodes[0].each((ss) => {
|
selector.insertAfter(last, ss);
|
last = ss;
|
});
|
selector.removeChild(n);
|
shouldInject = false;
|
return false;
|
}
|
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 {
|
selector.first.spaces.before = "";
|
}
|
if (shouldInject) {
|
const idToAdd = slotted ? id + "-s" : id;
|
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: idToAdd,
|
value: idToAdd,
|
raws: {},
|
quoteMark: `"`
|
})
|
);
|
}
|
}
|
function isSpaceCombinator(node) {
|
return node.type === "combinator" && /^\s+$/.test(node.value);
|
}
|
scopedPlugin.postcss = true;
|
var scopedPlugin$1 = scopedPlugin;
|
|
var sourceMap$1 = {};
|
|
var sourceMapGenerator = {};
|
|
var base64Vlq = {};
|
|
var base64$1 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var intToCharMap = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
|
|
/**
|
* Encode an integer in the range of 0 to 63 to a single base 64 digit.
|
*/
|
base64$1.encode = function (number) {
|
if (0 <= number && number < intToCharMap.length) {
|
return intToCharMap[number];
|
}
|
throw new TypeError("Must be between 0 and 63: " + number);
|
};
|
|
/**
|
* Decode a single base 64 character code digit to an integer. Returns -1 on
|
* failure.
|
*/
|
base64$1.decode = function (charCode) {
|
var bigA = 65; // 'A'
|
var bigZ = 90; // 'Z'
|
|
var littleA = 97; // 'a'
|
var littleZ = 122; // 'z'
|
|
var zero = 48; // '0'
|
var nine = 57; // '9'
|
|
var plus = 43; // '+'
|
var slash = 47; // '/'
|
|
var littleOffset = 26;
|
var numberOffset = 52;
|
|
// 0 - 25: ABCDEFGHIJKLMNOPQRSTUVWXYZ
|
if (bigA <= charCode && charCode <= bigZ) {
|
return (charCode - bigA);
|
}
|
|
// 26 - 51: abcdefghijklmnopqrstuvwxyz
|
if (littleA <= charCode && charCode <= littleZ) {
|
return (charCode - littleA + littleOffset);
|
}
|
|
// 52 - 61: 0123456789
|
if (zero <= charCode && charCode <= nine) {
|
return (charCode - zero + numberOffset);
|
}
|
|
// 62: +
|
if (charCode == plus) {
|
return 62;
|
}
|
|
// 63: /
|
if (charCode == slash) {
|
return 63;
|
}
|
|
// Invalid base64 digit.
|
return -1;
|
};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*
|
* Based on the Base 64 VLQ implementation in Closure Compiler:
|
* https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
|
*
|
* Copyright 2011 The Closure Compiler Authors. All rights reserved.
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are
|
* met:
|
*
|
* * Redistributions of source code must retain the above copyright
|
* notice, this list of conditions and the following disclaimer.
|
* * Redistributions in binary form must reproduce the above
|
* copyright notice, this list of conditions and the following
|
* disclaimer in the documentation and/or other materials provided
|
* with the distribution.
|
* * Neither the name of Google Inc. nor the names of its
|
* contributors may be used to endorse or promote products derived
|
* from this software without specific prior written permission.
|
*
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*/
|
|
var base64 = base64$1;
|
|
// A single base 64 digit can contain 6 bits of data. For the base 64 variable
|
// length quantities we use in the source map spec, the first bit is the sign,
|
// the next four bits are the actual value, and the 6th bit is the
|
// continuation bit. The continuation bit tells us whether there are more
|
// digits in this value following this digit.
|
//
|
// Continuation
|
// | Sign
|
// | |
|
// V V
|
// 101011
|
|
var VLQ_BASE_SHIFT = 5;
|
|
// binary: 100000
|
var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
|
|
// binary: 011111
|
var VLQ_BASE_MASK = VLQ_BASE - 1;
|
|
// binary: 100000
|
var VLQ_CONTINUATION_BIT = VLQ_BASE;
|
|
/**
|
* Converts from a two-complement value to a value where the sign bit is
|
* placed in the least significant bit. For example, as decimals:
|
* 1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
|
* 2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
|
*/
|
function toVLQSigned(aValue) {
|
return aValue < 0
|
? ((-aValue) << 1) + 1
|
: (aValue << 1) + 0;
|
}
|
|
/**
|
* Converts to a two-complement value from a value where the sign bit is
|
* placed in the least significant bit. For example, as decimals:
|
* 2 (10 binary) becomes 1, 3 (11 binary) becomes -1
|
* 4 (100 binary) becomes 2, 5 (101 binary) becomes -2
|
*/
|
function fromVLQSigned(aValue) {
|
var isNegative = (aValue & 1) === 1;
|
var shifted = aValue >> 1;
|
return isNegative
|
? -shifted
|
: shifted;
|
}
|
|
/**
|
* Returns the base 64 VLQ encoded value.
|
*/
|
base64Vlq.encode = function base64VLQ_encode(aValue) {
|
var encoded = "";
|
var digit;
|
|
var vlq = toVLQSigned(aValue);
|
|
do {
|
digit = vlq & VLQ_BASE_MASK;
|
vlq >>>= VLQ_BASE_SHIFT;
|
if (vlq > 0) {
|
// There are still more digits in this value, so we must make sure the
|
// continuation bit is marked.
|
digit |= VLQ_CONTINUATION_BIT;
|
}
|
encoded += base64.encode(digit);
|
} while (vlq > 0);
|
|
return encoded;
|
};
|
|
/**
|
* Decodes the next base 64 VLQ value from the given string and returns the
|
* value and the rest of the string via the out parameter.
|
*/
|
base64Vlq.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
|
var strLen = aStr.length;
|
var result = 0;
|
var shift = 0;
|
var continuation, digit;
|
|
do {
|
if (aIndex >= strLen) {
|
throw new Error("Expected more digits in base 64 VLQ value.");
|
}
|
|
digit = base64.decode(aStr.charCodeAt(aIndex++));
|
if (digit === -1) {
|
throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
|
}
|
|
continuation = !!(digit & VLQ_CONTINUATION_BIT);
|
digit &= VLQ_BASE_MASK;
|
result = result + (digit << shift);
|
shift += VLQ_BASE_SHIFT;
|
} while (continuation);
|
|
aOutParam.value = fromVLQSigned(result);
|
aOutParam.rest = aIndex;
|
};
|
|
var util$5 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
(function (exports) {
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
/**
|
* This is a helper function for getting values from parameter/options
|
* objects.
|
*
|
* @param args The object we are extracting values from
|
* @param name The name of the property we are getting.
|
* @param defaultValue An optional value to return if the property is missing
|
* from the object. If this is not specified and the property is missing, an
|
* error will be thrown.
|
*/
|
function getArg(aArgs, aName, aDefaultValue) {
|
if (aName in aArgs) {
|
return aArgs[aName];
|
} else if (arguments.length === 3) {
|
return aDefaultValue;
|
} else {
|
throw new Error('"' + aName + '" is a required argument.');
|
}
|
}
|
exports.getArg = getArg;
|
|
var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
|
var dataUrlRegexp = /^data:.+\,.+$/;
|
|
function urlParse(aUrl) {
|
var match = aUrl.match(urlRegexp);
|
if (!match) {
|
return null;
|
}
|
return {
|
scheme: match[1],
|
auth: match[2],
|
host: match[3],
|
port: match[4],
|
path: match[5]
|
};
|
}
|
exports.urlParse = urlParse;
|
|
function urlGenerate(aParsedUrl) {
|
var url = '';
|
if (aParsedUrl.scheme) {
|
url += aParsedUrl.scheme + ':';
|
}
|
url += '//';
|
if (aParsedUrl.auth) {
|
url += aParsedUrl.auth + '@';
|
}
|
if (aParsedUrl.host) {
|
url += aParsedUrl.host;
|
}
|
if (aParsedUrl.port) {
|
url += ":" + aParsedUrl.port;
|
}
|
if (aParsedUrl.path) {
|
url += aParsedUrl.path;
|
}
|
return url;
|
}
|
exports.urlGenerate = urlGenerate;
|
|
/**
|
* Normalizes a path, or the path portion of a URL:
|
*
|
* - Replaces consecutive slashes with one slash.
|
* - Removes unnecessary '.' parts.
|
* - Removes unnecessary '<dir>/..' parts.
|
*
|
* Based on code in the Node.js 'path' core module.
|
*
|
* @param aPath The path or url to normalize.
|
*/
|
function normalize(aPath) {
|
var path = aPath;
|
var url = urlParse(aPath);
|
if (url) {
|
if (!url.path) {
|
return aPath;
|
}
|
path = url.path;
|
}
|
var isAbsolute = exports.isAbsolute(path);
|
|
var parts = path.split(/\/+/);
|
for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
|
part = parts[i];
|
if (part === '.') {
|
parts.splice(i, 1);
|
} else if (part === '..') {
|
up++;
|
} else if (up > 0) {
|
if (part === '') {
|
// The first part is blank if the path is absolute. Trying to go
|
// above the root is a no-op. Therefore we can remove all '..' parts
|
// directly after the root.
|
parts.splice(i + 1, up);
|
up = 0;
|
} else {
|
parts.splice(i, 2);
|
up--;
|
}
|
}
|
}
|
path = parts.join('/');
|
|
if (path === '') {
|
path = isAbsolute ? '/' : '.';
|
}
|
|
if (url) {
|
url.path = path;
|
return urlGenerate(url);
|
}
|
return path;
|
}
|
exports.normalize = normalize;
|
|
/**
|
* Joins two paths/URLs.
|
*
|
* @param aRoot The root path or URL.
|
* @param aPath The path or URL to be joined with the root.
|
*
|
* - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
|
* scheme-relative URL: Then the scheme of aRoot, if any, is prepended
|
* first.
|
* - Otherwise aPath is a path. If aRoot is a URL, then its path portion
|
* is updated with the result and aRoot is returned. Otherwise the result
|
* is returned.
|
* - If aPath is absolute, the result is aPath.
|
* - Otherwise the two paths are joined with a slash.
|
* - Joining for example 'http://' and 'www.example.com' is also supported.
|
*/
|
function join(aRoot, aPath) {
|
if (aRoot === "") {
|
aRoot = ".";
|
}
|
if (aPath === "") {
|
aPath = ".";
|
}
|
var aPathUrl = urlParse(aPath);
|
var aRootUrl = urlParse(aRoot);
|
if (aRootUrl) {
|
aRoot = aRootUrl.path || '/';
|
}
|
|
// `join(foo, '//www.example.org')`
|
if (aPathUrl && !aPathUrl.scheme) {
|
if (aRootUrl) {
|
aPathUrl.scheme = aRootUrl.scheme;
|
}
|
return urlGenerate(aPathUrl);
|
}
|
|
if (aPathUrl || aPath.match(dataUrlRegexp)) {
|
return aPath;
|
}
|
|
// `join('http://', 'www.example.com')`
|
if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
|
aRootUrl.host = aPath;
|
return urlGenerate(aRootUrl);
|
}
|
|
var joined = aPath.charAt(0) === '/'
|
? aPath
|
: normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
|
|
if (aRootUrl) {
|
aRootUrl.path = joined;
|
return urlGenerate(aRootUrl);
|
}
|
return joined;
|
}
|
exports.join = join;
|
|
exports.isAbsolute = function (aPath) {
|
return aPath.charAt(0) === '/' || urlRegexp.test(aPath);
|
};
|
|
/**
|
* Make a path relative to a URL or another path.
|
*
|
* @param aRoot The root path or URL.
|
* @param aPath The path or URL to be made relative to aRoot.
|
*/
|
function relative(aRoot, aPath) {
|
if (aRoot === "") {
|
aRoot = ".";
|
}
|
|
aRoot = aRoot.replace(/\/$/, '');
|
|
// It is possible for the path to be above the root. In this case, simply
|
// checking whether the root is a prefix of the path won't work. Instead, we
|
// need to remove components from the root one by one, until either we find
|
// a prefix that fits, or we run out of components to remove.
|
var level = 0;
|
while (aPath.indexOf(aRoot + '/') !== 0) {
|
var index = aRoot.lastIndexOf("/");
|
if (index < 0) {
|
return aPath;
|
}
|
|
// If the only part of the root that is left is the scheme (i.e. http://,
|
// file:///, etc.), one or more slashes (/), or simply nothing at all, we
|
// have exhausted all components, so the path is not relative to the root.
|
aRoot = aRoot.slice(0, index);
|
if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
|
return aPath;
|
}
|
|
++level;
|
}
|
|
// Make sure we add a "../" for each component we removed from the root.
|
return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
|
}
|
exports.relative = relative;
|
|
var supportsNullProto = (function () {
|
var obj = Object.create(null);
|
return !('__proto__' in obj);
|
}());
|
|
function identity (s) {
|
return s;
|
}
|
|
/**
|
* Because behavior goes wacky when you set `__proto__` on objects, we
|
* have to prefix all the strings in our set with an arbitrary character.
|
*
|
* See https://github.com/mozilla/source-map/pull/31 and
|
* https://github.com/mozilla/source-map/issues/30
|
*
|
* @param String aStr
|
*/
|
function toSetString(aStr) {
|
if (isProtoString(aStr)) {
|
return '$' + aStr;
|
}
|
|
return aStr;
|
}
|
exports.toSetString = supportsNullProto ? identity : toSetString;
|
|
function fromSetString(aStr) {
|
if (isProtoString(aStr)) {
|
return aStr.slice(1);
|
}
|
|
return aStr;
|
}
|
exports.fromSetString = supportsNullProto ? identity : fromSetString;
|
|
function isProtoString(s) {
|
if (!s) {
|
return false;
|
}
|
|
var length = s.length;
|
|
if (length < 9 /* "__proto__".length */) {
|
return false;
|
}
|
|
if (s.charCodeAt(length - 1) !== 95 /* '_' */ ||
|
s.charCodeAt(length - 2) !== 95 /* '_' */ ||
|
s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
|
s.charCodeAt(length - 4) !== 116 /* 't' */ ||
|
s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
|
s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
|
s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
|
s.charCodeAt(length - 8) !== 95 /* '_' */ ||
|
s.charCodeAt(length - 9) !== 95 /* '_' */) {
|
return false;
|
}
|
|
for (var i = length - 10; i >= 0; i--) {
|
if (s.charCodeAt(i) !== 36 /* '$' */) {
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
/**
|
* Comparator between two mappings where the original positions are compared.
|
*
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
* mappings with the same original source/line/column, but different generated
|
* line and column the same. Useful when searching for a mapping with a
|
* stubbed out mapping.
|
*/
|
function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
|
var cmp = strcmp(mappingA.source, mappingB.source);
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0 || onlyCompareOriginal) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedLine - mappingB.generatedLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByOriginalPositions = compareByOriginalPositions;
|
|
/**
|
* Comparator between two mappings with deflated source and name indices where
|
* the generated positions are compared.
|
*
|
* Optionally pass in `true` as `onlyCompareGenerated` to consider two
|
* mappings with the same generated line and column, but different
|
* source/name/original line and column the same. Useful when searching for a
|
* mapping with a stubbed out mapping.
|
*/
|
function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
|
var cmp = mappingA.generatedLine - mappingB.generatedLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0 || onlyCompareGenerated) {
|
return cmp;
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
|
|
function strcmp(aStr1, aStr2) {
|
if (aStr1 === aStr2) {
|
return 0;
|
}
|
|
if (aStr1 === null) {
|
return 1; // aStr2 !== null
|
}
|
|
if (aStr2 === null) {
|
return -1; // aStr1 !== null
|
}
|
|
if (aStr1 > aStr2) {
|
return 1;
|
}
|
|
return -1;
|
}
|
|
/**
|
* Comparator between two mappings with inflated source and name strings where
|
* the generated positions are compared.
|
*/
|
function compareByGeneratedPositionsInflated(mappingA, mappingB) {
|
var cmp = mappingA.generatedLine - mappingB.generatedLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.generatedColumn - mappingB.generatedColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = strcmp(mappingA.source, mappingB.source);
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalLine - mappingB.originalLine;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
cmp = mappingA.originalColumn - mappingB.originalColumn;
|
if (cmp !== 0) {
|
return cmp;
|
}
|
|
return strcmp(mappingA.name, mappingB.name);
|
}
|
exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
|
|
/**
|
* Strip any JSON XSSI avoidance prefix from the string (as documented
|
* in the source maps specification), and then parse the string as
|
* JSON.
|
*/
|
function parseSourceMapInput(str) {
|
return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''));
|
}
|
exports.parseSourceMapInput = parseSourceMapInput;
|
|
/**
|
* Compute the URL of a source given the the source root, the source's
|
* URL, and the source map's URL.
|
*/
|
function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
|
sourceURL = sourceURL || '';
|
|
if (sourceRoot) {
|
// This follows what Chrome does.
|
if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
|
sourceRoot += '/';
|
}
|
// The spec says:
|
// Line 4: An optional source root, useful for relocating source
|
// files on a server or removing repeated values in the
|
// “sources” entry. This value is prepended to the individual
|
// entries in the “source” field.
|
sourceURL = sourceRoot + sourceURL;
|
}
|
|
// Historically, SourceMapConsumer did not take the sourceMapURL as
|
// a parameter. This mode is still somewhat supported, which is why
|
// this code block is conditional. However, it's preferable to pass
|
// the source map URL to SourceMapConsumer, so that this function
|
// can implement the source URL resolution algorithm as outlined in
|
// the spec. This block is basically the equivalent of:
|
// new URL(sourceURL, sourceMapURL).toString()
|
// ... except it avoids using URL, which wasn't available in the
|
// older releases of node still supported by this library.
|
//
|
// The spec says:
|
// If the sources are not absolute URLs after prepending of the
|
// “sourceRoot”, the sources are resolved relative to the
|
// SourceMap (like resolving script src in a html document).
|
if (sourceMapURL) {
|
var parsed = urlParse(sourceMapURL);
|
if (!parsed) {
|
throw new Error("sourceMapURL could not be parsed");
|
}
|
if (parsed.path) {
|
// Strip the last path component, but keep the "/".
|
var index = parsed.path.lastIndexOf('/');
|
if (index >= 0) {
|
parsed.path = parsed.path.substring(0, index + 1);
|
}
|
}
|
sourceURL = join(urlGenerate(parsed), sourceURL);
|
}
|
|
return normalize(sourceURL);
|
}
|
exports.computeSourceURL = computeSourceURL;
|
} (util$5));
|
|
var arraySet = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var util$4 = util$5;
|
var has = Object.prototype.hasOwnProperty;
|
var hasNativeMap = typeof Map !== "undefined";
|
|
/**
|
* A data structure which is a combination of an array and a set. Adding a new
|
* member is O(1), testing for membership is O(1), and finding the index of an
|
* element is O(1). Removing elements from the set is not supported. Only
|
* strings are supported for membership.
|
*/
|
function ArraySet$2() {
|
this._array = [];
|
this._set = hasNativeMap ? new Map() : Object.create(null);
|
}
|
|
/**
|
* Static method for creating ArraySet instances from an existing array.
|
*/
|
ArraySet$2.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
|
var set = new ArraySet$2();
|
for (var i = 0, len = aArray.length; i < len; i++) {
|
set.add(aArray[i], aAllowDuplicates);
|
}
|
return set;
|
};
|
|
/**
|
* Return how many unique items are in this ArraySet. If duplicates have been
|
* added, than those do not count towards the size.
|
*
|
* @returns Number
|
*/
|
ArraySet$2.prototype.size = function ArraySet_size() {
|
return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
|
};
|
|
/**
|
* Add the given string to this set.
|
*
|
* @param String aStr
|
*/
|
ArraySet$2.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
|
var sStr = hasNativeMap ? aStr : util$4.toSetString(aStr);
|
var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
|
var idx = this._array.length;
|
if (!isDuplicate || aAllowDuplicates) {
|
this._array.push(aStr);
|
}
|
if (!isDuplicate) {
|
if (hasNativeMap) {
|
this._set.set(aStr, idx);
|
} else {
|
this._set[sStr] = idx;
|
}
|
}
|
};
|
|
/**
|
* Is the given string a member of this set?
|
*
|
* @param String aStr
|
*/
|
ArraySet$2.prototype.has = function ArraySet_has(aStr) {
|
if (hasNativeMap) {
|
return this._set.has(aStr);
|
} else {
|
var sStr = util$4.toSetString(aStr);
|
return has.call(this._set, sStr);
|
}
|
};
|
|
/**
|
* What is the index of the given string in the array?
|
*
|
* @param String aStr
|
*/
|
ArraySet$2.prototype.indexOf = function ArraySet_indexOf(aStr) {
|
if (hasNativeMap) {
|
var idx = this._set.get(aStr);
|
if (idx >= 0) {
|
return idx;
|
}
|
} else {
|
var sStr = util$4.toSetString(aStr);
|
if (has.call(this._set, sStr)) {
|
return this._set[sStr];
|
}
|
}
|
|
throw new Error('"' + aStr + '" is not in the set.');
|
};
|
|
/**
|
* What is the element at the given index?
|
*
|
* @param Number aIdx
|
*/
|
ArraySet$2.prototype.at = function ArraySet_at(aIdx) {
|
if (aIdx >= 0 && aIdx < this._array.length) {
|
return this._array[aIdx];
|
}
|
throw new Error('No element indexed by ' + aIdx);
|
};
|
|
/**
|
* Returns the array representation of this set (which has the proper indices
|
* indicated by indexOf). Note that this is a copy of the internal array used
|
* for storing the members so that no one can mess with internal state.
|
*/
|
ArraySet$2.prototype.toArray = function ArraySet_toArray() {
|
return this._array.slice();
|
};
|
|
arraySet.ArraySet = ArraySet$2;
|
|
var mappingList = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2014 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var util$3 = util$5;
|
|
/**
|
* Determine whether mappingB is after mappingA with respect to generated
|
* position.
|
*/
|
function generatedPositionAfter(mappingA, mappingB) {
|
// Optimized for most common case
|
var lineA = mappingA.generatedLine;
|
var lineB = mappingB.generatedLine;
|
var columnA = mappingA.generatedColumn;
|
var columnB = mappingB.generatedColumn;
|
return lineB > lineA || lineB == lineA && columnB >= columnA ||
|
util$3.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
|
}
|
|
/**
|
* A data structure to provide a sorted view of accumulated mappings in a
|
* performance conscious manner. It trades a neglibable overhead in general
|
* case for a large speedup in case of mappings being added in order.
|
*/
|
function MappingList$1() {
|
this._array = [];
|
this._sorted = true;
|
// Serves as infimum
|
this._last = {generatedLine: -1, generatedColumn: 0};
|
}
|
|
/**
|
* Iterate through internal items. This method takes the same arguments that
|
* `Array.prototype.forEach` takes.
|
*
|
* NOTE: The order of the mappings is NOT guaranteed.
|
*/
|
MappingList$1.prototype.unsortedForEach =
|
function MappingList_forEach(aCallback, aThisArg) {
|
this._array.forEach(aCallback, aThisArg);
|
};
|
|
/**
|
* Add the given source mapping.
|
*
|
* @param Object aMapping
|
*/
|
MappingList$1.prototype.add = function MappingList_add(aMapping) {
|
if (generatedPositionAfter(this._last, aMapping)) {
|
this._last = aMapping;
|
this._array.push(aMapping);
|
} else {
|
this._sorted = false;
|
this._array.push(aMapping);
|
}
|
};
|
|
/**
|
* Returns the flat, sorted array of mappings. The mappings are sorted by
|
* generated position.
|
*
|
* WARNING: This method returns internal data without copying, for
|
* performance. The return value must NOT be mutated, and should be treated as
|
* an immutable borrow. If you want to take ownership, you must make your own
|
* copy.
|
*/
|
MappingList$1.prototype.toArray = function MappingList_toArray() {
|
if (!this._sorted) {
|
this._array.sort(util$3.compareByGeneratedPositionsInflated);
|
this._sorted = true;
|
}
|
return this._array;
|
};
|
|
mappingList.MappingList = MappingList$1;
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var base64VLQ$1 = base64Vlq;
|
var util$2 = util$5;
|
var ArraySet$1 = arraySet.ArraySet;
|
var MappingList = mappingList.MappingList;
|
|
/**
|
* An instance of the SourceMapGenerator represents a source map which is
|
* being built incrementally. You may pass an object with the following
|
* properties:
|
*
|
* - file: The filename of the generated source.
|
* - sourceRoot: A root for all relative URLs in this source map.
|
*/
|
function SourceMapGenerator$2(aArgs) {
|
if (!aArgs) {
|
aArgs = {};
|
}
|
this._file = util$2.getArg(aArgs, 'file', null);
|
this._sourceRoot = util$2.getArg(aArgs, 'sourceRoot', null);
|
this._skipValidation = util$2.getArg(aArgs, 'skipValidation', false);
|
this._sources = new ArraySet$1();
|
this._names = new ArraySet$1();
|
this._mappings = new MappingList();
|
this._sourcesContents = null;
|
}
|
|
SourceMapGenerator$2.prototype._version = 3;
|
|
/**
|
* Creates a new SourceMapGenerator based on a SourceMapConsumer
|
*
|
* @param aSourceMapConsumer The SourceMap.
|
*/
|
SourceMapGenerator$2.fromSourceMap =
|
function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
|
var sourceRoot = aSourceMapConsumer.sourceRoot;
|
var generator = new SourceMapGenerator$2({
|
file: aSourceMapConsumer.file,
|
sourceRoot: sourceRoot
|
});
|
aSourceMapConsumer.eachMapping(function (mapping) {
|
var newMapping = {
|
generated: {
|
line: mapping.generatedLine,
|
column: mapping.generatedColumn
|
}
|
};
|
|
if (mapping.source != null) {
|
newMapping.source = mapping.source;
|
if (sourceRoot != null) {
|
newMapping.source = util$2.relative(sourceRoot, newMapping.source);
|
}
|
|
newMapping.original = {
|
line: mapping.originalLine,
|
column: mapping.originalColumn
|
};
|
|
if (mapping.name != null) {
|
newMapping.name = mapping.name;
|
}
|
}
|
|
generator.addMapping(newMapping);
|
});
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
var sourceRelative = sourceFile;
|
if (sourceRoot !== null) {
|
sourceRelative = util$2.relative(sourceRoot, sourceFile);
|
}
|
|
if (!generator._sources.has(sourceRelative)) {
|
generator._sources.add(sourceRelative);
|
}
|
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
if (content != null) {
|
generator.setSourceContent(sourceFile, content);
|
}
|
});
|
return generator;
|
};
|
|
/**
|
* Add a single mapping from original source line and column to the generated
|
* source's line and column for this source map being created. The mapping
|
* object should have the following properties:
|
*
|
* - generated: An object with the generated line and column positions.
|
* - original: An object with the original line and column positions.
|
* - source: The original source file (relative to the sourceRoot).
|
* - name: An optional original token name for this mapping.
|
*/
|
SourceMapGenerator$2.prototype.addMapping =
|
function SourceMapGenerator_addMapping(aArgs) {
|
var generated = util$2.getArg(aArgs, 'generated');
|
var original = util$2.getArg(aArgs, 'original', null);
|
var source = util$2.getArg(aArgs, 'source', null);
|
var name = util$2.getArg(aArgs, 'name', null);
|
|
if (!this._skipValidation) {
|
this._validateMapping(generated, original, source, name);
|
}
|
|
if (source != null) {
|
source = String(source);
|
if (!this._sources.has(source)) {
|
this._sources.add(source);
|
}
|
}
|
|
if (name != null) {
|
name = String(name);
|
if (!this._names.has(name)) {
|
this._names.add(name);
|
}
|
}
|
|
this._mappings.add({
|
generatedLine: generated.line,
|
generatedColumn: generated.column,
|
originalLine: original != null && original.line,
|
originalColumn: original != null && original.column,
|
source: source,
|
name: name
|
});
|
};
|
|
/**
|
* Set the source content for a source file.
|
*/
|
SourceMapGenerator$2.prototype.setSourceContent =
|
function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
|
var source = aSourceFile;
|
if (this._sourceRoot != null) {
|
source = util$2.relative(this._sourceRoot, source);
|
}
|
|
if (aSourceContent != null) {
|
// Add the source content to the _sourcesContents map.
|
// Create a new _sourcesContents map if the property is null.
|
if (!this._sourcesContents) {
|
this._sourcesContents = Object.create(null);
|
}
|
this._sourcesContents[util$2.toSetString(source)] = aSourceContent;
|
} else if (this._sourcesContents) {
|
// Remove the source file from the _sourcesContents map.
|
// If the _sourcesContents map is empty, set the property to null.
|
delete this._sourcesContents[util$2.toSetString(source)];
|
if (Object.keys(this._sourcesContents).length === 0) {
|
this._sourcesContents = null;
|
}
|
}
|
};
|
|
/**
|
* Applies the mappings of a sub-source-map for a specific source file to the
|
* source map being generated. Each mapping to the supplied source file is
|
* rewritten using the supplied source map. Note: The resolution for the
|
* resulting mappings is the minimium of this map and the supplied map.
|
*
|
* @param aSourceMapConsumer The source map to be applied.
|
* @param aSourceFile Optional. The filename of the source file.
|
* If omitted, SourceMapConsumer's file property will be used.
|
* @param aSourceMapPath Optional. The dirname of the path to the source map
|
* to be applied. If relative, it is relative to the SourceMapConsumer.
|
* This parameter is needed when the two source maps aren't in the same
|
* directory, and the source map to be applied contains relative source
|
* paths. If so, those relative source paths need to be rewritten
|
* relative to the SourceMapGenerator.
|
*/
|
SourceMapGenerator$2.prototype.applySourceMap =
|
function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
|
var sourceFile = aSourceFile;
|
// If aSourceFile is omitted, we will use the file property of the SourceMap
|
if (aSourceFile == null) {
|
if (aSourceMapConsumer.file == null) {
|
throw new Error(
|
'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
|
'or the source map\'s "file" property. Both were omitted.'
|
);
|
}
|
sourceFile = aSourceMapConsumer.file;
|
}
|
var sourceRoot = this._sourceRoot;
|
// Make "sourceFile" relative if an absolute Url is passed.
|
if (sourceRoot != null) {
|
sourceFile = util$2.relative(sourceRoot, sourceFile);
|
}
|
// Applying the SourceMap can add and remove items from the sources and
|
// the names array.
|
var newSources = new ArraySet$1();
|
var newNames = new ArraySet$1();
|
|
// Find mappings for the "sourceFile"
|
this._mappings.unsortedForEach(function (mapping) {
|
if (mapping.source === sourceFile && mapping.originalLine != null) {
|
// Check if it can be mapped by the source map, then update the mapping.
|
var original = aSourceMapConsumer.originalPositionFor({
|
line: mapping.originalLine,
|
column: mapping.originalColumn
|
});
|
if (original.source != null) {
|
// Copy mapping
|
mapping.source = original.source;
|
if (aSourceMapPath != null) {
|
mapping.source = util$2.join(aSourceMapPath, mapping.source);
|
}
|
if (sourceRoot != null) {
|
mapping.source = util$2.relative(sourceRoot, mapping.source);
|
}
|
mapping.originalLine = original.line;
|
mapping.originalColumn = original.column;
|
if (original.name != null) {
|
mapping.name = original.name;
|
}
|
}
|
}
|
|
var source = mapping.source;
|
if (source != null && !newSources.has(source)) {
|
newSources.add(source);
|
}
|
|
var name = mapping.name;
|
if (name != null && !newNames.has(name)) {
|
newNames.add(name);
|
}
|
|
}, this);
|
this._sources = newSources;
|
this._names = newNames;
|
|
// Copy sourcesContents of applied map.
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
if (content != null) {
|
if (aSourceMapPath != null) {
|
sourceFile = util$2.join(aSourceMapPath, sourceFile);
|
}
|
if (sourceRoot != null) {
|
sourceFile = util$2.relative(sourceRoot, sourceFile);
|
}
|
this.setSourceContent(sourceFile, content);
|
}
|
}, this);
|
};
|
|
/**
|
* A mapping can have one of the three levels of data:
|
*
|
* 1. Just the generated position.
|
* 2. The Generated position, original position, and original source.
|
* 3. Generated and original position, original source, as well as a name
|
* token.
|
*
|
* To maintain consistency, we validate that any new mapping being added falls
|
* in to one of these categories.
|
*/
|
SourceMapGenerator$2.prototype._validateMapping =
|
function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource,
|
aName) {
|
// When aOriginal is truthy but has empty values for .line and .column,
|
// it is most likely a programmer error. In this case we throw a very
|
// specific error message to try to guide them the right way.
|
// For example: https://github.com/Polymer/polymer-bundler/pull/519
|
if (aOriginal && typeof aOriginal.line !== 'number' && typeof aOriginal.column !== 'number') {
|
throw new Error(
|
'original.line and original.column are not numbers -- you probably meant to omit ' +
|
'the original mapping entirely and only map the generated position. If so, pass ' +
|
'null for the original mapping instead of an object with empty or null values.'
|
);
|
}
|
|
if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
|
&& aGenerated.line > 0 && aGenerated.column >= 0
|
&& !aOriginal && !aSource && !aName) {
|
// Case 1.
|
return;
|
}
|
else if (aGenerated && 'line' in aGenerated && 'column' in aGenerated
|
&& aOriginal && 'line' in aOriginal && 'column' in aOriginal
|
&& aGenerated.line > 0 && aGenerated.column >= 0
|
&& aOriginal.line > 0 && aOriginal.column >= 0
|
&& aSource) {
|
// Cases 2 and 3.
|
return;
|
}
|
else {
|
throw new Error('Invalid mapping: ' + JSON.stringify({
|
generated: aGenerated,
|
source: aSource,
|
original: aOriginal,
|
name: aName
|
}));
|
}
|
};
|
|
/**
|
* Serialize the accumulated mappings in to the stream of base 64 VLQs
|
* specified by the source map format.
|
*/
|
SourceMapGenerator$2.prototype._serializeMappings =
|
function SourceMapGenerator_serializeMappings() {
|
var previousGeneratedColumn = 0;
|
var previousGeneratedLine = 1;
|
var previousOriginalColumn = 0;
|
var previousOriginalLine = 0;
|
var previousName = 0;
|
var previousSource = 0;
|
var result = '';
|
var next;
|
var mapping;
|
var nameIdx;
|
var sourceIdx;
|
|
var mappings = this._mappings.toArray();
|
for (var i = 0, len = mappings.length; i < len; i++) {
|
mapping = mappings[i];
|
next = '';
|
|
if (mapping.generatedLine !== previousGeneratedLine) {
|
previousGeneratedColumn = 0;
|
while (mapping.generatedLine !== previousGeneratedLine) {
|
next += ';';
|
previousGeneratedLine++;
|
}
|
}
|
else {
|
if (i > 0) {
|
if (!util$2.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
|
continue;
|
}
|
next += ',';
|
}
|
}
|
|
next += base64VLQ$1.encode(mapping.generatedColumn
|
- previousGeneratedColumn);
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
if (mapping.source != null) {
|
sourceIdx = this._sources.indexOf(mapping.source);
|
next += base64VLQ$1.encode(sourceIdx - previousSource);
|
previousSource = sourceIdx;
|
|
// lines are stored 0-based in SourceMap spec version 3
|
next += base64VLQ$1.encode(mapping.originalLine - 1
|
- previousOriginalLine);
|
previousOriginalLine = mapping.originalLine - 1;
|
|
next += base64VLQ$1.encode(mapping.originalColumn
|
- previousOriginalColumn);
|
previousOriginalColumn = mapping.originalColumn;
|
|
if (mapping.name != null) {
|
nameIdx = this._names.indexOf(mapping.name);
|
next += base64VLQ$1.encode(nameIdx - previousName);
|
previousName = nameIdx;
|
}
|
}
|
|
result += next;
|
}
|
|
return result;
|
};
|
|
SourceMapGenerator$2.prototype._generateSourcesContent =
|
function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
|
return aSources.map(function (source) {
|
if (!this._sourcesContents) {
|
return null;
|
}
|
if (aSourceRoot != null) {
|
source = util$2.relative(aSourceRoot, source);
|
}
|
var key = util$2.toSetString(source);
|
return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
|
? this._sourcesContents[key]
|
: null;
|
}, this);
|
};
|
|
/**
|
* Externalize the source map.
|
*/
|
SourceMapGenerator$2.prototype.toJSON =
|
function SourceMapGenerator_toJSON() {
|
var map = {
|
version: this._version,
|
sources: this._sources.toArray(),
|
names: this._names.toArray(),
|
mappings: this._serializeMappings()
|
};
|
if (this._file != null) {
|
map.file = this._file;
|
}
|
if (this._sourceRoot != null) {
|
map.sourceRoot = this._sourceRoot;
|
}
|
if (this._sourcesContents) {
|
map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
|
}
|
|
return map;
|
};
|
|
/**
|
* Render the source map being generated to a string.
|
*/
|
SourceMapGenerator$2.prototype.toString =
|
function SourceMapGenerator_toString() {
|
return JSON.stringify(this.toJSON());
|
};
|
|
sourceMapGenerator.SourceMapGenerator = SourceMapGenerator$2;
|
|
var sourceMapConsumer = {};
|
|
var binarySearch$1 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
(function (exports) {
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
exports.GREATEST_LOWER_BOUND = 1;
|
exports.LEAST_UPPER_BOUND = 2;
|
|
/**
|
* Recursive implementation of binary search.
|
*
|
* @param aLow Indices here and lower do not contain the needle.
|
* @param aHigh Indices here and higher do not contain the needle.
|
* @param aNeedle The element being searched for.
|
* @param aHaystack The non-empty array being searched.
|
* @param aCompare Function which takes two elements and returns -1, 0, or 1.
|
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
|
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
*/
|
function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
|
// This function terminates when one of the following is true:
|
//
|
// 1. We find the exact element we are looking for.
|
//
|
// 2. We did not find the exact element, but we can return the index of
|
// the next-closest element.
|
//
|
// 3. We did not find the exact element, and there is no next-closest
|
// element than the one we are searching for, so we return -1.
|
var mid = Math.floor((aHigh - aLow) / 2) + aLow;
|
var cmp = aCompare(aNeedle, aHaystack[mid], true);
|
if (cmp === 0) {
|
// Found the element we are looking for.
|
return mid;
|
}
|
else if (cmp > 0) {
|
// Our needle is greater than aHaystack[mid].
|
if (aHigh - mid > 1) {
|
// The element is in the upper half.
|
return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
|
}
|
|
// The exact needle element was not found in this haystack. Determine if
|
// we are in termination case (3) or (2) and return the appropriate thing.
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
return aHigh < aHaystack.length ? aHigh : -1;
|
} else {
|
return mid;
|
}
|
}
|
else {
|
// Our needle is less than aHaystack[mid].
|
if (mid - aLow > 1) {
|
// The element is in the lower half.
|
return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
|
}
|
|
// we are in termination case (3) or (2) and return the appropriate thing.
|
if (aBias == exports.LEAST_UPPER_BOUND) {
|
return mid;
|
} else {
|
return aLow < 0 ? -1 : aLow;
|
}
|
}
|
}
|
|
/**
|
* This is an implementation of binary search which will always try and return
|
* the index of the closest element if there is no exact hit. This is because
|
* mappings between original and generated line/col pairs are single points,
|
* and there is an implicit region between each of them, so a miss just means
|
* that you aren't on the very start of a region.
|
*
|
* @param aNeedle The element you are looking for.
|
* @param aHaystack The array that is being searched.
|
* @param aCompare A function which takes the needle and an element in the
|
* array and returns -1, 0, or 1 depending on whether the needle is less
|
* than, equal to, or greater than the element, respectively.
|
* @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
|
* 'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
* Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
|
*/
|
exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
|
if (aHaystack.length === 0) {
|
return -1;
|
}
|
|
var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
|
aCompare, aBias || exports.GREATEST_LOWER_BOUND);
|
if (index < 0) {
|
return -1;
|
}
|
|
// We have found either the exact element, or the next-closest element than
|
// the one we are searching for. However, there may be more than one such
|
// element. Make sure we always return the smallest of these.
|
while (index - 1 >= 0) {
|
if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
|
break;
|
}
|
--index;
|
}
|
|
return index;
|
};
|
} (binarySearch$1));
|
|
var quickSort$1 = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
// It turns out that some (most?) JavaScript engines don't self-host
|
// `Array.prototype.sort`. This makes sense because C++ will likely remain
|
// faster than JS when doing raw CPU-intensive sorting. However, when using a
|
// custom comparator function, calling back and forth between the VM's C++ and
|
// JIT'd JS is rather slow *and* loses JIT type information, resulting in
|
// worse generated code for the comparator function than would be optimal. In
|
// fact, when sorting with a comparator, these costs outweigh the benefits of
|
// sorting in C++. By using our own JS-implemented Quick Sort (below), we get
|
// a ~3500ms mean speed-up in `bench/bench.html`.
|
|
/**
|
* Swap the elements indexed by `x` and `y` in the array `ary`.
|
*
|
* @param {Array} ary
|
* The array.
|
* @param {Number} x
|
* The index of the first item.
|
* @param {Number} y
|
* The index of the second item.
|
*/
|
function swap(ary, x, y) {
|
var temp = ary[x];
|
ary[x] = ary[y];
|
ary[y] = temp;
|
}
|
|
/**
|
* Returns a random integer within the range `low .. high` inclusive.
|
*
|
* @param {Number} low
|
* The lower bound on the range.
|
* @param {Number} high
|
* The upper bound on the range.
|
*/
|
function randomIntInRange(low, high) {
|
return Math.round(low + (Math.random() * (high - low)));
|
}
|
|
/**
|
* The Quick Sort algorithm.
|
*
|
* @param {Array} ary
|
* An array to sort.
|
* @param {function} comparator
|
* Function to use to compare two items.
|
* @param {Number} p
|
* Start index of the array
|
* @param {Number} r
|
* End index of the array
|
*/
|
function doQuickSort(ary, comparator, p, r) {
|
// If our lower bound is less than our upper bound, we (1) partition the
|
// array into two pieces and (2) recurse on each half. If it is not, this is
|
// the empty array and our base case.
|
|
if (p < r) {
|
// (1) Partitioning.
|
//
|
// The partitioning chooses a pivot between `p` and `r` and moves all
|
// elements that are less than or equal to the pivot to the before it, and
|
// all the elements that are greater than it after it. The effect is that
|
// once partition is done, the pivot is in the exact place it will be when
|
// the array is put in sorted order, and it will not need to be moved
|
// again. This runs in O(n) time.
|
|
// Always choose a random pivot so that an input array which is reverse
|
// sorted does not cause O(n^2) running time.
|
var pivotIndex = randomIntInRange(p, r);
|
var i = p - 1;
|
|
swap(ary, pivotIndex, r);
|
var pivot = ary[r];
|
|
// Immediately after `j` is incremented in this loop, the following hold
|
// true:
|
//
|
// * Every element in `ary[p .. i]` is less than or equal to the pivot.
|
//
|
// * Every element in `ary[i+1 .. j-1]` is greater than the pivot.
|
for (var j = p; j < r; j++) {
|
if (comparator(ary[j], pivot) <= 0) {
|
i += 1;
|
swap(ary, i, j);
|
}
|
}
|
|
swap(ary, i + 1, j);
|
var q = i + 1;
|
|
// (2) Recurse on each half.
|
|
doQuickSort(ary, comparator, p, q - 1);
|
doQuickSort(ary, comparator, q + 1, r);
|
}
|
}
|
|
/**
|
* Sort the given array in-place with the given comparator function.
|
*
|
* @param {Array} ary
|
* An array to sort.
|
* @param {function} comparator
|
* Function to use to compare two items.
|
*/
|
quickSort$1.quickSort = function (ary, comparator) {
|
doQuickSort(ary, comparator, 0, ary.length - 1);
|
};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var util$1 = util$5;
|
var binarySearch = binarySearch$1;
|
var ArraySet = arraySet.ArraySet;
|
var base64VLQ = base64Vlq;
|
var quickSort = quickSort$1.quickSort;
|
|
function SourceMapConsumer$1(aSourceMap, aSourceMapURL) {
|
var sourceMap = aSourceMap;
|
if (typeof aSourceMap === 'string') {
|
sourceMap = util$1.parseSourceMapInput(aSourceMap);
|
}
|
|
return sourceMap.sections != null
|
? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
|
: new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
|
}
|
|
SourceMapConsumer$1.fromSourceMap = function(aSourceMap, aSourceMapURL) {
|
return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
|
};
|
|
/**
|
* The version of the source mapping spec that we are consuming.
|
*/
|
SourceMapConsumer$1.prototype._version = 3;
|
|
// `__generatedMappings` and `__originalMappings` are arrays that hold the
|
// parsed mapping coordinates from the source map's "mappings" attribute. They
|
// are lazily instantiated, accessed via the `_generatedMappings` and
|
// `_originalMappings` getters respectively, and we only parse the mappings
|
// and create these arrays once queried for a source location. We jump through
|
// these hoops because there can be many thousands of mappings, and parsing
|
// them is expensive, so we only want to do it if we must.
|
//
|
// Each object in the arrays is of the form:
|
//
|
// {
|
// generatedLine: The line number in the generated code,
|
// generatedColumn: The column number in the generated code,
|
// source: The path to the original source file that generated this
|
// chunk of code,
|
// originalLine: The line number in the original source that
|
// corresponds to this chunk of generated code,
|
// originalColumn: The column number in the original source that
|
// corresponds to this chunk of generated code,
|
// name: The name of the original symbol which generated this chunk of
|
// code.
|
// }
|
//
|
// All properties except for `generatedLine` and `generatedColumn` can be
|
// `null`.
|
//
|
// `_generatedMappings` is ordered by the generated positions.
|
//
|
// `_originalMappings` is ordered by the original positions.
|
|
SourceMapConsumer$1.prototype.__generatedMappings = null;
|
Object.defineProperty(SourceMapConsumer$1.prototype, '_generatedMappings', {
|
configurable: true,
|
enumerable: true,
|
get: function () {
|
if (!this.__generatedMappings) {
|
this._parseMappings(this._mappings, this.sourceRoot);
|
}
|
|
return this.__generatedMappings;
|
}
|
});
|
|
SourceMapConsumer$1.prototype.__originalMappings = null;
|
Object.defineProperty(SourceMapConsumer$1.prototype, '_originalMappings', {
|
configurable: true,
|
enumerable: true,
|
get: function () {
|
if (!this.__originalMappings) {
|
this._parseMappings(this._mappings, this.sourceRoot);
|
}
|
|
return this.__originalMappings;
|
}
|
});
|
|
SourceMapConsumer$1.prototype._charIsMappingSeparator =
|
function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
|
var c = aStr.charAt(index);
|
return c === ";" || c === ",";
|
};
|
|
/**
|
* Parse the mappings in a string in to a data structure which we can easily
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
* `this.__originalMappings` properties).
|
*/
|
SourceMapConsumer$1.prototype._parseMappings =
|
function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
throw new Error("Subclasses must implement _parseMappings");
|
};
|
|
SourceMapConsumer$1.GENERATED_ORDER = 1;
|
SourceMapConsumer$1.ORIGINAL_ORDER = 2;
|
|
SourceMapConsumer$1.GREATEST_LOWER_BOUND = 1;
|
SourceMapConsumer$1.LEAST_UPPER_BOUND = 2;
|
|
/**
|
* Iterate over each mapping between an original source/line/column and a
|
* generated line/column in this source map.
|
*
|
* @param Function aCallback
|
* The function that is called with each mapping.
|
* @param Object aContext
|
* Optional. If specified, this object will be the value of `this` every
|
* time that `aCallback` is called.
|
* @param aOrder
|
* Either `SourceMapConsumer.GENERATED_ORDER` or
|
* `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
|
* iterate over the mappings sorted by the generated file's line/column
|
* order or the original's source/line/column order, respectively. Defaults to
|
* `SourceMapConsumer.GENERATED_ORDER`.
|
*/
|
SourceMapConsumer$1.prototype.eachMapping =
|
function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
|
var context = aContext || null;
|
var order = aOrder || SourceMapConsumer$1.GENERATED_ORDER;
|
|
var mappings;
|
switch (order) {
|
case SourceMapConsumer$1.GENERATED_ORDER:
|
mappings = this._generatedMappings;
|
break;
|
case SourceMapConsumer$1.ORIGINAL_ORDER:
|
mappings = this._originalMappings;
|
break;
|
default:
|
throw new Error("Unknown order of iteration.");
|
}
|
|
var sourceRoot = this.sourceRoot;
|
mappings.map(function (mapping) {
|
var source = mapping.source === null ? null : this._sources.at(mapping.source);
|
source = util$1.computeSourceURL(sourceRoot, source, this._sourceMapURL);
|
return {
|
source: source,
|
generatedLine: mapping.generatedLine,
|
generatedColumn: mapping.generatedColumn,
|
originalLine: mapping.originalLine,
|
originalColumn: mapping.originalColumn,
|
name: mapping.name === null ? null : this._names.at(mapping.name)
|
};
|
}, this).forEach(aCallback, context);
|
};
|
|
/**
|
* Returns all generated line and column information for the original source,
|
* line, and column provided. If no column is provided, returns all mappings
|
* corresponding to a either the line we are searching for or the next
|
* closest line that has any mappings. Otherwise, returns all mappings
|
* corresponding to the given line and either the column we are searching for
|
* or the next closest column that has any offsets.
|
*
|
* The only argument is an object with the following properties:
|
*
|
* - source: The filename of the original source.
|
* - line: The line number in the original source. The line number is 1-based.
|
* - column: Optional. the column number in the original source.
|
* The column number is 0-based.
|
*
|
* and an array of objects is returned, each with the following properties:
|
*
|
* - line: The line number in the generated source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the generated source, or null.
|
* The column number is 0-based.
|
*/
|
SourceMapConsumer$1.prototype.allGeneratedPositionsFor =
|
function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
|
var line = util$1.getArg(aArgs, 'line');
|
|
// When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
|
// returns the index of the closest mapping less than the needle. By
|
// setting needle.originalColumn to 0, we thus find the last mapping for
|
// the given line, provided such a mapping exists.
|
var needle = {
|
source: util$1.getArg(aArgs, 'source'),
|
originalLine: line,
|
originalColumn: util$1.getArg(aArgs, 'column', 0)
|
};
|
|
needle.source = this._findSourceIndex(needle.source);
|
if (needle.source < 0) {
|
return [];
|
}
|
|
var mappings = [];
|
|
var index = this._findMapping(needle,
|
this._originalMappings,
|
"originalLine",
|
"originalColumn",
|
util$1.compareByOriginalPositions,
|
binarySearch.LEAST_UPPER_BOUND);
|
if (index >= 0) {
|
var mapping = this._originalMappings[index];
|
|
if (aArgs.column === undefined) {
|
var originalLine = mapping.originalLine;
|
|
// Iterate until either we run out of mappings, or we run into
|
// a mapping for a different line than the one we found. Since
|
// mappings are sorted, this is guaranteed to find all mappings for
|
// the line we found.
|
while (mapping && mapping.originalLine === originalLine) {
|
mappings.push({
|
line: util$1.getArg(mapping, 'generatedLine', null),
|
column: util$1.getArg(mapping, 'generatedColumn', null),
|
lastColumn: util$1.getArg(mapping, 'lastGeneratedColumn', null)
|
});
|
|
mapping = this._originalMappings[++index];
|
}
|
} else {
|
var originalColumn = mapping.originalColumn;
|
|
// Iterate until either we run out of mappings, or we run into
|
// a mapping for a different line than the one we were searching for.
|
// Since mappings are sorted, this is guaranteed to find all mappings for
|
// the line we are searching for.
|
while (mapping &&
|
mapping.originalLine === line &&
|
mapping.originalColumn == originalColumn) {
|
mappings.push({
|
line: util$1.getArg(mapping, 'generatedLine', null),
|
column: util$1.getArg(mapping, 'generatedColumn', null),
|
lastColumn: util$1.getArg(mapping, 'lastGeneratedColumn', null)
|
});
|
|
mapping = this._originalMappings[++index];
|
}
|
}
|
}
|
|
return mappings;
|
};
|
|
sourceMapConsumer.SourceMapConsumer = SourceMapConsumer$1;
|
|
/**
|
* A BasicSourceMapConsumer instance represents a parsed source map which we can
|
* query for information about the original file positions by giving it a file
|
* position in the generated source.
|
*
|
* The first parameter is the raw source map (either as a JSON string, or
|
* already parsed to an object). According to the spec, source maps have the
|
* following attributes:
|
*
|
* - version: Which version of the source map spec this map is following.
|
* - sources: An array of URLs to the original source files.
|
* - names: An array of identifiers which can be referrenced by individual mappings.
|
* - sourceRoot: Optional. The URL root from which all sources are relative.
|
* - sourcesContent: Optional. An array of contents of the original source files.
|
* - mappings: A string of base64 VLQs which contain the actual mappings.
|
* - file: Optional. The generated file this source map is associated with.
|
*
|
* Here is an example source map, taken from the source map spec[0]:
|
*
|
* {
|
* version : 3,
|
* file: "out.js",
|
* sourceRoot : "",
|
* sources: ["foo.js", "bar.js"],
|
* names: ["src", "maps", "are", "fun"],
|
* mappings: "AA,AB;;ABCDE;"
|
* }
|
*
|
* The second parameter, if given, is a string whose value is the URL
|
* at which the source map was found. This URL is used to compute the
|
* sources array.
|
*
|
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
|
*/
|
function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
|
var sourceMap = aSourceMap;
|
if (typeof aSourceMap === 'string') {
|
sourceMap = util$1.parseSourceMapInput(aSourceMap);
|
}
|
|
var version = util$1.getArg(sourceMap, 'version');
|
var sources = util$1.getArg(sourceMap, 'sources');
|
// Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
|
// requires the array) to play nice here.
|
var names = util$1.getArg(sourceMap, 'names', []);
|
var sourceRoot = util$1.getArg(sourceMap, 'sourceRoot', null);
|
var sourcesContent = util$1.getArg(sourceMap, 'sourcesContent', null);
|
var mappings = util$1.getArg(sourceMap, 'mappings');
|
var file = util$1.getArg(sourceMap, 'file', null);
|
|
// Once again, Sass deviates from the spec and supplies the version as a
|
// string rather than a number, so we use loose equality checking here.
|
if (version != this._version) {
|
throw new Error('Unsupported version: ' + version);
|
}
|
|
if (sourceRoot) {
|
sourceRoot = util$1.normalize(sourceRoot);
|
}
|
|
sources = sources
|
.map(String)
|
// Some source maps produce relative source paths like "./foo.js" instead of
|
// "foo.js". Normalize these first so that future comparisons will succeed.
|
// See bugzil.la/1090768.
|
.map(util$1.normalize)
|
// Always ensure that absolute sources are internally stored relative to
|
// the source root, if the source root is absolute. Not doing this would
|
// be particularly problematic when the source root is a prefix of the
|
// source (valid, but why??). See github issue #199 and bugzil.la/1188982.
|
.map(function (source) {
|
return sourceRoot && util$1.isAbsolute(sourceRoot) && util$1.isAbsolute(source)
|
? util$1.relative(sourceRoot, source)
|
: source;
|
});
|
|
// Pass `true` below to allow duplicate names and sources. While source maps
|
// are intended to be compressed and deduplicated, the TypeScript compiler
|
// sometimes generates source maps with duplicates in them. See Github issue
|
// #72 and bugzil.la/889492.
|
this._names = ArraySet.fromArray(names.map(String), true);
|
this._sources = ArraySet.fromArray(sources, true);
|
|
this._absoluteSources = this._sources.toArray().map(function (s) {
|
return util$1.computeSourceURL(sourceRoot, s, aSourceMapURL);
|
});
|
|
this.sourceRoot = sourceRoot;
|
this.sourcesContent = sourcesContent;
|
this._mappings = mappings;
|
this._sourceMapURL = aSourceMapURL;
|
this.file = file;
|
}
|
|
BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer$1.prototype);
|
BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer$1;
|
|
/**
|
* Utility function to find the index of a source. Returns -1 if not
|
* found.
|
*/
|
BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
|
var relativeSource = aSource;
|
if (this.sourceRoot != null) {
|
relativeSource = util$1.relative(this.sourceRoot, relativeSource);
|
}
|
|
if (this._sources.has(relativeSource)) {
|
return this._sources.indexOf(relativeSource);
|
}
|
|
// Maybe aSource is an absolute URL as returned by |sources|. In
|
// this case we can't simply undo the transform.
|
var i;
|
for (i = 0; i < this._absoluteSources.length; ++i) {
|
if (this._absoluteSources[i] == aSource) {
|
return i;
|
}
|
}
|
|
return -1;
|
};
|
|
/**
|
* Create a BasicSourceMapConsumer from a SourceMapGenerator.
|
*
|
* @param SourceMapGenerator aSourceMap
|
* The source map that will be consumed.
|
* @param String aSourceMapURL
|
* The URL at which the source map can be found (optional)
|
* @returns BasicSourceMapConsumer
|
*/
|
BasicSourceMapConsumer.fromSourceMap =
|
function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
|
var smc = Object.create(BasicSourceMapConsumer.prototype);
|
|
var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
|
var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
|
smc.sourceRoot = aSourceMap._sourceRoot;
|
smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(),
|
smc.sourceRoot);
|
smc.file = aSourceMap._file;
|
smc._sourceMapURL = aSourceMapURL;
|
smc._absoluteSources = smc._sources.toArray().map(function (s) {
|
return util$1.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
|
});
|
|
// Because we are modifying the entries (by converting string sources and
|
// names to indices into the sources and names ArraySets), we have to make
|
// a copy of the entry or else bad things happen. Shared mutable state
|
// strikes again! See github issue #191.
|
|
var generatedMappings = aSourceMap._mappings.toArray().slice();
|
var destGeneratedMappings = smc.__generatedMappings = [];
|
var destOriginalMappings = smc.__originalMappings = [];
|
|
for (var i = 0, length = generatedMappings.length; i < length; i++) {
|
var srcMapping = generatedMappings[i];
|
var destMapping = new Mapping;
|
destMapping.generatedLine = srcMapping.generatedLine;
|
destMapping.generatedColumn = srcMapping.generatedColumn;
|
|
if (srcMapping.source) {
|
destMapping.source = sources.indexOf(srcMapping.source);
|
destMapping.originalLine = srcMapping.originalLine;
|
destMapping.originalColumn = srcMapping.originalColumn;
|
|
if (srcMapping.name) {
|
destMapping.name = names.indexOf(srcMapping.name);
|
}
|
|
destOriginalMappings.push(destMapping);
|
}
|
|
destGeneratedMappings.push(destMapping);
|
}
|
|
quickSort(smc.__originalMappings, util$1.compareByOriginalPositions);
|
|
return smc;
|
};
|
|
/**
|
* The version of the source mapping spec that we are consuming.
|
*/
|
BasicSourceMapConsumer.prototype._version = 3;
|
|
/**
|
* The list of original sources.
|
*/
|
Object.defineProperty(BasicSourceMapConsumer.prototype, 'sources', {
|
get: function () {
|
return this._absoluteSources.slice();
|
}
|
});
|
|
/**
|
* Provide the JIT with a nice shape / hidden class.
|
*/
|
function Mapping() {
|
this.generatedLine = 0;
|
this.generatedColumn = 0;
|
this.source = null;
|
this.originalLine = null;
|
this.originalColumn = null;
|
this.name = null;
|
}
|
|
/**
|
* Parse the mappings in a string in to a data structure which we can easily
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
* `this.__originalMappings` properties).
|
*/
|
BasicSourceMapConsumer.prototype._parseMappings =
|
function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
var generatedLine = 1;
|
var previousGeneratedColumn = 0;
|
var previousOriginalLine = 0;
|
var previousOriginalColumn = 0;
|
var previousSource = 0;
|
var previousName = 0;
|
var length = aStr.length;
|
var index = 0;
|
var cachedSegments = {};
|
var temp = {};
|
var originalMappings = [];
|
var generatedMappings = [];
|
var mapping, str, segment, end, value;
|
|
while (index < length) {
|
if (aStr.charAt(index) === ';') {
|
generatedLine++;
|
index++;
|
previousGeneratedColumn = 0;
|
}
|
else if (aStr.charAt(index) === ',') {
|
index++;
|
}
|
else {
|
mapping = new Mapping();
|
mapping.generatedLine = generatedLine;
|
|
// Because each offset is encoded relative to the previous one,
|
// many segments often have the same encoding. We can exploit this
|
// fact by caching the parsed variable length fields of each segment,
|
// allowing us to avoid a second parse if we encounter the same
|
// segment again.
|
for (end = index; end < length; end++) {
|
if (this._charIsMappingSeparator(aStr, end)) {
|
break;
|
}
|
}
|
str = aStr.slice(index, end);
|
|
segment = cachedSegments[str];
|
if (segment) {
|
index += str.length;
|
} else {
|
segment = [];
|
while (index < end) {
|
base64VLQ.decode(aStr, index, temp);
|
value = temp.value;
|
index = temp.rest;
|
segment.push(value);
|
}
|
|
if (segment.length === 2) {
|
throw new Error('Found a source, but no line and column');
|
}
|
|
if (segment.length === 3) {
|
throw new Error('Found a source and line, but no column');
|
}
|
|
cachedSegments[str] = segment;
|
}
|
|
// Generated column.
|
mapping.generatedColumn = previousGeneratedColumn + segment[0];
|
previousGeneratedColumn = mapping.generatedColumn;
|
|
if (segment.length > 1) {
|
// Original source.
|
mapping.source = previousSource + segment[1];
|
previousSource += segment[1];
|
|
// Original line.
|
mapping.originalLine = previousOriginalLine + segment[2];
|
previousOriginalLine = mapping.originalLine;
|
// Lines are stored 0-based
|
mapping.originalLine += 1;
|
|
// Original column.
|
mapping.originalColumn = previousOriginalColumn + segment[3];
|
previousOriginalColumn = mapping.originalColumn;
|
|
if (segment.length > 4) {
|
// Original name.
|
mapping.name = previousName + segment[4];
|
previousName += segment[4];
|
}
|
}
|
|
generatedMappings.push(mapping);
|
if (typeof mapping.originalLine === 'number') {
|
originalMappings.push(mapping);
|
}
|
}
|
}
|
|
quickSort(generatedMappings, util$1.compareByGeneratedPositionsDeflated);
|
this.__generatedMappings = generatedMappings;
|
|
quickSort(originalMappings, util$1.compareByOriginalPositions);
|
this.__originalMappings = originalMappings;
|
};
|
|
/**
|
* Find the mapping that best matches the hypothetical "needle" mapping that
|
* we are searching for in the given "haystack" of mappings.
|
*/
|
BasicSourceMapConsumer.prototype._findMapping =
|
function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName,
|
aColumnName, aComparator, aBias) {
|
// To return the position we are searching for, we must first find the
|
// mapping for the given position and then return the opposite position it
|
// points to. Because the mappings are sorted, we can use binary search to
|
// find the best mapping.
|
|
if (aNeedle[aLineName] <= 0) {
|
throw new TypeError('Line must be greater than or equal to 1, got '
|
+ aNeedle[aLineName]);
|
}
|
if (aNeedle[aColumnName] < 0) {
|
throw new TypeError('Column must be greater than or equal to 0, got '
|
+ aNeedle[aColumnName]);
|
}
|
|
return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
|
};
|
|
/**
|
* Compute the last column for each generated mapping. The last column is
|
* inclusive.
|
*/
|
BasicSourceMapConsumer.prototype.computeColumnSpans =
|
function SourceMapConsumer_computeColumnSpans() {
|
for (var index = 0; index < this._generatedMappings.length; ++index) {
|
var mapping = this._generatedMappings[index];
|
|
// Mappings do not contain a field for the last generated columnt. We
|
// can come up with an optimistic estimate, however, by assuming that
|
// mappings are contiguous (i.e. given two consecutive mappings, the
|
// first mapping ends where the second one starts).
|
if (index + 1 < this._generatedMappings.length) {
|
var nextMapping = this._generatedMappings[index + 1];
|
|
if (mapping.generatedLine === nextMapping.generatedLine) {
|
mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
|
continue;
|
}
|
}
|
|
// The last mapping for each line spans the entire line.
|
mapping.lastGeneratedColumn = Infinity;
|
}
|
};
|
|
/**
|
* Returns the original source, line, and column information for the generated
|
* source's line and column positions provided. The only argument is an object
|
* with the following properties:
|
*
|
* - line: The line number in the generated source. The line number
|
* is 1-based.
|
* - column: The column number in the generated source. The column
|
* number is 0-based.
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - source: The original source file, or null.
|
* - line: The line number in the original source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the original source, or null. The
|
* column number is 0-based.
|
* - name: The original identifier, or null.
|
*/
|
BasicSourceMapConsumer.prototype.originalPositionFor =
|
function SourceMapConsumer_originalPositionFor(aArgs) {
|
var needle = {
|
generatedLine: util$1.getArg(aArgs, 'line'),
|
generatedColumn: util$1.getArg(aArgs, 'column')
|
};
|
|
var index = this._findMapping(
|
needle,
|
this._generatedMappings,
|
"generatedLine",
|
"generatedColumn",
|
util$1.compareByGeneratedPositionsDeflated,
|
util$1.getArg(aArgs, 'bias', SourceMapConsumer$1.GREATEST_LOWER_BOUND)
|
);
|
|
if (index >= 0) {
|
var mapping = this._generatedMappings[index];
|
|
if (mapping.generatedLine === needle.generatedLine) {
|
var source = util$1.getArg(mapping, 'source', null);
|
if (source !== null) {
|
source = this._sources.at(source);
|
source = util$1.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
|
}
|
var name = util$1.getArg(mapping, 'name', null);
|
if (name !== null) {
|
name = this._names.at(name);
|
}
|
return {
|
source: source,
|
line: util$1.getArg(mapping, 'originalLine', null),
|
column: util$1.getArg(mapping, 'originalColumn', null),
|
name: name
|
};
|
}
|
}
|
|
return {
|
source: null,
|
line: null,
|
column: null,
|
name: null
|
};
|
};
|
|
/**
|
* Return true if we have the source content for every source in the source
|
* map, false otherwise.
|
*/
|
BasicSourceMapConsumer.prototype.hasContentsOfAllSources =
|
function BasicSourceMapConsumer_hasContentsOfAllSources() {
|
if (!this.sourcesContent) {
|
return false;
|
}
|
return this.sourcesContent.length >= this._sources.size() &&
|
!this.sourcesContent.some(function (sc) { return sc == null; });
|
};
|
|
/**
|
* Returns the original source content. The only argument is the url of the
|
* original source file. Returns null if no original source content is
|
* available.
|
*/
|
BasicSourceMapConsumer.prototype.sourceContentFor =
|
function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
|
if (!this.sourcesContent) {
|
return null;
|
}
|
|
var index = this._findSourceIndex(aSource);
|
if (index >= 0) {
|
return this.sourcesContent[index];
|
}
|
|
var relativeSource = aSource;
|
if (this.sourceRoot != null) {
|
relativeSource = util$1.relative(this.sourceRoot, relativeSource);
|
}
|
|
var url;
|
if (this.sourceRoot != null
|
&& (url = util$1.urlParse(this.sourceRoot))) {
|
// XXX: file:// URIs and absolute paths lead to unexpected behavior for
|
// many users. We can help them out when they expect file:// URIs to
|
// behave like it would if they were running a local HTTP server. See
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
|
var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
|
if (url.scheme == "file"
|
&& this._sources.has(fileUriAbsPath)) {
|
return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
|
}
|
|
if ((!url.path || url.path == "/")
|
&& this._sources.has("/" + relativeSource)) {
|
return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
|
}
|
}
|
|
// This function is used recursively from
|
// IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
|
// don't want to throw if we can't find the source - we just want to
|
// return null, so we provide a flag to exit gracefully.
|
if (nullOnMissing) {
|
return null;
|
}
|
else {
|
throw new Error('"' + relativeSource + '" is not in the SourceMap.');
|
}
|
};
|
|
/**
|
* Returns the generated line and column information for the original source,
|
* line, and column positions provided. The only argument is an object with
|
* the following properties:
|
*
|
* - source: The filename of the original source.
|
* - line: The line number in the original source. The line number
|
* is 1-based.
|
* - column: The column number in the original source. The column
|
* number is 0-based.
|
* - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
|
* 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
|
* closest element that is smaller than or greater than the one we are
|
* searching for, respectively, if the exact element cannot be found.
|
* Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - line: The line number in the generated source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the generated source, or null.
|
* The column number is 0-based.
|
*/
|
BasicSourceMapConsumer.prototype.generatedPositionFor =
|
function SourceMapConsumer_generatedPositionFor(aArgs) {
|
var source = util$1.getArg(aArgs, 'source');
|
source = this._findSourceIndex(source);
|
if (source < 0) {
|
return {
|
line: null,
|
column: null,
|
lastColumn: null
|
};
|
}
|
|
var needle = {
|
source: source,
|
originalLine: util$1.getArg(aArgs, 'line'),
|
originalColumn: util$1.getArg(aArgs, 'column')
|
};
|
|
var index = this._findMapping(
|
needle,
|
this._originalMappings,
|
"originalLine",
|
"originalColumn",
|
util$1.compareByOriginalPositions,
|
util$1.getArg(aArgs, 'bias', SourceMapConsumer$1.GREATEST_LOWER_BOUND)
|
);
|
|
if (index >= 0) {
|
var mapping = this._originalMappings[index];
|
|
if (mapping.source === needle.source) {
|
return {
|
line: util$1.getArg(mapping, 'generatedLine', null),
|
column: util$1.getArg(mapping, 'generatedColumn', null),
|
lastColumn: util$1.getArg(mapping, 'lastGeneratedColumn', null)
|
};
|
}
|
}
|
|
return {
|
line: null,
|
column: null,
|
lastColumn: null
|
};
|
};
|
|
sourceMapConsumer.BasicSourceMapConsumer = BasicSourceMapConsumer;
|
|
/**
|
* An IndexedSourceMapConsumer instance represents a parsed source map which
|
* we can query for information. It differs from BasicSourceMapConsumer in
|
* that it takes "indexed" source maps (i.e. ones with a "sections" field) as
|
* input.
|
*
|
* The first parameter is a raw source map (either as a JSON string, or already
|
* parsed to an object). According to the spec for indexed source maps, they
|
* have the following attributes:
|
*
|
* - version: Which version of the source map spec this map is following.
|
* - file: Optional. The generated file this source map is associated with.
|
* - sections: A list of section definitions.
|
*
|
* Each value under the "sections" field has two fields:
|
* - offset: The offset into the original specified at which this section
|
* begins to apply, defined as an object with a "line" and "column"
|
* field.
|
* - map: A source map definition. This source map could also be indexed,
|
* but doesn't have to be.
|
*
|
* Instead of the "map" field, it's also possible to have a "url" field
|
* specifying a URL to retrieve a source map from, but that's currently
|
* unsupported.
|
*
|
* Here's an example source map, taken from the source map spec[0], but
|
* modified to omit a section which uses the "url" field.
|
*
|
* {
|
* version : 3,
|
* file: "app.js",
|
* sections: [{
|
* offset: {line:100, column:10},
|
* map: {
|
* version : 3,
|
* file: "section.js",
|
* sources: ["foo.js", "bar.js"],
|
* names: ["src", "maps", "are", "fun"],
|
* mappings: "AAAA,E;;ABCDE;"
|
* }
|
* }],
|
* }
|
*
|
* The second parameter, if given, is a string whose value is the URL
|
* at which the source map was found. This URL is used to compute the
|
* sources array.
|
*
|
* [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
|
*/
|
function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
|
var sourceMap = aSourceMap;
|
if (typeof aSourceMap === 'string') {
|
sourceMap = util$1.parseSourceMapInput(aSourceMap);
|
}
|
|
var version = util$1.getArg(sourceMap, 'version');
|
var sections = util$1.getArg(sourceMap, 'sections');
|
|
if (version != this._version) {
|
throw new Error('Unsupported version: ' + version);
|
}
|
|
this._sources = new ArraySet();
|
this._names = new ArraySet();
|
|
var lastOffset = {
|
line: -1,
|
column: 0
|
};
|
this._sections = sections.map(function (s) {
|
if (s.url) {
|
// The url field will require support for asynchronicity.
|
// See https://github.com/mozilla/source-map/issues/16
|
throw new Error('Support for url field in sections not implemented.');
|
}
|
var offset = util$1.getArg(s, 'offset');
|
var offsetLine = util$1.getArg(offset, 'line');
|
var offsetColumn = util$1.getArg(offset, 'column');
|
|
if (offsetLine < lastOffset.line ||
|
(offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
|
throw new Error('Section offsets must be ordered and non-overlapping.');
|
}
|
lastOffset = offset;
|
|
return {
|
generatedOffset: {
|
// The offset fields are 0-based, but we use 1-based indices when
|
// encoding/decoding from VLQ.
|
generatedLine: offsetLine + 1,
|
generatedColumn: offsetColumn + 1
|
},
|
consumer: new SourceMapConsumer$1(util$1.getArg(s, 'map'), aSourceMapURL)
|
}
|
});
|
}
|
|
IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer$1.prototype);
|
IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer$1;
|
|
/**
|
* The version of the source mapping spec that we are consuming.
|
*/
|
IndexedSourceMapConsumer.prototype._version = 3;
|
|
/**
|
* The list of original sources.
|
*/
|
Object.defineProperty(IndexedSourceMapConsumer.prototype, 'sources', {
|
get: function () {
|
var sources = [];
|
for (var i = 0; i < this._sections.length; i++) {
|
for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
|
sources.push(this._sections[i].consumer.sources[j]);
|
}
|
}
|
return sources;
|
}
|
});
|
|
/**
|
* Returns the original source, line, and column information for the generated
|
* source's line and column positions provided. The only argument is an object
|
* with the following properties:
|
*
|
* - line: The line number in the generated source. The line number
|
* is 1-based.
|
* - column: The column number in the generated source. The column
|
* number is 0-based.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - source: The original source file, or null.
|
* - line: The line number in the original source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the original source, or null. The
|
* column number is 0-based.
|
* - name: The original identifier, or null.
|
*/
|
IndexedSourceMapConsumer.prototype.originalPositionFor =
|
function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
|
var needle = {
|
generatedLine: util$1.getArg(aArgs, 'line'),
|
generatedColumn: util$1.getArg(aArgs, 'column')
|
};
|
|
// Find the section containing the generated position we're trying to map
|
// to an original position.
|
var sectionIndex = binarySearch.search(needle, this._sections,
|
function(needle, section) {
|
var cmp = needle.generatedLine - section.generatedOffset.generatedLine;
|
if (cmp) {
|
return cmp;
|
}
|
|
return (needle.generatedColumn -
|
section.generatedOffset.generatedColumn);
|
});
|
var section = this._sections[sectionIndex];
|
|
if (!section) {
|
return {
|
source: null,
|
line: null,
|
column: null,
|
name: null
|
};
|
}
|
|
return section.consumer.originalPositionFor({
|
line: needle.generatedLine -
|
(section.generatedOffset.generatedLine - 1),
|
column: needle.generatedColumn -
|
(section.generatedOffset.generatedLine === needle.generatedLine
|
? section.generatedOffset.generatedColumn - 1
|
: 0),
|
bias: aArgs.bias
|
});
|
};
|
|
/**
|
* Return true if we have the source content for every source in the source
|
* map, false otherwise.
|
*/
|
IndexedSourceMapConsumer.prototype.hasContentsOfAllSources =
|
function IndexedSourceMapConsumer_hasContentsOfAllSources() {
|
return this._sections.every(function (s) {
|
return s.consumer.hasContentsOfAllSources();
|
});
|
};
|
|
/**
|
* Returns the original source content. The only argument is the url of the
|
* original source file. Returns null if no original source content is
|
* available.
|
*/
|
IndexedSourceMapConsumer.prototype.sourceContentFor =
|
function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
|
for (var i = 0; i < this._sections.length; i++) {
|
var section = this._sections[i];
|
|
var content = section.consumer.sourceContentFor(aSource, true);
|
if (content) {
|
return content;
|
}
|
}
|
if (nullOnMissing) {
|
return null;
|
}
|
else {
|
throw new Error('"' + aSource + '" is not in the SourceMap.');
|
}
|
};
|
|
/**
|
* Returns the generated line and column information for the original source,
|
* line, and column positions provided. The only argument is an object with
|
* the following properties:
|
*
|
* - source: The filename of the original source.
|
* - line: The line number in the original source. The line number
|
* is 1-based.
|
* - column: The column number in the original source. The column
|
* number is 0-based.
|
*
|
* and an object is returned with the following properties:
|
*
|
* - line: The line number in the generated source, or null. The
|
* line number is 1-based.
|
* - column: The column number in the generated source, or null.
|
* The column number is 0-based.
|
*/
|
IndexedSourceMapConsumer.prototype.generatedPositionFor =
|
function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
|
for (var i = 0; i < this._sections.length; i++) {
|
var section = this._sections[i];
|
|
// Only consider this section if the requested source is in the list of
|
// sources of the consumer.
|
if (section.consumer._findSourceIndex(util$1.getArg(aArgs, 'source')) === -1) {
|
continue;
|
}
|
var generatedPosition = section.consumer.generatedPositionFor(aArgs);
|
if (generatedPosition) {
|
var ret = {
|
line: generatedPosition.line +
|
(section.generatedOffset.generatedLine - 1),
|
column: generatedPosition.column +
|
(section.generatedOffset.generatedLine === generatedPosition.line
|
? section.generatedOffset.generatedColumn - 1
|
: 0)
|
};
|
return ret;
|
}
|
}
|
|
return {
|
line: null,
|
column: null
|
};
|
};
|
|
/**
|
* Parse the mappings in a string in to a data structure which we can easily
|
* query (the ordered arrays in the `this.__generatedMappings` and
|
* `this.__originalMappings` properties).
|
*/
|
IndexedSourceMapConsumer.prototype._parseMappings =
|
function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
|
this.__generatedMappings = [];
|
this.__originalMappings = [];
|
for (var i = 0; i < this._sections.length; i++) {
|
var section = this._sections[i];
|
var sectionMappings = section.consumer._generatedMappings;
|
for (var j = 0; j < sectionMappings.length; j++) {
|
var mapping = sectionMappings[j];
|
|
var source = section.consumer._sources.at(mapping.source);
|
source = util$1.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
|
this._sources.add(source);
|
source = this._sources.indexOf(source);
|
|
var name = null;
|
if (mapping.name) {
|
name = section.consumer._names.at(mapping.name);
|
this._names.add(name);
|
name = this._names.indexOf(name);
|
}
|
|
// The mappings coming from the consumer for the section have
|
// generated positions relative to the start of the section, so we
|
// need to offset them to be relative to the start of the concatenated
|
// generated file.
|
var adjustedMapping = {
|
source: source,
|
generatedLine: mapping.generatedLine +
|
(section.generatedOffset.generatedLine - 1),
|
generatedColumn: mapping.generatedColumn +
|
(section.generatedOffset.generatedLine === mapping.generatedLine
|
? section.generatedOffset.generatedColumn - 1
|
: 0),
|
originalLine: mapping.originalLine,
|
originalColumn: mapping.originalColumn,
|
name: name
|
};
|
|
this.__generatedMappings.push(adjustedMapping);
|
if (typeof adjustedMapping.originalLine === 'number') {
|
this.__originalMappings.push(adjustedMapping);
|
}
|
}
|
}
|
|
quickSort(this.__generatedMappings, util$1.compareByGeneratedPositionsDeflated);
|
quickSort(this.__originalMappings, util$1.compareByOriginalPositions);
|
};
|
|
sourceMapConsumer.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
|
|
var sourceNode = {};
|
|
/* -*- Mode: js; js-indent-level: 2; -*- */
|
|
/*
|
* Copyright 2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
var SourceMapGenerator$1 = sourceMapGenerator.SourceMapGenerator;
|
var util = util$5;
|
|
// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
|
// operating systems these days (capturing the result).
|
var REGEX_NEWLINE = /(\r?\n)/;
|
|
// Newline character code for charCodeAt() comparisons
|
var NEWLINE_CODE = 10;
|
|
// Private symbol for identifying `SourceNode`s when multiple versions of
|
// the source-map library are loaded. This MUST NOT CHANGE across
|
// versions!
|
var isSourceNode = "$$$isSourceNode$$$";
|
|
/**
|
* SourceNodes provide a way to abstract over interpolating/concatenating
|
* snippets of generated JavaScript source code while maintaining the line and
|
* column information associated with the original source code.
|
*
|
* @param aLine The original line number.
|
* @param aColumn The original column number.
|
* @param aSource The original source's filename.
|
* @param aChunks Optional. An array of strings which are snippets of
|
* generated JS, or other SourceNodes.
|
* @param aName The original identifier.
|
*/
|
function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
|
this.children = [];
|
this.sourceContents = {};
|
this.line = aLine == null ? null : aLine;
|
this.column = aColumn == null ? null : aColumn;
|
this.source = aSource == null ? null : aSource;
|
this.name = aName == null ? null : aName;
|
this[isSourceNode] = true;
|
if (aChunks != null) this.add(aChunks);
|
}
|
|
/**
|
* Creates a SourceNode from generated code and a SourceMapConsumer.
|
*
|
* @param aGeneratedCode The generated code
|
* @param aSourceMapConsumer The SourceMap for the generated code
|
* @param aRelativePath Optional. The path that relative sources in the
|
* SourceMapConsumer should be relative to.
|
*/
|
SourceNode.fromStringWithSourceMap =
|
function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
|
// The SourceNode we want to fill with the generated code
|
// and the SourceMap
|
var node = new SourceNode();
|
|
// All even indices of this array are one line of the generated code,
|
// while all odd indices are the newlines between two adjacent lines
|
// (since `REGEX_NEWLINE` captures its match).
|
// Processed fragments are accessed by calling `shiftNextLine`.
|
var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
|
var remainingLinesIndex = 0;
|
var shiftNextLine = function() {
|
var lineContents = getNextLine();
|
// The last line of a file might not have a newline.
|
var newLine = getNextLine() || "";
|
return lineContents + newLine;
|
|
function getNextLine() {
|
return remainingLinesIndex < remainingLines.length ?
|
remainingLines[remainingLinesIndex++] : undefined;
|
}
|
};
|
|
// We need to remember the position of "remainingLines"
|
var lastGeneratedLine = 1, lastGeneratedColumn = 0;
|
|
// The generate SourceNodes we need a code range.
|
// To extract it current and last mapping is used.
|
// Here we store the last mapping.
|
var lastMapping = null;
|
|
aSourceMapConsumer.eachMapping(function (mapping) {
|
if (lastMapping !== null) {
|
// We add the code from "lastMapping" to "mapping":
|
// First check if there is a new line in between.
|
if (lastGeneratedLine < mapping.generatedLine) {
|
// Associate first line with "lastMapping"
|
addMappingWithCode(lastMapping, shiftNextLine());
|
lastGeneratedLine++;
|
lastGeneratedColumn = 0;
|
// The remaining code is added without mapping
|
} else {
|
// There is no new line in between.
|
// Associate the code between "lastGeneratedColumn" and
|
// "mapping.generatedColumn" with "lastMapping"
|
var nextLine = remainingLines[remainingLinesIndex] || '';
|
var code = nextLine.substr(0, mapping.generatedColumn -
|
lastGeneratedColumn);
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
|
lastGeneratedColumn);
|
lastGeneratedColumn = mapping.generatedColumn;
|
addMappingWithCode(lastMapping, code);
|
// No more remaining code, continue
|
lastMapping = mapping;
|
return;
|
}
|
}
|
// We add the generated code until the first mapping
|
// to the SourceNode without any mapping.
|
// Each line is added as separate string.
|
while (lastGeneratedLine < mapping.generatedLine) {
|
node.add(shiftNextLine());
|
lastGeneratedLine++;
|
}
|
if (lastGeneratedColumn < mapping.generatedColumn) {
|
var nextLine = remainingLines[remainingLinesIndex] || '';
|
node.add(nextLine.substr(0, mapping.generatedColumn));
|
remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
|
lastGeneratedColumn = mapping.generatedColumn;
|
}
|
lastMapping = mapping;
|
}, this);
|
// We have processed all mappings.
|
if (remainingLinesIndex < remainingLines.length) {
|
if (lastMapping) {
|
// Associate the remaining code in the current line with "lastMapping"
|
addMappingWithCode(lastMapping, shiftNextLine());
|
}
|
// and add the remaining lines without any mapping
|
node.add(remainingLines.splice(remainingLinesIndex).join(""));
|
}
|
|
// Copy sourcesContent into SourceNode
|
aSourceMapConsumer.sources.forEach(function (sourceFile) {
|
var content = aSourceMapConsumer.sourceContentFor(sourceFile);
|
if (content != null) {
|
if (aRelativePath != null) {
|
sourceFile = util.join(aRelativePath, sourceFile);
|
}
|
node.setSourceContent(sourceFile, content);
|
}
|
});
|
|
return node;
|
|
function addMappingWithCode(mapping, code) {
|
if (mapping === null || mapping.source === undefined) {
|
node.add(code);
|
} else {
|
var source = aRelativePath
|
? util.join(aRelativePath, mapping.source)
|
: mapping.source;
|
node.add(new SourceNode(mapping.originalLine,
|
mapping.originalColumn,
|
source,
|
code,
|
mapping.name));
|
}
|
}
|
};
|
|
/**
|
* Add a chunk of generated JS to this source node.
|
*
|
* @param aChunk A string snippet of generated JS code, another instance of
|
* SourceNode, or an array where each member is one of those things.
|
*/
|
SourceNode.prototype.add = function SourceNode_add(aChunk) {
|
if (Array.isArray(aChunk)) {
|
aChunk.forEach(function (chunk) {
|
this.add(chunk);
|
}, this);
|
}
|
else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
if (aChunk) {
|
this.children.push(aChunk);
|
}
|
}
|
else {
|
throw new TypeError(
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
);
|
}
|
return this;
|
};
|
|
/**
|
* Add a chunk of generated JS to the beginning of this source node.
|
*
|
* @param aChunk A string snippet of generated JS code, another instance of
|
* SourceNode, or an array where each member is one of those things.
|
*/
|
SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
|
if (Array.isArray(aChunk)) {
|
for (var i = aChunk.length-1; i >= 0; i--) {
|
this.prepend(aChunk[i]);
|
}
|
}
|
else if (aChunk[isSourceNode] || typeof aChunk === "string") {
|
this.children.unshift(aChunk);
|
}
|
else {
|
throw new TypeError(
|
"Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
|
);
|
}
|
return this;
|
};
|
|
/**
|
* Walk over the tree of JS snippets in this node and its children. The
|
* walking function is called once for each snippet of JS and is passed that
|
* snippet and the its original associated source's line/column location.
|
*
|
* @param aFn The traversal function.
|
*/
|
SourceNode.prototype.walk = function SourceNode_walk(aFn) {
|
var chunk;
|
for (var i = 0, len = this.children.length; i < len; i++) {
|
chunk = this.children[i];
|
if (chunk[isSourceNode]) {
|
chunk.walk(aFn);
|
}
|
else {
|
if (chunk !== '') {
|
aFn(chunk, { source: this.source,
|
line: this.line,
|
column: this.column,
|
name: this.name });
|
}
|
}
|
}
|
};
|
|
/**
|
* Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
|
* each of `this.children`.
|
*
|
* @param aSep The separator.
|
*/
|
SourceNode.prototype.join = function SourceNode_join(aSep) {
|
var newChildren;
|
var i;
|
var len = this.children.length;
|
if (len > 0) {
|
newChildren = [];
|
for (i = 0; i < len-1; i++) {
|
newChildren.push(this.children[i]);
|
newChildren.push(aSep);
|
}
|
newChildren.push(this.children[i]);
|
this.children = newChildren;
|
}
|
return this;
|
};
|
|
/**
|
* Call String.prototype.replace on the very right-most source snippet. Useful
|
* for trimming whitespace from the end of a source node, etc.
|
*
|
* @param aPattern The pattern to replace.
|
* @param aReplacement The thing to replace the pattern with.
|
*/
|
SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
|
var lastChild = this.children[this.children.length - 1];
|
if (lastChild[isSourceNode]) {
|
lastChild.replaceRight(aPattern, aReplacement);
|
}
|
else if (typeof lastChild === 'string') {
|
this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
|
}
|
else {
|
this.children.push(''.replace(aPattern, aReplacement));
|
}
|
return this;
|
};
|
|
/**
|
* Set the source content for a source file. This will be added to the SourceMapGenerator
|
* in the sourcesContent field.
|
*
|
* @param aSourceFile The filename of the source file
|
* @param aSourceContent The content of the source file
|
*/
|
SourceNode.prototype.setSourceContent =
|
function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
|
this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
|
};
|
|
/**
|
* Walk over the tree of SourceNodes. The walking function is called for each
|
* source file content and is passed the filename and source content.
|
*
|
* @param aFn The traversal function.
|
*/
|
SourceNode.prototype.walkSourceContents =
|
function SourceNode_walkSourceContents(aFn) {
|
for (var i = 0, len = this.children.length; i < len; i++) {
|
if (this.children[i][isSourceNode]) {
|
this.children[i].walkSourceContents(aFn);
|
}
|
}
|
|
var sources = Object.keys(this.sourceContents);
|
for (var i = 0, len = sources.length; i < len; i++) {
|
aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
|
}
|
};
|
|
/**
|
* Return the string representation of this source node. Walks over the tree
|
* and concatenates all the various snippets together to one string.
|
*/
|
SourceNode.prototype.toString = function SourceNode_toString() {
|
var str = "";
|
this.walk(function (chunk) {
|
str += chunk;
|
});
|
return str;
|
};
|
|
/**
|
* Returns the string representation of this source node along with a source
|
* map.
|
*/
|
SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
|
var generated = {
|
code: "",
|
line: 1,
|
column: 0
|
};
|
var map = new SourceMapGenerator$1(aArgs);
|
var sourceMappingActive = false;
|
var lastOriginalSource = null;
|
var lastOriginalLine = null;
|
var lastOriginalColumn = null;
|
var lastOriginalName = null;
|
this.walk(function (chunk, original) {
|
generated.code += chunk;
|
if (original.source !== null
|
&& original.line !== null
|
&& original.column !== null) {
|
if(lastOriginalSource !== original.source
|
|| lastOriginalLine !== original.line
|
|| lastOriginalColumn !== original.column
|
|| lastOriginalName !== original.name) {
|
map.addMapping({
|
source: original.source,
|
original: {
|
line: original.line,
|
column: original.column
|
},
|
generated: {
|
line: generated.line,
|
column: generated.column
|
},
|
name: original.name
|
});
|
}
|
lastOriginalSource = original.source;
|
lastOriginalLine = original.line;
|
lastOriginalColumn = original.column;
|
lastOriginalName = original.name;
|
sourceMappingActive = true;
|
} else if (sourceMappingActive) {
|
map.addMapping({
|
generated: {
|
line: generated.line,
|
column: generated.column
|
}
|
});
|
lastOriginalSource = null;
|
sourceMappingActive = false;
|
}
|
for (var idx = 0, length = chunk.length; idx < length; idx++) {
|
if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
|
generated.line++;
|
generated.column = 0;
|
// Mappings end at eol
|
if (idx + 1 === length) {
|
lastOriginalSource = null;
|
sourceMappingActive = false;
|
} else if (sourceMappingActive) {
|
map.addMapping({
|
source: original.source,
|
original: {
|
line: original.line,
|
column: original.column
|
},
|
generated: {
|
line: generated.line,
|
column: generated.column
|
},
|
name: original.name
|
});
|
}
|
} else {
|
generated.column++;
|
}
|
}
|
});
|
this.walkSourceContents(function (sourceFile, sourceContent) {
|
map.setSourceContent(sourceFile, sourceContent);
|
});
|
|
return { code: generated.code, map: map };
|
};
|
|
sourceNode.SourceNode = SourceNode;
|
|
/*
|
* Copyright 2009-2011 Mozilla Foundation and contributors
|
* Licensed under the New BSD license. See LICENSE.txt or:
|
* http://opensource.org/licenses/BSD-3-Clause
|
*/
|
|
sourceMap$1.SourceMapGenerator = sourceMapGenerator.SourceMapGenerator;
|
sourceMap$1.SourceMapConsumer = sourceMapConsumer.SourceMapConsumer;
|
sourceMap$1.SourceNode = sourceNode.SourceNode;
|
|
var sourceMap = sourceMap$1;
|
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())
|
}
|
|
var merge$1 = mergeSourceMap;
|
|
var __defProp$5 = Object.defineProperty;
|
var __defProps$5 = Object.defineProperties;
|
var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$5 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$5.call(b, prop))
|
__defNormalProp$5(a, prop, b[prop]);
|
if (__getOwnPropSymbols$5)
|
for (var prop of __getOwnPropSymbols$5(b)) {
|
if (__propIsEnum$5.call(b, prop))
|
__defNormalProp$5(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
|
const scss = (source, map, options, load = require) => {
|
const nodeSass = load("sass");
|
const finalOptions = __spreadProps$5(__spreadValues$5({}, 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: merge$1(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, load) => scss(
|
source,
|
map,
|
__spreadProps$5(__spreadValues$5({}, options), {
|
indentedSyntax: true
|
}),
|
load
|
);
|
const less = (source, map, options, load = require) => {
|
const nodeLess = load("less");
|
let result;
|
let error = null;
|
nodeLess.render(
|
getSource(source, options.filename, options.additionalData),
|
__spreadProps$5(__spreadValues$5({}, 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: merge$1(map, result.map),
|
errors: [],
|
dependencies
|
};
|
}
|
return {
|
code: result.css.toString(),
|
errors: [],
|
dependencies
|
};
|
};
|
const styl = (source, map, options, load = require) => {
|
const nodeStylus = load("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: merge$1(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$1(additionalData)) {
|
return additionalData(source, filename);
|
}
|
return additionalData + source;
|
}
|
const processors = {
|
less,
|
sass,
|
scss,
|
styl,
|
stylus: styl
|
};
|
|
var __defProp$4 = Object.defineProperty;
|
var __defProps$4 = Object.defineProperties;
|
var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$4 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$4.call(b, prop))
|
__defNormalProp$4(a, prop, b[prop]);
|
if (__getOwnPropSymbols$4)
|
for (var prop of __getOwnPropSymbols$4(b)) {
|
if (__propIsEnum$4.call(b, prop))
|
__defNormalProp$4(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
|
function compileStyle(options) {
|
return doCompileStyle(__spreadProps$4(__spreadValues$4({}, options), {
|
isAsync: false
|
}));
|
}
|
function compileStyleAsync(options) {
|
return doCompileStyle(__spreadProps$4(__spreadValues$4({}, options), {
|
isAsync: true
|
}));
|
}
|
function doCompileStyle(options) {
|
const {
|
filename,
|
id,
|
scoped = false,
|
trim = true,
|
isProd = false,
|
modules = false,
|
modulesOptions = {},
|
preprocessLang,
|
postcssOptions,
|
postcssPlugins
|
} = options;
|
const preprocessor = preprocessLang && processors[preprocessLang];
|
const preProcessedSource = preprocessor && preprocess(options, preprocessor);
|
const map = preProcessedSource ? preProcessedSource.map : options.inMap || options.map;
|
const source = preProcessedSource ? preProcessedSource.code : options.source;
|
const shortId = id.replace(/^data-v-/, "");
|
const longId = `data-v-${shortId}`;
|
const plugins = (postcssPlugins || []).slice();
|
plugins.unshift(cssVarsPlugin({ id: shortId, isProd }));
|
if (trim) {
|
plugins.push(trimPlugin$1());
|
}
|
if (scoped) {
|
plugins.push(scopedPlugin$1(longId));
|
}
|
let cssModules;
|
if (modules) {
|
{
|
throw new Error(
|
"[@vue/compiler-sfc] `modules` option is not supported in the browser build."
|
);
|
}
|
}
|
const postCSSOptions = __spreadProps$4(__spreadValues$4({}, postcssOptions), {
|
to: filename,
|
from: filename
|
});
|
if (map) {
|
postCSSOptions.map = {
|
inline: false,
|
annotation: false,
|
prev: map
|
};
|
}
|
let result;
|
let code;
|
let outMap;
|
const dependencies = new Set(
|
preProcessedSource ? preProcessedSource.dependencies : []
|
);
|
dependencies.delete(filename);
|
const errors = [];
|
if (preProcessedSource && preProcessedSource.errors.length) {
|
errors.push(...preProcessedSource.errors);
|
}
|
const recordPlainCssDependencies = (messages) => {
|
messages.forEach((msg) => {
|
if (msg.type === "dependency") {
|
dependencies.add(msg.file);
|
}
|
});
|
return dependencies;
|
};
|
try {
|
result = postcss$1(plugins).process(source, postCSSOptions);
|
if (options.isAsync) {
|
return result.then((result2) => ({
|
code: result2.css || "",
|
map: result2.map && result2.map.toJSON(),
|
errors,
|
modules: cssModules,
|
rawResult: result2,
|
dependencies: recordPlainCssDependencies(result2.messages)
|
})).catch((error) => ({
|
code: "",
|
map: void 0,
|
errors: [...errors, error],
|
rawResult: void 0,
|
dependencies
|
}));
|
}
|
recordPlainCssDependencies(result.messages);
|
code = result.css;
|
outMap = result.map;
|
} catch (e) {
|
errors.push(e);
|
}
|
return {
|
code: code || ``,
|
map: outMap && outMap.toJSON(),
|
errors,
|
rawResult: result,
|
dependencies
|
};
|
}
|
function preprocess(options, preprocessor) {
|
if (!options.preprocessCustomRequire) {
|
throw new Error(
|
`[@vue/compiler-sfc] Style preprocessing in the browser build must provide the \`preprocessCustomRequire\` option to return the in-browser version of the preprocessor.`
|
);
|
}
|
return preprocessor(
|
options.source,
|
options.inMap || options.map,
|
__spreadValues$4({
|
filename: options.filename
|
}, options.preprocessOptions),
|
options.preprocessCustomRequire
|
);
|
}
|
|
const comma = ','.charCodeAt(0);
|
const semicolon = ';'.charCodeAt(0);
|
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
const intToChar = new Uint8Array(64); // 64 possible chars.
|
const charToInt = new Uint8Array(128); // z is 122 in ASCII
|
for (let i = 0; i < chars.length; i++) {
|
const c = chars.charCodeAt(i);
|
intToChar[i] = c;
|
charToInt[c] = i;
|
}
|
// Provide a fallback for older environments.
|
const td = typeof TextDecoder !== 'undefined'
|
? /* #__PURE__ */ new TextDecoder()
|
: typeof Buffer !== 'undefined'
|
? {
|
decode(buf) {
|
const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
|
return out.toString();
|
},
|
}
|
: {
|
decode(buf) {
|
let out = '';
|
for (let i = 0; i < buf.length; i++) {
|
out += String.fromCharCode(buf[i]);
|
}
|
return out;
|
},
|
};
|
function encode(decoded) {
|
const state = new Int32Array(5);
|
const bufLength = 1024 * 16;
|
const subLength = bufLength - 36;
|
const buf = new Uint8Array(bufLength);
|
const sub = buf.subarray(0, subLength);
|
let pos = 0;
|
let out = '';
|
for (let i = 0; i < decoded.length; i++) {
|
const line = decoded[i];
|
if (i > 0) {
|
if (pos === bufLength) {
|
out += td.decode(buf);
|
pos = 0;
|
}
|
buf[pos++] = semicolon;
|
}
|
if (line.length === 0)
|
continue;
|
state[0] = 0;
|
for (let j = 0; j < line.length; j++) {
|
const segment = line[j];
|
// We can push up to 5 ints, each int can take at most 7 chars, and we
|
// may push a comma.
|
if (pos > subLength) {
|
out += td.decode(sub);
|
buf.copyWithin(0, subLength, pos);
|
pos -= subLength;
|
}
|
if (j > 0)
|
buf[pos++] = comma;
|
pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
|
if (segment.length === 1)
|
continue;
|
pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
|
pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
|
pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
|
if (segment.length === 4)
|
continue;
|
pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
|
}
|
}
|
return out + td.decode(buf.subarray(0, pos));
|
}
|
function encodeInteger(buf, pos, state, segment, j) {
|
const next = segment[j];
|
let num = next - state[j];
|
state[j] = next;
|
num = num < 0 ? (-num << 1) | 1 : num << 1;
|
do {
|
let clamped = num & 0b011111;
|
num >>>= 5;
|
if (num > 0)
|
clamped |= 0b100000;
|
buf[pos++] = intToChar[clamped];
|
} while (num > 0);
|
return pos;
|
}
|
|
class BitSet {
|
constructor(arg) {
|
this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
|
}
|
|
add(n) {
|
this.bits[n >> 5] |= 1 << (n & 31);
|
}
|
|
has(n) {
|
return !!(this.bits[n >> 5] & (1 << (n & 31)));
|
}
|
}
|
|
class Chunk {
|
constructor(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;
|
|
{
|
this.previous = null;
|
this.next = null;
|
}
|
}
|
|
appendLeft(content) {
|
this.outro += content;
|
}
|
|
appendRight(content) {
|
this.intro = this.intro + content;
|
}
|
|
clone() {
|
const 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;
|
}
|
|
contains(index) {
|
return this.start < index && index < this.end;
|
}
|
|
eachNext(fn) {
|
let chunk = this;
|
while (chunk) {
|
fn(chunk);
|
chunk = chunk.next;
|
}
|
}
|
|
eachPrevious(fn) {
|
let chunk = this;
|
while (chunk) {
|
fn(chunk);
|
chunk = chunk.previous;
|
}
|
}
|
|
edit(content, storeName, contentOnly) {
|
this.content = content;
|
if (!contentOnly) {
|
this.intro = '';
|
this.outro = '';
|
}
|
this.storeName = storeName;
|
|
this.edited = true;
|
|
return this;
|
}
|
|
prependLeft(content) {
|
this.outro = content + this.outro;
|
}
|
|
prependRight(content) {
|
this.intro = content + this.intro;
|
}
|
|
split(index) {
|
const sliceIndex = index - this.start;
|
|
const originalBefore = this.original.slice(0, sliceIndex);
|
const originalAfter = this.original.slice(sliceIndex);
|
|
this.original = originalBefore;
|
|
const 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;
|
}
|
|
toString() {
|
return this.intro + this.content + this.outro;
|
}
|
|
trimEnd(rx) {
|
this.outro = this.outro.replace(rx, '');
|
if (this.outro.length) return true;
|
|
const 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;
|
}
|
}
|
|
trimStart(rx) {
|
this.intro = this.intro.replace(rx, '');
|
if (this.intro.length) return true;
|
|
const 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;
|
}
|
}
|
}
|
|
function getBtoa () {
|
if (typeof window !== 'undefined' && typeof window.btoa === 'function') {
|
return (str) => window.btoa(unescape(encodeURIComponent(str)));
|
} else if (typeof Buffer === 'function') {
|
return (str) => Buffer.from(str, 'utf-8').toString('base64');
|
} else {
|
return () => {
|
throw new Error('Unsupported environment: `window.btoa` or `Buffer` should be supported.');
|
};
|
}
|
}
|
|
const btoa = /*#__PURE__*/ getBtoa();
|
|
class SourceMap {
|
constructor(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);
|
if (typeof properties.x_google_ignoreList !== 'undefined') {
|
this.x_google_ignoreList = properties.x_google_ignoreList;
|
}
|
}
|
|
toString() {
|
return JSON.stringify(this);
|
}
|
|
toUrl() {
|
return 'data:application/json;charset=utf-8;base64,' + btoa(this.toString());
|
}
|
}
|
|
function guessIndent(code) {
|
const lines = code.split('\n');
|
|
const tabbed = lines.filter((line) => /^\t+/.test(line));
|
const spaced = lines.filter((line) => /^ {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
|
const min = spaced.reduce((previous, current) => {
|
const numSpaces = /^ +/.exec(current)[0].length;
|
return Math.min(numSpaces, previous);
|
}, Infinity);
|
|
return new Array(min + 1).join(' ');
|
}
|
|
function getRelativePath(from, to) {
|
const fromParts = from.split(/[/\\]/);
|
const toParts = to.split(/[/\\]/);
|
|
fromParts.pop(); // get dirname
|
|
while (fromParts[0] === toParts[0]) {
|
fromParts.shift();
|
toParts.shift();
|
}
|
|
if (fromParts.length) {
|
let i = fromParts.length;
|
while (i--) fromParts[i] = '..';
|
}
|
|
return fromParts.concat(toParts).join('/');
|
}
|
|
const toString = Object.prototype.toString;
|
|
function isObject(thing) {
|
return toString.call(thing) === '[object Object]';
|
}
|
|
function getLocator(source) {
|
const originalLines = source.split('\n');
|
const lineOffsets = [];
|
|
for (let i = 0, pos = 0; i < originalLines.length; i++) {
|
lineOffsets.push(pos);
|
pos += originalLines[i].length + 1;
|
}
|
|
return function locate(index) {
|
let i = 0;
|
let j = lineOffsets.length;
|
while (i < j) {
|
const m = (i + j) >> 1;
|
if (index < lineOffsets[m]) {
|
j = m;
|
} else {
|
i = m + 1;
|
}
|
}
|
const line = i - 1;
|
const column = index - lineOffsets[line];
|
return { line, column };
|
};
|
}
|
|
class Mappings {
|
constructor(hires) {
|
this.hires = hires;
|
this.generatedCodeLine = 0;
|
this.generatedCodeColumn = 0;
|
this.raw = [];
|
this.rawSegments = this.raw[this.generatedCodeLine] = [];
|
this.pending = null;
|
}
|
|
addEdit(sourceIndex, content, loc, nameIndex) {
|
if (content.length) {
|
const 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;
|
}
|
|
addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
|
let originalCharIndex = chunk.start;
|
let 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;
|
}
|
|
advance(str) {
|
if (!str) return;
|
|
const lines = str.split('\n');
|
|
if (lines.length > 1) {
|
for (let 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;
|
}
|
}
|
|
const n = '\n';
|
|
const warned = {
|
insertLeft: false,
|
insertRight: false,
|
storeName: false,
|
};
|
|
class MagicString {
|
constructor(string, options = {}) {
|
const 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: undefined },
|
ignoreList: { writable: true, value: options.ignoreList },
|
});
|
|
this.byStart[0] = chunk;
|
this.byEnd[string.length] = chunk;
|
}
|
|
addSourcemapLocation(char) {
|
this.sourcemapLocations.add(char);
|
}
|
|
append(content) {
|
if (typeof content !== 'string') throw new TypeError('outro content must be a string');
|
|
this.outro += content;
|
return this;
|
}
|
|
appendLeft(index, content) {
|
if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
|
|
this._split(index);
|
|
const chunk = this.byEnd[index];
|
|
if (chunk) {
|
chunk.appendLeft(content);
|
} else {
|
this.intro += content;
|
}
|
return this;
|
}
|
|
appendRight(index, content) {
|
if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
|
|
this._split(index);
|
|
const chunk = this.byStart[index];
|
|
if (chunk) {
|
chunk.appendRight(content);
|
} else {
|
this.outro += content;
|
}
|
return this;
|
}
|
|
clone() {
|
const cloned = new MagicString(this.original, { filename: this.filename });
|
|
let originalChunk = this.firstChunk;
|
let clonedChunk = (cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone());
|
|
while (originalChunk) {
|
cloned.byStart[clonedChunk.start] = clonedChunk;
|
cloned.byEnd[clonedChunk.end] = clonedChunk;
|
|
const nextOriginalChunk = originalChunk.next;
|
const 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;
|
}
|
|
generateDecodedMap(options) {
|
options = options || {};
|
|
const sourceIndex = 0;
|
const names = Object.keys(this.storedNames);
|
const mappings = new Mappings(options.hires);
|
|
const locate = getLocator(this.original);
|
|
if (this.intro) {
|
mappings.advance(this.intro);
|
}
|
|
this.firstChunk.eachNext((chunk) => {
|
const 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.original, loc, this.sourcemapLocations);
|
}
|
|
if (chunk.outro.length) mappings.advance(chunk.outro);
|
});
|
|
return {
|
file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
|
sources: [options.source ? getRelativePath(options.file || '', options.source) : (options.file || '')],
|
sourcesContent: options.includeContent ? [this.original] : undefined,
|
names,
|
mappings: mappings.raw,
|
x_google_ignoreList: this.ignoreList ? [sourceIndex] : undefined
|
};
|
}
|
|
generateMap(options) {
|
return new SourceMap(this.generateDecodedMap(options));
|
}
|
|
_ensureindentStr() {
|
if (this.indentStr === undefined) {
|
this.indentStr = guessIndent(this.original);
|
}
|
}
|
|
_getRawIndentString() {
|
this._ensureindentStr();
|
return this.indentStr;
|
}
|
|
getIndentString() {
|
this._ensureindentStr();
|
return this.indentStr === null ? '\t' : this.indentStr;
|
}
|
|
indent(indentStr, options) {
|
const pattern = /^[^\r\n]/gm;
|
|
if (isObject(indentStr)) {
|
options = indentStr;
|
indentStr = undefined;
|
}
|
|
if (indentStr === undefined) {
|
this._ensureindentStr();
|
indentStr = this.indentStr || '\t';
|
}
|
|
if (indentStr === '') return this; // noop
|
|
options = options || {};
|
|
// Process exclusion ranges
|
const isExcluded = {};
|
|
if (options.exclude) {
|
const exclusions =
|
typeof options.exclude[0] === 'number' ? [options.exclude] : options.exclude;
|
exclusions.forEach((exclusion) => {
|
for (let i = exclusion[0]; i < exclusion[1]; i += 1) {
|
isExcluded[i] = true;
|
}
|
});
|
}
|
|
let shouldIndentNextCharacter = options.indentStart !== false;
|
const replacer = (match) => {
|
if (shouldIndentNextCharacter) return `${indentStr}${match}`;
|
shouldIndentNextCharacter = true;
|
return match;
|
};
|
|
this.intro = this.intro.replace(pattern, replacer);
|
|
let charIndex = 0;
|
let chunk = this.firstChunk;
|
|
while (chunk) {
|
const 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]) {
|
const 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;
|
}
|
|
insert() {
|
throw new Error(
|
'magicString.insert(...) is deprecated. Use prependRight(...) or appendLeft(...)'
|
);
|
}
|
|
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);
|
}
|
|
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);
|
}
|
|
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);
|
|
const first = this.byStart[start];
|
const last = this.byEnd[end];
|
|
const oldLeft = first.previous;
|
const oldRight = last.next;
|
|
const newRight = this.byStart[index];
|
if (!newRight && last === this.lastChunk) return this;
|
const 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;
|
}
|
|
overwrite(start, end, content, options) {
|
options = options || {};
|
return this.update(start, end, content, { ...options, overwrite: !options.contentOnly });
|
}
|
|
update(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 };
|
}
|
const storeName = options !== undefined ? options.storeName : false;
|
const overwrite = options !== undefined ? options.overwrite : false;
|
|
if (storeName) {
|
const original = this.original.slice(start, end);
|
Object.defineProperty(this.storedNames, original, {
|
writable: true,
|
value: true,
|
enumerable: true,
|
});
|
}
|
|
const first = this.byStart[start];
|
const last = this.byEnd[end];
|
|
if (first) {
|
let 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, !overwrite);
|
} else {
|
// must be inserting at the end
|
const 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;
|
}
|
|
prepend(content) {
|
if (typeof content !== 'string') throw new TypeError('outro content must be a string');
|
|
this.intro = content + this.intro;
|
return this;
|
}
|
|
prependLeft(index, content) {
|
if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
|
|
this._split(index);
|
|
const chunk = this.byEnd[index];
|
|
if (chunk) {
|
chunk.prependLeft(content);
|
} else {
|
this.intro = content + this.intro;
|
}
|
return this;
|
}
|
|
prependRight(index, content) {
|
if (typeof content !== 'string') throw new TypeError('inserted content must be a string');
|
|
this._split(index);
|
|
const chunk = this.byStart[index];
|
|
if (chunk) {
|
chunk.prependRight(content);
|
} else {
|
this.outro = content + this.outro;
|
}
|
return this;
|
}
|
|
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);
|
|
let chunk = this.byStart[start];
|
|
while (chunk) {
|
chunk.intro = '';
|
chunk.outro = '';
|
chunk.edit('');
|
|
chunk = end > chunk.end ? this.byStart[chunk.end] : null;
|
}
|
return this;
|
}
|
|
lastChar() {
|
if (this.outro.length) return this.outro[this.outro.length - 1];
|
let 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 '';
|
}
|
|
lastLine() {
|
let lineIndex = this.outro.lastIndexOf(n);
|
if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
|
let lineStr = this.outro;
|
let 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;
|
}
|
|
slice(start = 0, end = this.original.length) {
|
while (start < 0) start += this.original.length;
|
while (end < 0) end += this.original.length;
|
|
let result = '';
|
|
// find start chunk
|
let 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.`);
|
|
const startChunk = chunk;
|
while (chunk) {
|
if (chunk.intro && (startChunk !== chunk || chunk.start === start)) {
|
result += chunk.intro;
|
}
|
|
const 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.`);
|
|
const sliceStart = startChunk === chunk ? start - chunk.start : 0;
|
const 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
|
snip(start, end) {
|
const clone = this.clone();
|
clone.remove(0, start);
|
clone.remove(end, clone.original.length);
|
|
return clone;
|
}
|
|
_split(index) {
|
if (this.byStart[index] || this.byEnd[index]) return;
|
|
let chunk = this.lastSearchedChunk;
|
const 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];
|
}
|
}
|
|
_splitChunk(chunk, index) {
|
if (chunk.edited && chunk.content.length) {
|
// zero-length edited chunks are a special case (overlapping replacements)
|
const loc = getLocator(this.original)(index);
|
throw new Error(
|
`Cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`
|
);
|
}
|
|
const 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;
|
}
|
|
toString() {
|
let str = this.intro;
|
|
let chunk = this.firstChunk;
|
while (chunk) {
|
str += chunk.toString();
|
chunk = chunk.next;
|
}
|
|
return str + this.outro;
|
}
|
|
isEmpty() {
|
let 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;
|
}
|
|
length() {
|
let chunk = this.firstChunk;
|
let length = 0;
|
do {
|
length += chunk.intro.length + chunk.content.length + chunk.outro.length;
|
} while ((chunk = chunk.next));
|
return length;
|
}
|
|
trimLines() {
|
return this.trim('[\\r\\n]');
|
}
|
|
trim(charType) {
|
return this.trimStart(charType).trimEnd(charType);
|
}
|
|
trimEndAborted(charType) {
|
const rx = new RegExp((charType || '\\s') + '+$');
|
|
this.outro = this.outro.replace(rx, '');
|
if (this.outro.length) return true;
|
|
let chunk = this.lastChunk;
|
|
do {
|
const end = chunk.end;
|
const 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;
|
}
|
|
trimEnd(charType) {
|
this.trimEndAborted(charType);
|
return this;
|
}
|
trimStartAborted(charType) {
|
const rx = new RegExp('^' + (charType || '\\s') + '+');
|
|
this.intro = this.intro.replace(rx, '');
|
if (this.intro.length) return true;
|
|
let chunk = this.firstChunk;
|
|
do {
|
const end = chunk.end;
|
const 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;
|
}
|
|
trimStart(charType) {
|
this.trimStartAborted(charType);
|
return this;
|
}
|
|
hasChanged() {
|
return this.original !== this.toString();
|
}
|
|
_replaceRegexp(searchValue, replacement) {
|
function getReplacement(match, str) {
|
if (typeof replacement === 'string') {
|
return replacement.replace(/\$(\$|&|\d+)/g, (_, i) => {
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
|
if (i === '$') return '$';
|
if (i === '&') return match[0];
|
const num = +i;
|
if (num < match.length) return match[+i];
|
return `$${i}`;
|
});
|
} else {
|
return replacement(...match, match.index, str, match.groups);
|
}
|
}
|
function matchAll(re, str) {
|
let match;
|
const matches = [];
|
while ((match = re.exec(str))) {
|
matches.push(match);
|
}
|
return matches;
|
}
|
if (searchValue.global) {
|
const matches = matchAll(searchValue, this.original);
|
matches.forEach((match) => {
|
if (match.index != null)
|
this.overwrite(
|
match.index,
|
match.index + match[0].length,
|
getReplacement(match, this.original)
|
);
|
});
|
} else {
|
const match = this.original.match(searchValue);
|
if (match && match.index != null)
|
this.overwrite(
|
match.index,
|
match.index + match[0].length,
|
getReplacement(match, this.original)
|
);
|
}
|
return this;
|
}
|
|
_replaceString(string, replacement) {
|
const { original } = this;
|
const index = original.indexOf(string);
|
|
if (index !== -1) {
|
this.overwrite(index, index + string.length, replacement);
|
}
|
|
return this;
|
}
|
|
replace(searchValue, replacement) {
|
if (typeof searchValue === 'string') {
|
return this._replaceString(searchValue, replacement);
|
}
|
|
return this._replaceRegexp(searchValue, replacement);
|
}
|
|
_replaceAllString(string, replacement) {
|
const { original } = this;
|
const stringLength = string.length;
|
for (
|
let index = original.indexOf(string);
|
index !== -1;
|
index = original.indexOf(string, index + stringLength)
|
) {
|
this.overwrite(index, index + stringLength, replacement);
|
}
|
|
return this;
|
}
|
|
replaceAll(searchValue, replacement) {
|
if (typeof searchValue === 'string') {
|
return this._replaceAllString(searchValue, replacement);
|
}
|
|
if (!searchValue.global) {
|
throw new TypeError(
|
'MagicString.prototype.replaceAll called with a non-global RegExp argument'
|
);
|
}
|
|
return this._replaceRegexp(searchValue, replacement);
|
}
|
}
|
|
var __defProp$3 = Object.defineProperty;
|
var __defProps$3 = Object.defineProperties;
|
var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$3 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$3.call(b, prop))
|
__defNormalProp$3(a, prop, b[prop]);
|
if (__getOwnPropSymbols$3)
|
for (var prop of __getOwnPropSymbols$3(b)) {
|
if (__propIsEnum$3.call(b, prop))
|
__defNormalProp$3(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
|
const CONVERT_SYMBOL = "$";
|
const ESCAPE_SYMBOL = "$$";
|
const IMPORT_SOURCE = "vue/macros";
|
const shorthands = ["ref", "computed", "shallowRef", "toRef", "customRef"];
|
const transformCheckRE = /[^\w]\$(?:\$|ref|computed|shallowRef)?\s*(\(|\<)/;
|
function shouldTransform(src) {
|
return transformCheckRE.test(src);
|
}
|
function transform(src, {
|
filename,
|
sourceMap,
|
parserPlugins,
|
importHelpersFrom = "vue"
|
} = {}) {
|
const plugins = parserPlugins || [];
|
if (filename) {
|
if (/\.tsx?$/.test(filename)) {
|
plugins.push("typescript");
|
}
|
if (filename.endsWith("x")) {
|
plugins.push("jsx");
|
}
|
}
|
const ast = parse_1$1(src, {
|
sourceType: "module",
|
plugins
|
});
|
const s = new MagicString(src);
|
const res = transformAST(ast.program, s, 0);
|
if (res.importedHelpers.length) {
|
s.prepend(
|
`import { ${res.importedHelpers.map((h) => `${h} as _${h}`).join(", ")} } from '${importHelpersFrom}'
|
`
|
);
|
}
|
return __spreadProps$3(__spreadValues$3({}, res), {
|
code: s.toString(),
|
map: sourceMap ? s.generateMap({
|
source: filename,
|
hires: true,
|
includeContent: true
|
}) : null
|
});
|
}
|
function transformAST(ast, s, offset = 0, knownRefs, knownProps) {
|
warnExperimental();
|
const userImports = /* @__PURE__ */ Object.create(null);
|
for (const node of ast.body) {
|
if (node.type !== "ImportDeclaration")
|
continue;
|
walkImportDeclaration(node);
|
}
|
let convertSymbol;
|
let escapeSymbol;
|
for (const { local, imported, source, specifier } of Object.values(
|
userImports
|
)) {
|
if (source === IMPORT_SOURCE) {
|
if (imported === ESCAPE_SYMBOL) {
|
escapeSymbol = local;
|
} else if (imported === CONVERT_SYMBOL) {
|
convertSymbol = local;
|
} else if (imported !== local) {
|
error(
|
`macro imports for ref-creating methods do not support aliasing.`,
|
specifier
|
);
|
}
|
}
|
}
|
if (!convertSymbol && !userImports[CONVERT_SYMBOL]) {
|
convertSymbol = CONVERT_SYMBOL;
|
}
|
if (!escapeSymbol && !userImports[ESCAPE_SYMBOL]) {
|
escapeSymbol = ESCAPE_SYMBOL;
|
}
|
const importedHelpers = /* @__PURE__ */ new Set();
|
const rootScope = {};
|
const scopeStack = [rootScope];
|
let currentScope = rootScope;
|
let escapeScope;
|
const excludedIds = /* @__PURE__ */ new WeakSet();
|
const parentStack = [];
|
const propsLocalToPublicMap = /* @__PURE__ */ Object.create(null);
|
if (knownRefs) {
|
for (const key of knownRefs) {
|
rootScope[key] = {};
|
}
|
}
|
if (knownProps) {
|
for (const key in knownProps) {
|
const { local, isConst } = knownProps[key];
|
rootScope[local] = {
|
isProp: true,
|
isConst: !!isConst
|
};
|
propsLocalToPublicMap[local] = key;
|
}
|
}
|
function walkImportDeclaration(node) {
|
const source = node.source.value;
|
if (source === IMPORT_SOURCE) {
|
s.remove(node.start + offset, node.end + offset);
|
}
|
for (const specifier of node.specifiers) {
|
const local = specifier.local.name;
|
const imported = specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name || "default";
|
userImports[local] = {
|
source,
|
local,
|
imported,
|
specifier
|
};
|
}
|
}
|
function isRefCreationCall(callee) {
|
if (!convertSymbol || currentScope[convertSymbol] !== void 0) {
|
return false;
|
}
|
if (callee === convertSymbol) {
|
return convertSymbol;
|
}
|
if (callee[0] === "$" && shorthands.includes(callee.slice(1))) {
|
return callee;
|
}
|
return false;
|
}
|
function error(msg, node) {
|
const e = new Error(msg);
|
e.node = node;
|
throw e;
|
}
|
function helper(msg) {
|
importedHelpers.add(msg);
|
return `_${msg}`;
|
}
|
function registerBinding(id, binding) {
|
excludedIds.add(id);
|
if (currentScope) {
|
currentScope[id.name] = binding ? binding : false;
|
} else {
|
error(
|
"registerBinding called without active scope, something is wrong.",
|
id
|
);
|
}
|
}
|
const registerRefBinding = (id, isConst = false) => registerBinding(id, { isConst });
|
let tempVarCount = 0;
|
function genTempVar() {
|
return `__$temp_${++tempVarCount}`;
|
}
|
function snip(node) {
|
return s.original.slice(node.start + offset, node.end + offset);
|
}
|
function walkScope(node, isRoot = false) {
|
for (const stmt of node.body) {
|
if (stmt.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt, isRoot);
|
} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
|
if (stmt.declare || !stmt.id)
|
continue;
|
registerBinding(stmt.id);
|
} else if ((stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") && stmt.left.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt.left);
|
} else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && stmt.declaration.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt.declaration, isRoot);
|
} else if (stmt.type === "LabeledStatement" && stmt.body.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt.body, isRoot);
|
}
|
}
|
}
|
function walkVariableDeclaration(stmt, isRoot = false) {
|
if (stmt.declare) {
|
return;
|
}
|
for (const decl of stmt.declarations) {
|
let refCall;
|
const isCall = decl.init && decl.init.type === "CallExpression" && decl.init.callee.type === "Identifier";
|
if (isCall && (refCall = isRefCreationCall(decl.init.callee.name))) {
|
processRefDeclaration(
|
refCall,
|
decl.id,
|
decl.init,
|
stmt.kind === "const"
|
);
|
} else {
|
const isProps = isRoot && isCall && decl.init.callee.name === "defineProps";
|
for (const id of extractIdentifiers(decl.id)) {
|
if (isProps) {
|
excludedIds.add(id);
|
} else {
|
registerBinding(id);
|
}
|
}
|
}
|
}
|
}
|
function processRefDeclaration(method, id, call, isConst) {
|
excludedIds.add(call.callee);
|
if (method === convertSymbol) {
|
s.remove(call.callee.start + offset, call.callee.end + offset);
|
if (id.type === "Identifier") {
|
registerRefBinding(id, isConst);
|
} else if (id.type === "ObjectPattern") {
|
processRefObjectPattern(id, call, isConst);
|
} else if (id.type === "ArrayPattern") {
|
processRefArrayPattern(id, call, isConst);
|
}
|
} else {
|
if (id.type === "Identifier") {
|
registerRefBinding(id, isConst);
|
s.overwrite(
|
call.start + offset,
|
call.start + method.length + offset,
|
helper(method.slice(1))
|
);
|
} else {
|
error(`${method}() cannot be used with destructure patterns.`, call);
|
}
|
}
|
}
|
function processRefObjectPattern(pattern, call, isConst, tempVar, path = []) {
|
if (!tempVar) {
|
tempVar = genTempVar();
|
s.overwrite(pattern.start + offset, pattern.end + offset, tempVar);
|
}
|
let nameId;
|
for (const p of pattern.properties) {
|
let key;
|
let defaultValue;
|
if (p.type === "ObjectProperty") {
|
if (p.key.start === p.value.start) {
|
nameId = p.key;
|
if (p.value.type === "Identifier") {
|
excludedIds.add(p.value);
|
} else if (p.value.type === "AssignmentPattern" && p.value.left.type === "Identifier") {
|
excludedIds.add(p.value.left);
|
defaultValue = p.value.right;
|
}
|
} else {
|
key = p.computed ? p.key : p.key.name;
|
if (p.value.type === "Identifier") {
|
nameId = p.value;
|
} else if (p.value.type === "ObjectPattern") {
|
processRefObjectPattern(p.value, call, isConst, tempVar, [
|
...path,
|
key
|
]);
|
} else if (p.value.type === "ArrayPattern") {
|
processRefArrayPattern(p.value, call, isConst, tempVar, [
|
...path,
|
key
|
]);
|
} else if (p.value.type === "AssignmentPattern") {
|
if (p.value.left.type === "Identifier") {
|
nameId = p.value.left;
|
defaultValue = p.value.right;
|
} else if (p.value.left.type === "ObjectPattern") {
|
processRefObjectPattern(p.value.left, call, isConst, tempVar, [
|
...path,
|
[key, p.value.right]
|
]);
|
} else if (p.value.left.type === "ArrayPattern") {
|
processRefArrayPattern(p.value.left, call, isConst, tempVar, [
|
...path,
|
[key, p.value.right]
|
]);
|
} else ;
|
}
|
}
|
} else {
|
error(`reactivity destructure does not support rest elements.`, p);
|
}
|
if (nameId) {
|
registerRefBinding(nameId, isConst);
|
const source = pathToString(tempVar, path);
|
const keyStr = isString$2(key) ? `'${key}'` : key ? snip(key) : `'${nameId.name}'`;
|
const defaultStr = defaultValue ? `, ${snip(defaultValue)}` : ``;
|
s.appendLeft(
|
call.end + offset,
|
`,
|
${nameId.name} = ${helper(
|
"toRef"
|
)}(${source}, ${keyStr}${defaultStr})`
|
);
|
}
|
}
|
if (nameId) {
|
s.appendLeft(call.end + offset, ";");
|
}
|
}
|
function processRefArrayPattern(pattern, call, isConst, tempVar, path = []) {
|
if (!tempVar) {
|
tempVar = genTempVar();
|
s.overwrite(pattern.start + offset, pattern.end + offset, tempVar);
|
}
|
let nameId;
|
for (let i = 0; i < pattern.elements.length; i++) {
|
const e = pattern.elements[i];
|
if (!e)
|
continue;
|
let defaultValue;
|
if (e.type === "Identifier") {
|
nameId = e;
|
} else if (e.type === "AssignmentPattern") {
|
nameId = e.left;
|
defaultValue = e.right;
|
} else if (e.type === "RestElement") {
|
error(`reactivity destructure does not support rest elements.`, e);
|
} else if (e.type === "ObjectPattern") {
|
processRefObjectPattern(e, call, isConst, tempVar, [...path, i]);
|
} else if (e.type === "ArrayPattern") {
|
processRefArrayPattern(e, call, isConst, tempVar, [...path, i]);
|
}
|
if (nameId) {
|
registerRefBinding(nameId, isConst);
|
const source = pathToString(tempVar, path);
|
const defaultStr = defaultValue ? `, ${snip(defaultValue)}` : ``;
|
s.appendLeft(
|
call.end + offset,
|
`,
|
${nameId.name} = ${helper(
|
"toRef"
|
)}(${source}, ${i}${defaultStr})`
|
);
|
}
|
}
|
if (nameId) {
|
s.appendLeft(call.end + offset, ";");
|
}
|
}
|
function pathToString(source, path) {
|
if (path.length) {
|
for (const seg of path) {
|
if (isArray$3(seg)) {
|
source = `(${source}${segToString(seg[0])} || ${snip(seg[1])})`;
|
} else {
|
source += segToString(seg);
|
}
|
}
|
}
|
return source;
|
}
|
function segToString(seg) {
|
if (typeof seg === "number") {
|
return `[${seg}]`;
|
} else if (typeof seg === "string") {
|
return `.${seg}`;
|
} else {
|
return snip(seg);
|
}
|
}
|
function rewriteId(scope, id, parent, parentStack2) {
|
if (hasOwn(scope, id.name)) {
|
const binding = scope[id.name];
|
if (binding) {
|
if (binding.isConst && (parent.type === "AssignmentExpression" && id === parent.left || parent.type === "UpdateExpression")) {
|
error(`Assignment to constant variable.`, id);
|
}
|
const { isProp } = binding;
|
if (isStaticProperty(parent) && parent.shorthand) {
|
if (!parent.inPattern || isInDestructureAssignment(parent, parentStack2)) {
|
if (isProp) {
|
if (escapeScope) {
|
registerEscapedPropBinding(id);
|
s.appendLeft(
|
id.end + offset,
|
`: __props_${propsLocalToPublicMap[id.name]}`
|
);
|
} else {
|
s.appendLeft(
|
id.end + offset,
|
`: ${genPropsAccessExp(propsLocalToPublicMap[id.name])}`
|
);
|
}
|
} else {
|
s.appendLeft(id.end + offset, `: ${id.name}.value`);
|
}
|
}
|
} else {
|
if (isProp) {
|
if (escapeScope) {
|
registerEscapedPropBinding(id);
|
s.overwrite(
|
id.start + offset,
|
id.end + offset,
|
`__props_${propsLocalToPublicMap[id.name]}`
|
);
|
} else {
|
s.overwrite(
|
id.start + offset,
|
id.end + offset,
|
genPropsAccessExp(propsLocalToPublicMap[id.name])
|
);
|
}
|
} else {
|
s.appendLeft(id.end + offset, ".value");
|
}
|
}
|
}
|
return true;
|
}
|
return false;
|
}
|
const propBindingRefs = {};
|
function registerEscapedPropBinding(id) {
|
if (!propBindingRefs.hasOwnProperty(id.name)) {
|
propBindingRefs[id.name] = true;
|
const publicKey = propsLocalToPublicMap[id.name];
|
s.prependRight(
|
offset,
|
`const __props_${publicKey} = ${helper(
|
`toRef`
|
)}(__props, '${publicKey}');
|
`
|
);
|
}
|
}
|
walkScope(ast, true);
|
walk$1(ast, {
|
enter(node, parent) {
|
parent && parentStack.push(parent);
|
if (isFunctionType(node)) {
|
scopeStack.push(currentScope = {});
|
walkFunctionParams(node, registerBinding);
|
if (node.body.type === "BlockStatement") {
|
walkScope(node.body);
|
}
|
return;
|
}
|
if (node.type === "CatchClause") {
|
scopeStack.push(currentScope = {});
|
if (node.param && node.param.type === "Identifier") {
|
registerBinding(node.param);
|
}
|
walkScope(node.body);
|
return;
|
}
|
if (node.type === "BlockStatement" && !isFunctionType(parent)) {
|
scopeStack.push(currentScope = {});
|
walkScope(node);
|
return;
|
}
|
if (parent && parent.type.startsWith("TS") && parent.type !== "TSAsExpression" && parent.type !== "TSNonNullExpression" && parent.type !== "TSTypeAssertion") {
|
return this.skip();
|
}
|
if (node.type === "Identifier") {
|
const binding = rootScope[node.name];
|
if (
|
// if inside $$(), skip unless this is a destructured prop binding
|
!(escapeScope && (!binding || !binding.isProp)) && isReferencedIdentifier(node, parent, parentStack) && !excludedIds.has(node)
|
) {
|
let i = scopeStack.length;
|
while (i--) {
|
if (rewriteId(scopeStack[i], node, parent, parentStack)) {
|
return;
|
}
|
}
|
}
|
}
|
if (node.type === "CallExpression" && node.callee.type === "Identifier") {
|
const callee = node.callee.name;
|
const refCall = isRefCreationCall(callee);
|
if (refCall && (!parent || parent.type !== "VariableDeclarator")) {
|
return error(
|
`${refCall} can only be used as the initializer of a variable declaration.`,
|
node
|
);
|
}
|
if (escapeSymbol && currentScope[escapeSymbol] === void 0 && callee === escapeSymbol) {
|
escapeScope = node;
|
s.remove(node.callee.start + offset, node.callee.end + offset);
|
if ((parent == null ? void 0 : parent.type) === "ExpressionStatement") {
|
let i = (node.leadingComments ? node.leadingComments[0].start : node.start) + offset;
|
while (i--) {
|
const char = s.original.charAt(i);
|
if (char === "\n") {
|
s.prependRight(node.start + offset, ";");
|
break;
|
} else if (!/\s/.test(char)) {
|
break;
|
}
|
}
|
}
|
}
|
}
|
},
|
leave(node, parent) {
|
parent && parentStack.pop();
|
if (node.type === "BlockStatement" && !isFunctionType(parent) || isFunctionType(node)) {
|
scopeStack.pop();
|
currentScope = scopeStack[scopeStack.length - 1] || null;
|
}
|
if (node === escapeScope) {
|
escapeScope = void 0;
|
}
|
}
|
});
|
return {
|
rootRefs: Object.keys(rootScope).filter((key) => {
|
const binding = rootScope[key];
|
return binding && !binding.isProp;
|
}),
|
importedHelpers: [...importedHelpers]
|
};
|
}
|
const hasWarned = {};
|
function warnExperimental() {
|
if (typeof window !== "undefined") {
|
return;
|
}
|
warnOnce(
|
`Reactivity Transform was an experimental feature and has now been deprecated. It will be removed from Vue core in 3.4. If you intend to continue using it, switch to https://vue-macros.sxzz.moe/features/reactivity-transform.html.
|
See reason for deprecation here: https://github.com/vuejs/rfcs/discussions/369#discussioncomment-5059028`
|
);
|
}
|
function warnOnce(msg) {
|
const isNodeProd = typeof process !== "undefined" && process.env.NODE_ENV === "production";
|
if (!isNodeProd && true && !hasWarned[msg]) {
|
hasWarned[msg] = true;
|
warn(msg);
|
}
|
}
|
function warn(msg) {
|
console.warn(
|
`\x1B[1m\x1B[33m[@vue/reactivity-transform]\x1B[0m\x1B[33m ${msg}\x1B[0m
|
`
|
);
|
}
|
|
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 = {};
|
Object.defineProperty(bindings, "__isScriptSetup", {
|
enumerable: false,
|
value: false
|
});
|
for (const property of node.properties) {
|
if (property.type === "ObjectProperty" && !property.computed && property.key.type === "Identifier") {
|
if (property.key.name === "props") {
|
for (const key of getObjectOrArrayExpressionKeys(property.value)) {
|
bindings[key] = "props";
|
}
|
} else if (property.key.name === "inject") {
|
for (const key of getObjectOrArrayExpressionKeys(property.value)) {
|
bindings[key] = "options";
|
}
|
} else if (property.value.type === "ObjectExpression" && (property.key.name === "computed" || property.key.name === "methods")) {
|
for (const key of getObjectExpressionKeys(property.value)) {
|
bindings[key] = "options";
|
}
|
}
|
} else if (property.type === "ObjectMethod" && property.key.type === "Identifier" && (property.key.name === "setup" || property.key.name === "data")) {
|
for (const bodyItem of property.body.body) {
|
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" : "data";
|
}
|
}
|
}
|
}
|
}
|
return bindings;
|
}
|
function getObjectExpressionKeys(node) {
|
const keys = [];
|
for (const prop of node.properties) {
|
if (prop.type === "SpreadElement")
|
continue;
|
const key = resolveObjectKey(prop.key, prop.computed);
|
if (key)
|
keys.push(String(key));
|
}
|
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 [];
|
}
|
|
function rewriteDefault(input, as, parserPlugins) {
|
const ast = parse_1$1(input, {
|
sourceType: "module",
|
plugins: parserPlugins
|
}).program.body;
|
const s = new MagicString(input);
|
rewriteDefaultAST(ast, s, as);
|
return s.toString();
|
}
|
function rewriteDefaultAST(ast, s, as) {
|
if (!hasDefaultExport(ast)) {
|
s.append(`
|
const ${as} = {}`);
|
return;
|
}
|
ast.forEach((node) => {
|
if (node.type === "ExportDefaultDeclaration") {
|
if (node.declaration.type === "ClassDeclaration") {
|
let start = node.declaration.decorators && node.declaration.decorators.length > 0 ? node.declaration.decorators[node.declaration.decorators.length - 1].end : node.start;
|
s.overwrite(start, node.declaration.id.start, ` class `);
|
s.append(`
|
const ${as} = ${node.declaration.id.name}`);
|
} else {
|
s.overwrite(node.start, node.declaration.start, `const ${as} = `);
|
}
|
} else 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") {
|
s.prepend(
|
`import { default as __VUE_DEFAULT__ } from '${node.source.value}'
|
`
|
);
|
const end2 = specifierEnd(s, specifier.local.end, node.end);
|
s.remove(specifier.start, end2);
|
s.append(`
|
const ${as} = __VUE_DEFAULT__`);
|
continue;
|
} else {
|
s.prepend(
|
`import { ${s.slice(
|
specifier.local.start,
|
specifier.local.end
|
)} as __VUE_DEFAULT__ } from '${node.source.value}'
|
`
|
);
|
const end2 = specifierEnd(s, specifier.exported.end, node.end);
|
s.remove(specifier.start, end2);
|
s.append(`
|
const ${as} = __VUE_DEFAULT__`);
|
continue;
|
}
|
}
|
const end = specifierEnd(s, specifier.end, node.end);
|
s.remove(specifier.start, end);
|
s.append(`
|
const ${as} = ${specifier.local.name}`);
|
}
|
}
|
}
|
});
|
}
|
function hasDefaultExport(ast) {
|
for (const stmt of ast) {
|
if (stmt.type === "ExportDefaultDeclaration") {
|
return true;
|
} else if (stmt.type === "ExportNamedDeclaration" && stmt.specifiers.some(
|
(spec) => spec.exported.name === "default"
|
)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
function specifierEnd(s, end, nodeEnd) {
|
let hasCommas = false;
|
let oldEnd = end;
|
while (end < nodeEnd) {
|
if (/\s/.test(s.slice(end, end + 1))) {
|
end++;
|
} else if (s.slice(end, end + 1) === ",") {
|
end++;
|
hasCommas = true;
|
break;
|
} else if (s.slice(end, end + 1) === "}") {
|
break;
|
}
|
}
|
return hasCommas ? end : oldEnd;
|
}
|
|
var __defProp$2 = Object.defineProperty;
|
var __defProps$2 = Object.defineProperties;
|
var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$2 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$2.call(b, prop))
|
__defNormalProp$2(a, prop, b[prop]);
|
if (__getOwnPropSymbols$2)
|
for (var prop of __getOwnPropSymbols$2(b)) {
|
if (__propIsEnum$2.call(b, prop))
|
__defNormalProp$2(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
|
const normalScriptDefaultVar = `__default__`;
|
function processNormalScript(ctx, scopeId) {
|
const script = ctx.descriptor.script;
|
if (script.lang && !ctx.isJS && !ctx.isTS) {
|
return script;
|
}
|
try {
|
let content = script.content;
|
let map = script.map;
|
const scriptAst = ctx.scriptAst;
|
const bindings = analyzeScriptBindings(scriptAst.body);
|
const { source, filename, cssVars } = ctx.descriptor;
|
const { sourceMap, genDefaultAs, isProd } = ctx.options;
|
if (ctx.options.reactivityTransform && shouldTransform(content)) {
|
const s = new MagicString(source);
|
const startOffset = script.loc.start.offset;
|
const endOffset = script.loc.end.offset;
|
const { importedHelpers } = transformAST(scriptAst, s, startOffset);
|
if (importedHelpers.length) {
|
s.prepend(
|
`import { ${importedHelpers.map((h) => `${h} as _${h}`).join(", ")} } from 'vue'
|
`
|
);
|
}
|
s.remove(0, startOffset);
|
s.remove(endOffset, source.length);
|
content = s.toString();
|
if (sourceMap !== false) {
|
map = s.generateMap({
|
source: filename,
|
hires: true,
|
includeContent: true
|
});
|
}
|
}
|
if (cssVars.length || genDefaultAs) {
|
const defaultVar = genDefaultAs || normalScriptDefaultVar;
|
const s = new MagicString(content);
|
rewriteDefaultAST(scriptAst.body, s, defaultVar);
|
content = s.toString();
|
if (cssVars.length) {
|
content += genNormalScriptCssVarsCode(
|
cssVars,
|
bindings,
|
scopeId,
|
!!isProd,
|
defaultVar
|
);
|
}
|
if (!genDefaultAs) {
|
content += `
|
export default ${defaultVar}`;
|
}
|
}
|
return __spreadProps$2(__spreadValues$2({}, script), {
|
content,
|
map,
|
bindings,
|
scriptAst: scriptAst.body
|
});
|
} catch (e) {
|
return script;
|
}
|
}
|
|
var _a, _b;
|
class ScriptCompileContext {
|
constructor(descriptor, options) {
|
this.descriptor = descriptor;
|
this.options = options;
|
this.source = this.descriptor.source;
|
this.filename = this.descriptor.filename;
|
this.s = new MagicString(this.source);
|
this.startOffset = (_a = this.descriptor.scriptSetup) == null ? void 0 : _a.loc.start.offset;
|
this.endOffset = (_b = this.descriptor.scriptSetup) == null ? void 0 : _b.loc.end.offset;
|
this.userImports = /* @__PURE__ */ Object.create(null);
|
// macros presence check
|
this.hasDefinePropsCall = false;
|
this.hasDefineEmitCall = false;
|
this.hasDefineExposeCall = false;
|
this.hasDefaultExportName = false;
|
this.hasDefaultExportRender = false;
|
this.hasDefineOptionsCall = false;
|
this.hasDefineSlotsCall = false;
|
this.hasDefineModelCall = false;
|
this.propsDestructuredBindings = /* @__PURE__ */ Object.create(null);
|
// defineModel
|
this.modelDecls = {};
|
// codegen
|
this.bindingMetadata = {};
|
this.helperImports = /* @__PURE__ */ new Set();
|
const { script, scriptSetup } = descriptor;
|
const scriptLang = script && script.lang;
|
const scriptSetupLang = scriptSetup && scriptSetup.lang;
|
this.isJS = scriptLang === "js" || scriptLang === "jsx" || scriptSetupLang === "js" || scriptSetupLang === "jsx";
|
this.isTS = scriptLang === "ts" || scriptLang === "tsx" || scriptSetupLang === "ts" || scriptSetupLang === "tsx";
|
const plugins = resolveParserPlugins(
|
scriptLang || scriptSetupLang,
|
options.babelParserPlugins
|
);
|
function parse(input, offset) {
|
try {
|
return parse_1$1(input, {
|
plugins,
|
sourceType: "module"
|
}).program;
|
} catch (e) {
|
e.message = `[vue/compiler-sfc] ${e.message}
|
|
${descriptor.filename}
|
${generateCodeFrame(
|
descriptor.source,
|
e.pos + offset,
|
e.pos + offset + 1
|
)}`;
|
throw e;
|
}
|
}
|
this.scriptAst = descriptor.script && parse(descriptor.script.content, descriptor.script.loc.start.offset);
|
this.scriptSetupAst = descriptor.scriptSetup && parse(descriptor.scriptSetup.content, this.startOffset);
|
}
|
helper(key) {
|
this.helperImports.add(key);
|
return `_${key}`;
|
}
|
getString(node, scriptSetup = true) {
|
const block = scriptSetup ? this.descriptor.scriptSetup : this.descriptor.script;
|
return block.content.slice(node.start, node.end);
|
}
|
error(msg, node, scope) {
|
const offset = scope ? scope.offset : this.startOffset;
|
throw new Error(
|
`[@vue/compiler-sfc] ${msg}
|
|
${(scope || this.descriptor).filename}
|
${generateCodeFrame(
|
(scope || this.descriptor).source,
|
node.start + offset,
|
node.end + offset
|
)}`
|
);
|
}
|
}
|
function resolveParserPlugins(lang, userPlugins, dts = false) {
|
const plugins = [];
|
if (lang === "jsx" || lang === "tsx") {
|
plugins.push("jsx");
|
} else if (userPlugins) {
|
userPlugins = userPlugins.filter((p) => p !== "jsx");
|
}
|
if (lang === "ts" || lang === "tsx") {
|
plugins.push(["typescript", { dts }]);
|
if (!plugins.includes("decorators")) {
|
plugins.push("decorators-legacy");
|
}
|
}
|
if (userPlugins) {
|
plugins.push(...userPlugins);
|
}
|
return plugins;
|
}
|
|
var __defProp$1 = Object.defineProperty;
|
var __defProps$1 = Object.defineProperties;
|
var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
|
var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
|
var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues$1 = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp$1.call(b, prop))
|
__defNormalProp$1(a, prop, b[prop]);
|
if (__getOwnPropSymbols$1)
|
for (var prop of __getOwnPropSymbols$1(b)) {
|
if (__propIsEnum$1.call(b, prop))
|
__defNormalProp$1(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
|
class TypeScope {
|
constructor(filename, source, offset = 0, imports = /* @__PURE__ */ Object.create(null), types = /* @__PURE__ */ Object.create(null), declares = /* @__PURE__ */ Object.create(null)) {
|
this.filename = filename;
|
this.source = source;
|
this.offset = offset;
|
this.imports = imports;
|
this.types = types;
|
this.declares = declares;
|
this.resolvedImportSources = /* @__PURE__ */ Object.create(null);
|
this.exportedTypes = /* @__PURE__ */ Object.create(null);
|
this.exportedDeclares = /* @__PURE__ */ Object.create(null);
|
}
|
}
|
function resolveTypeElements(ctx, node, scope) {
|
if (node._resolvedElements) {
|
return node._resolvedElements;
|
}
|
return node._resolvedElements = innerResolveTypeElements(
|
ctx,
|
node,
|
node._ownerScope || scope || ctxToScope(ctx)
|
);
|
}
|
function innerResolveTypeElements(ctx, node, scope) {
|
var _a, _b;
|
switch (node.type) {
|
case "TSTypeLiteral":
|
return typeElementsToMap(ctx, node.members, scope);
|
case "TSInterfaceDeclaration":
|
return resolveInterfaceMembers(ctx, node, scope);
|
case "TSTypeAliasDeclaration":
|
case "TSParenthesizedType":
|
return resolveTypeElements(ctx, node.typeAnnotation, scope);
|
case "TSFunctionType": {
|
return { props: {}, calls: [node] };
|
}
|
case "TSUnionType":
|
case "TSIntersectionType":
|
return mergeElements(
|
node.types.map((t) => resolveTypeElements(ctx, t, scope)),
|
node.type
|
);
|
case "TSMappedType":
|
return resolveMappedType(ctx, node, scope);
|
case "TSIndexedAccessType": {
|
const types = resolveIndexType(ctx, node, scope);
|
return mergeElements(
|
types.map((t) => resolveTypeElements(ctx, t, t._ownerScope)),
|
"TSUnionType"
|
);
|
}
|
case "TSExpressionWithTypeArguments":
|
case "TSTypeReference": {
|
const typeName = getReferenceName(node);
|
if ((typeName === "ExtractPropTypes" || typeName === "ExtractPublicPropTypes") && node.typeParameters && ((_a = scope.imports[typeName]) == null ? void 0 : _a.source) === "vue") {
|
return resolveExtractPropTypes(
|
resolveTypeElements(ctx, node.typeParameters.params[0], scope),
|
scope
|
);
|
}
|
const resolved = resolveTypeReference(ctx, node, scope);
|
if (resolved) {
|
return resolveTypeElements(ctx, resolved, resolved._ownerScope);
|
} else {
|
if (typeof typeName === "string") {
|
if (
|
// @ts-ignore
|
SupportedBuiltinsSet.has(typeName)
|
) {
|
return resolveBuiltin(ctx, node, typeName, scope);
|
} else if (typeName === "ReturnType" && node.typeParameters) {
|
const ret = resolveReturnType(
|
ctx,
|
node.typeParameters.params[0],
|
scope
|
);
|
if (ret) {
|
return resolveTypeElements(ctx, ret, scope);
|
}
|
}
|
}
|
return ctx.error(
|
`Unresolvable type reference or unsupported built-in utility type`,
|
node,
|
scope
|
);
|
}
|
}
|
case "TSImportType": {
|
if (getId(node.argument) === "vue" && ((_b = node.qualifier) == null ? void 0 : _b.type) === "Identifier" && node.qualifier.name === "ExtractPropTypes" && node.typeParameters) {
|
return resolveExtractPropTypes(
|
resolveTypeElements(ctx, node.typeParameters.params[0], scope),
|
scope
|
);
|
}
|
const sourceScope = importSourceToScope(
|
ctx,
|
node.argument,
|
scope,
|
node.argument.value
|
);
|
const resolved = resolveTypeReference(ctx, node, sourceScope);
|
if (resolved) {
|
return resolveTypeElements(ctx, resolved, resolved._ownerScope);
|
}
|
}
|
case "TSTypeQuery": {
|
const resolved = resolveTypeReference(ctx, node, scope);
|
if (resolved) {
|
return resolveTypeElements(ctx, resolved, resolved._ownerScope);
|
}
|
}
|
}
|
return ctx.error(`Unresolvable type: ${node.type}`, node, scope);
|
}
|
function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx)) {
|
const res = { props: {} };
|
for (const e of elements) {
|
if (e.type === "TSPropertySignature" || e.type === "TSMethodSignature") {
|
e._ownerScope = scope;
|
const name = getId(e.key);
|
if (name && !e.computed) {
|
res.props[name] = e;
|
} else if (e.key.type === "TemplateLiteral") {
|
for (const key of resolveTemplateKeys(ctx, e.key, scope)) {
|
res.props[key] = e;
|
}
|
} else {
|
ctx.error(
|
`Unsupported computed key in type referenced by a macro`,
|
e.key,
|
scope
|
);
|
}
|
} else if (e.type === "TSCallSignatureDeclaration") {
|
(res.calls || (res.calls = [])).push(e);
|
}
|
}
|
return res;
|
}
|
function mergeElements(maps, type) {
|
if (maps.length === 1)
|
return maps[0];
|
const res = { props: {} };
|
const { props: baseProps } = res;
|
for (const { props, calls } of maps) {
|
for (const key in props) {
|
if (!hasOwn(baseProps, key)) {
|
baseProps[key] = props[key];
|
} else {
|
baseProps[key] = createProperty(
|
baseProps[key].key,
|
{
|
type,
|
// @ts-ignore
|
types: [baseProps[key], props[key]]
|
},
|
baseProps[key]._ownerScope,
|
baseProps[key].optional || props[key].optional
|
);
|
}
|
}
|
if (calls) {
|
(res.calls || (res.calls = [])).push(...calls);
|
}
|
}
|
return res;
|
}
|
function createProperty(key, typeAnnotation, scope, optional) {
|
return {
|
type: "TSPropertySignature",
|
key,
|
kind: "get",
|
optional,
|
typeAnnotation: {
|
type: "TSTypeAnnotation",
|
typeAnnotation
|
},
|
_ownerScope: scope
|
};
|
}
|
function resolveInterfaceMembers(ctx, node, scope) {
|
const base = typeElementsToMap(ctx, node.body.body, node._ownerScope);
|
if (node.extends) {
|
for (const ext of node.extends) {
|
if (ext.leadingComments && ext.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
|
continue;
|
}
|
try {
|
const { props } = resolveTypeElements(ctx, ext, scope);
|
for (const key in props) {
|
if (!hasOwn(base.props, key)) {
|
base.props[key] = props[key];
|
}
|
}
|
} catch (e) {
|
ctx.error(
|
`Failed to resolve extends base type.
|
If this previously worked in 3.2, you can instruct the compiler to ignore this extend by adding /* @vue-ignore */ before it, for example:
|
|
interface Props extends /* @vue-ignore */ Base {}
|
|
Note: both in 3.2 or with the ignore, the properties in the base type are treated as fallthrough attrs at runtime.`,
|
ext
|
);
|
}
|
}
|
}
|
return base;
|
}
|
function resolveMappedType(ctx, node, scope) {
|
const res = { props: {} };
|
const keys = resolveStringType(ctx, node.typeParameter.constraint, scope);
|
for (const key of keys) {
|
res.props[key] = createProperty(
|
{
|
type: "Identifier",
|
name: key
|
},
|
node.typeAnnotation,
|
scope,
|
!!node.optional
|
);
|
}
|
return res;
|
}
|
function resolveIndexType(ctx, node, scope) {
|
var _a, _b;
|
if (node.indexType.type === "TSNumberKeyword") {
|
return resolveArrayElementType(ctx, node.objectType, scope);
|
}
|
const { indexType, objectType } = node;
|
const types = [];
|
let keys;
|
let resolved;
|
if (indexType.type === "TSStringKeyword") {
|
resolved = resolveTypeElements(ctx, objectType, scope);
|
keys = Object.keys(resolved.props);
|
} else {
|
keys = resolveStringType(ctx, indexType, scope);
|
resolved = resolveTypeElements(ctx, objectType, scope);
|
}
|
for (const key of keys) {
|
const targetType = (_b = (_a = resolved.props[key]) == null ? void 0 : _a.typeAnnotation) == null ? void 0 : _b.typeAnnotation;
|
if (targetType) {
|
targetType._ownerScope = resolved.props[key]._ownerScope;
|
types.push(targetType);
|
}
|
}
|
return types;
|
}
|
function resolveArrayElementType(ctx, node, scope) {
|
if (node.type === "TSArrayType") {
|
return [node.elementType];
|
}
|
if (node.type === "TSTupleType") {
|
return node.elementTypes.map(
|
(t) => t.type === "TSNamedTupleMember" ? t.elementType : t
|
);
|
}
|
if (node.type === "TSTypeReference") {
|
if (getReferenceName(node) === "Array" && node.typeParameters) {
|
return node.typeParameters.params;
|
} else {
|
const resolved = resolveTypeReference(ctx, node, scope);
|
if (resolved) {
|
return resolveArrayElementType(ctx, resolved, scope);
|
}
|
}
|
}
|
return ctx.error(
|
"Failed to resolve element type from target type",
|
node,
|
scope
|
);
|
}
|
function resolveStringType(ctx, node, scope) {
|
switch (node.type) {
|
case "StringLiteral":
|
return [node.value];
|
case "TSLiteralType":
|
return resolveStringType(ctx, node.literal, scope);
|
case "TSUnionType":
|
return node.types.map((t) => resolveStringType(ctx, t, scope)).flat();
|
case "TemplateLiteral": {
|
return resolveTemplateKeys(ctx, node, scope);
|
}
|
case "TSTypeReference": {
|
const resolved = resolveTypeReference(ctx, node, scope);
|
if (resolved) {
|
return resolveStringType(ctx, resolved, scope);
|
}
|
if (node.typeName.type === "Identifier") {
|
const getParam = (index = 0) => resolveStringType(ctx, node.typeParameters.params[index], scope);
|
switch (node.typeName.name) {
|
case "Extract":
|
return getParam(1);
|
case "Exclude": {
|
const excluded = getParam(1);
|
return getParam().filter((s) => !excluded.includes(s));
|
}
|
case "Uppercase":
|
return getParam().map((s) => s.toUpperCase());
|
case "Lowercase":
|
return getParam().map((s) => s.toLowerCase());
|
case "Capitalize":
|
return getParam().map(capitalize$1);
|
case "Uncapitalize":
|
return getParam().map((s) => s[0].toLowerCase() + s.slice(1));
|
default:
|
ctx.error(
|
"Unsupported type when resolving index type",
|
node.typeName,
|
scope
|
);
|
}
|
}
|
}
|
}
|
return ctx.error("Failed to resolve index type into finite keys", node, scope);
|
}
|
function resolveTemplateKeys(ctx, node, scope) {
|
if (!node.expressions.length) {
|
return [node.quasis[0].value.raw];
|
}
|
const res = [];
|
const e = node.expressions[0];
|
const q = node.quasis[0];
|
const leading = q ? q.value.raw : ``;
|
const resolved = resolveStringType(ctx, e, scope);
|
const restResolved = resolveTemplateKeys(
|
ctx,
|
__spreadProps$1(__spreadValues$1({}, node), {
|
expressions: node.expressions.slice(1),
|
quasis: q ? node.quasis.slice(1) : node.quasis
|
}),
|
scope
|
);
|
for (const r of resolved) {
|
for (const rr of restResolved) {
|
res.push(leading + r + rr);
|
}
|
}
|
return res;
|
}
|
const SupportedBuiltinsSet = /* @__PURE__ */ new Set([
|
"Partial",
|
"Required",
|
"Readonly",
|
"Pick",
|
"Omit"
|
]);
|
function resolveBuiltin(ctx, node, name, scope) {
|
const t = resolveTypeElements(ctx, node.typeParameters.params[0], scope);
|
switch (name) {
|
case "Partial": {
|
const res2 = { props: {}, calls: t.calls };
|
Object.keys(t.props).forEach((key) => {
|
res2.props[key] = __spreadProps$1(__spreadValues$1({}, t.props[key]), { optional: true });
|
});
|
return res2;
|
}
|
case "Required": {
|
const res2 = { props: {}, calls: t.calls };
|
Object.keys(t.props).forEach((key) => {
|
res2.props[key] = __spreadProps$1(__spreadValues$1({}, t.props[key]), { optional: false });
|
});
|
return res2;
|
}
|
case "Readonly":
|
return t;
|
case "Pick": {
|
const picked = resolveStringType(
|
ctx,
|
node.typeParameters.params[1],
|
scope
|
);
|
const res2 = { props: {}, calls: t.calls };
|
for (const key of picked) {
|
res2.props[key] = t.props[key];
|
}
|
return res2;
|
}
|
case "Omit":
|
const omitted = resolveStringType(
|
ctx,
|
node.typeParameters.params[1],
|
scope
|
);
|
const res = { props: {}, calls: t.calls };
|
for (const key in t.props) {
|
if (!omitted.includes(key)) {
|
res.props[key] = t.props[key];
|
}
|
}
|
return res;
|
}
|
}
|
function resolveTypeReference(ctx, node, scope, name, onlyExported = false) {
|
if (node._resolvedReference) {
|
return node._resolvedReference;
|
}
|
return node._resolvedReference = innerResolveTypeReference(
|
ctx,
|
scope || ctxToScope(ctx),
|
name || getReferenceName(node),
|
node,
|
onlyExported
|
);
|
}
|
function innerResolveTypeReference(ctx, scope, name, node, onlyExported) {
|
if (typeof name === "string") {
|
if (scope.imports[name]) {
|
return resolveTypeFromImport(ctx, node, name, scope);
|
} else {
|
const lookupSource = node.type === "TSTypeQuery" ? onlyExported ? scope.exportedDeclares : scope.declares : onlyExported ? scope.exportedTypes : scope.types;
|
if (lookupSource[name]) {
|
return lookupSource[name];
|
} else {
|
const globalScopes = resolveGlobalScope(ctx);
|
if (globalScopes) {
|
for (const s of globalScopes) {
|
const src = node.type === "TSTypeQuery" ? s.declares : s.types;
|
if (src[name]) {
|
(ctx.deps || (ctx.deps = /* @__PURE__ */ new Set())).add(s.filename);
|
return src[name];
|
}
|
}
|
}
|
}
|
}
|
} else {
|
let ns = innerResolveTypeReference(ctx, scope, name[0], node, onlyExported);
|
if (ns) {
|
if (ns.type !== "TSModuleDeclaration") {
|
ns = ns._ns;
|
}
|
if (ns) {
|
const childScope = moduleDeclToScope(ctx, ns, ns._ownerScope || scope);
|
return innerResolveTypeReference(
|
ctx,
|
childScope,
|
name.length > 2 ? name.slice(1) : name[name.length - 1],
|
node,
|
!ns.declare
|
);
|
}
|
}
|
}
|
}
|
function getReferenceName(node) {
|
const ref = node.type === "TSTypeReference" ? node.typeName : node.type === "TSExpressionWithTypeArguments" ? node.expression : node.type === "TSImportType" ? node.qualifier : node.exprName;
|
if ((ref == null ? void 0 : ref.type) === "Identifier") {
|
return ref.name;
|
} else if ((ref == null ? void 0 : ref.type) === "TSQualifiedName") {
|
return qualifiedNameToPath(ref);
|
} else {
|
return "default";
|
}
|
}
|
function qualifiedNameToPath(node) {
|
if (node.type === "Identifier") {
|
return [node.name];
|
} else {
|
return [...qualifiedNameToPath(node.left), node.right.name];
|
}
|
}
|
function resolveGlobalScope(ctx) {
|
if (ctx.options.globalTypeFiles) {
|
const fs = resolveFS(ctx);
|
if (!fs) {
|
throw new Error("[vue/compiler-sfc] globalTypeFiles requires fs access.");
|
}
|
return ctx.options.globalTypeFiles.map(
|
(file) => fileToScope(ctx, normalizePath(file), true)
|
);
|
}
|
}
|
let ts;
|
function registerTS(_ts) {
|
ts = _ts;
|
}
|
function resolveFS(ctx) {
|
if (ctx.fs) {
|
return ctx.fs;
|
}
|
const fs = ctx.options.fs || ts.sys;
|
if (!fs) {
|
return;
|
}
|
return ctx.fs = {
|
fileExists(file) {
|
if (file.endsWith(".vue.ts")) {
|
file = file.replace(/\.ts$/, "");
|
}
|
return fs.fileExists(file);
|
},
|
readFile(file) {
|
if (file.endsWith(".vue.ts")) {
|
file = file.replace(/\.ts$/, "");
|
}
|
return fs.readFile(file);
|
}
|
};
|
}
|
function resolveTypeFromImport(ctx, node, name, scope) {
|
const { source, imported } = scope.imports[name];
|
const sourceScope = importSourceToScope(ctx, node, scope, source);
|
return resolveTypeReference(ctx, node, sourceScope, imported, true);
|
}
|
function importSourceToScope(ctx, node, scope, source) {
|
const fs = resolveFS(ctx);
|
if (!fs) {
|
return ctx.error(
|
`No fs option provided to \`compileScript\` in non-Node environment. File system access is required for resolving imported types.`,
|
node,
|
scope
|
);
|
}
|
let resolved = scope.resolvedImportSources[source];
|
if (!resolved) {
|
if (source.startsWith(".")) {
|
const filename = joinPaths(scope.filename, "..", source);
|
resolved = resolveExt(filename, fs);
|
} else {
|
{
|
ctx.error(
|
`Type import from non-relative sources is not supported in the browser build.`,
|
node,
|
scope
|
);
|
}
|
if (!ts) {
|
ctx.error(
|
`Failed to resolve import source ${JSON.stringify(source)}. typescript is required as a peer dep for vue in order to support resolving types from module imports.`,
|
node,
|
scope
|
);
|
}
|
resolved = resolveWithTS(scope.filename);
|
}
|
if (resolved) {
|
resolved = scope.resolvedImportSources[source] = normalizePath(resolved);
|
}
|
}
|
if (resolved) {
|
(ctx.deps || (ctx.deps = /* @__PURE__ */ new Set())).add(resolved);
|
return fileToScope(ctx, resolved);
|
} else {
|
return ctx.error(
|
`Failed to resolve import source ${JSON.stringify(source)}.`,
|
node,
|
scope
|
);
|
}
|
}
|
function resolveExt(filename, fs) {
|
filename = filename.replace(/\.js$/, "");
|
const tryResolve = (filename2) => {
|
if (fs.fileExists(filename2))
|
return filename2;
|
};
|
return tryResolve(filename) || tryResolve(filename + `.ts`) || tryResolve(filename + `.d.ts`) || tryResolve(joinPaths(filename, `index.ts`)) || tryResolve(joinPaths(filename, `index.d.ts`));
|
}
|
const tsConfigCache = createCache();
|
const tsConfigRefMap = /* @__PURE__ */ new Map();
|
function resolveWithTS(containingFile, source, fs) {
|
return;
|
}
|
const fileToScopeCache = createCache();
|
function invalidateTypeCache(filename) {
|
filename = normalizePath(filename);
|
fileToScopeCache.delete(filename);
|
tsConfigCache.delete(filename);
|
const affectedConfig = tsConfigRefMap.get(filename);
|
if (affectedConfig)
|
tsConfigCache.delete(affectedConfig);
|
}
|
function fileToScope(ctx, filename, asGlobal = false) {
|
const cached = fileToScopeCache.get(filename);
|
if (cached) {
|
return cached;
|
}
|
const fs = resolveFS(ctx);
|
const source = fs.readFile(filename) || "";
|
const body = parseFile(filename, source, ctx.options.babelParserPlugins);
|
const scope = new TypeScope(filename, source, 0, recordImports(body));
|
recordTypes(ctx, body, scope, asGlobal);
|
fileToScopeCache.set(filename, scope);
|
return scope;
|
}
|
function parseFile(filename, content, parserPlugins) {
|
const ext = extname(filename);
|
if (ext === ".ts" || ext === ".tsx") {
|
return parse_1$1(content, {
|
plugins: resolveParserPlugins(
|
ext.slice(1),
|
parserPlugins,
|
filename.endsWith(".d.ts")
|
),
|
sourceType: "module"
|
}).program.body;
|
} else if (ext === ".vue") {
|
const {
|
descriptor: { script, scriptSetup }
|
} = parse$7(content);
|
if (!script && !scriptSetup) {
|
return [];
|
}
|
const scriptOffset = script ? script.loc.start.offset : Infinity;
|
const scriptSetupOffset = scriptSetup ? scriptSetup.loc.start.offset : Infinity;
|
const firstBlock = scriptOffset < scriptSetupOffset ? script : scriptSetup;
|
const secondBlock = scriptOffset < scriptSetupOffset ? scriptSetup : script;
|
let scriptContent = " ".repeat(Math.min(scriptOffset, scriptSetupOffset)) + firstBlock.content;
|
if (secondBlock) {
|
scriptContent += " ".repeat(secondBlock.loc.start.offset - script.loc.end.offset) + secondBlock.content;
|
}
|
const lang = (script == null ? void 0 : script.lang) || (scriptSetup == null ? void 0 : scriptSetup.lang);
|
return parse_1$1(scriptContent, {
|
plugins: resolveParserPlugins(lang, parserPlugins),
|
sourceType: "module"
|
}).program.body;
|
}
|
return [];
|
}
|
function ctxToScope(ctx) {
|
if (ctx.scope) {
|
return ctx.scope;
|
}
|
const body = "ast" in ctx ? ctx.ast : ctx.scriptAst ? [...ctx.scriptAst.body, ...ctx.scriptSetupAst.body] : ctx.scriptSetupAst.body;
|
const scope = new TypeScope(
|
ctx.filename,
|
ctx.source,
|
"startOffset" in ctx ? ctx.startOffset : 0,
|
"userImports" in ctx ? Object.create(ctx.userImports) : recordImports(body)
|
);
|
recordTypes(ctx, body, scope);
|
return ctx.scope = scope;
|
}
|
function moduleDeclToScope(ctx, node, parentScope) {
|
if (node._resolvedChildScope) {
|
return node._resolvedChildScope;
|
}
|
const scope = new TypeScope(
|
parentScope.filename,
|
parentScope.source,
|
parentScope.offset,
|
Object.create(parentScope.imports),
|
Object.create(parentScope.types),
|
Object.create(parentScope.declares)
|
);
|
if (node.body.type === "TSModuleDeclaration") {
|
const decl = node.body;
|
decl._ownerScope = scope;
|
const id = getId(decl.id);
|
scope.types[id] = scope.exportedTypes[id] = decl;
|
} else {
|
recordTypes(ctx, node.body.body, scope);
|
}
|
return node._resolvedChildScope = scope;
|
}
|
const importExportRE = /^Import|^Export/;
|
function recordTypes(ctx, body, scope, asGlobal = false) {
|
const { types, declares, exportedTypes, exportedDeclares, imports } = scope;
|
const isAmbient = asGlobal ? !body.some((s) => importExportRE.test(s.type)) : false;
|
for (const stmt of body) {
|
if (asGlobal) {
|
if (isAmbient) {
|
if (stmt.declare) {
|
recordType(stmt, types, declares);
|
}
|
} else if (stmt.type === "TSModuleDeclaration" && stmt.global) {
|
for (const s of stmt.body.body) {
|
recordType(s, types, declares);
|
}
|
}
|
} else {
|
recordType(stmt, types, declares);
|
}
|
}
|
if (!asGlobal) {
|
for (const stmt of body) {
|
if (stmt.type === "ExportNamedDeclaration") {
|
if (stmt.declaration) {
|
recordType(stmt.declaration, types, declares);
|
recordType(stmt.declaration, exportedTypes, exportedDeclares);
|
} else {
|
for (const spec of stmt.specifiers) {
|
if (spec.type === "ExportSpecifier") {
|
const local = spec.local.name;
|
const exported = getId(spec.exported);
|
if (stmt.source) {
|
imports[local] = {
|
source: stmt.source.value,
|
imported: local
|
};
|
exportedTypes[exported] = {
|
type: "TSTypeReference",
|
typeName: {
|
type: "Identifier",
|
name: local
|
},
|
_ownerScope: scope
|
};
|
} else if (types[local]) {
|
exportedTypes[exported] = types[local];
|
}
|
}
|
}
|
}
|
} else if (stmt.type === "ExportAllDeclaration") {
|
const sourceScope = importSourceToScope(
|
ctx,
|
stmt.source,
|
scope,
|
stmt.source.value
|
);
|
Object.assign(scope.exportedTypes, sourceScope.exportedTypes);
|
} else if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
|
if (stmt.declaration.type !== "Identifier") {
|
recordType(stmt.declaration, types, declares, "default");
|
recordType(
|
stmt.declaration,
|
exportedTypes,
|
exportedDeclares,
|
"default"
|
);
|
} else if (types[stmt.declaration.name]) {
|
exportedTypes["default"] = types[stmt.declaration.name];
|
}
|
}
|
}
|
}
|
for (const key of Object.keys(types)) {
|
const node = types[key];
|
node._ownerScope = scope;
|
if (node._ns)
|
node._ns._ownerScope = scope;
|
}
|
for (const key of Object.keys(declares)) {
|
declares[key]._ownerScope = scope;
|
}
|
}
|
function recordType(node, types, declares, overwriteId) {
|
switch (node.type) {
|
case "TSInterfaceDeclaration":
|
case "TSEnumDeclaration":
|
case "TSModuleDeclaration": {
|
const id = overwriteId || getId(node.id);
|
let existing = types[id];
|
if (existing) {
|
if (node.type === "TSModuleDeclaration") {
|
if (existing.type === "TSModuleDeclaration") {
|
mergeNamespaces(existing, node);
|
} else {
|
attachNamespace(existing, node);
|
}
|
break;
|
}
|
if (existing.type === "TSModuleDeclaration") {
|
types[id] = node;
|
attachNamespace(node, existing);
|
break;
|
}
|
if (existing.type !== node.type) {
|
break;
|
}
|
if (node.type === "TSInterfaceDeclaration") {
|
existing.body.body.push(...node.body.body);
|
} else {
|
existing.members.push(...node.members);
|
}
|
} else {
|
types[id] = node;
|
}
|
break;
|
}
|
case "ClassDeclaration":
|
types[overwriteId || getId(node.id)] = node;
|
break;
|
case "TSTypeAliasDeclaration":
|
types[node.id.name] = node.typeAnnotation;
|
break;
|
case "TSDeclareFunction":
|
if (node.id)
|
declares[node.id.name] = node;
|
break;
|
case "VariableDeclaration": {
|
if (node.declare) {
|
for (const decl of node.declarations) {
|
if (decl.id.type === "Identifier" && decl.id.typeAnnotation) {
|
declares[decl.id.name] = decl.id.typeAnnotation.typeAnnotation;
|
}
|
}
|
}
|
break;
|
}
|
}
|
}
|
function mergeNamespaces(to, from) {
|
const toBody = to.body;
|
const fromBody = from.body;
|
if (toBody.type === "TSModuleDeclaration") {
|
if (fromBody.type === "TSModuleDeclaration") {
|
mergeNamespaces(toBody, fromBody);
|
} else {
|
fromBody.body.push({
|
type: "ExportNamedDeclaration",
|
declaration: toBody,
|
exportKind: "type",
|
specifiers: []
|
});
|
}
|
} else if (fromBody.type === "TSModuleDeclaration") {
|
toBody.body.push({
|
type: "ExportNamedDeclaration",
|
declaration: fromBody,
|
exportKind: "type",
|
specifiers: []
|
});
|
} else {
|
toBody.body.push(...fromBody.body);
|
}
|
}
|
function attachNamespace(to, ns) {
|
if (!to._ns) {
|
to._ns = ns;
|
} else {
|
mergeNamespaces(to._ns, ns);
|
}
|
}
|
function recordImports(body) {
|
const imports = /* @__PURE__ */ Object.create(null);
|
for (const s of body) {
|
recordImport(s, imports);
|
}
|
return imports;
|
}
|
function recordImport(node, imports) {
|
if (node.type !== "ImportDeclaration") {
|
return;
|
}
|
for (const s of node.specifiers) {
|
imports[s.local.name] = {
|
imported: getImportedName(s),
|
source: node.source.value
|
};
|
}
|
}
|
function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)) {
|
try {
|
switch (node.type) {
|
case "TSStringKeyword":
|
return ["String"];
|
case "TSNumberKeyword":
|
return ["Number"];
|
case "TSBooleanKeyword":
|
return ["Boolean"];
|
case "TSObjectKeyword":
|
return ["Object"];
|
case "TSNullKeyword":
|
return ["null"];
|
case "TSTypeLiteral":
|
case "TSInterfaceDeclaration": {
|
const types = /* @__PURE__ */ new Set();
|
const members = node.type === "TSTypeLiteral" ? node.members : node.body.body;
|
for (const m of members) {
|
if (m.type === "TSCallSignatureDeclaration" || m.type === "TSConstructSignatureDeclaration") {
|
types.add("Function");
|
} else {
|
types.add("Object");
|
}
|
}
|
return types.size ? Array.from(types) : ["Object"];
|
}
|
case "TSPropertySignature":
|
if (node.typeAnnotation) {
|
return inferRuntimeType(
|
ctx,
|
node.typeAnnotation.typeAnnotation,
|
scope
|
);
|
}
|
case "TSMethodSignature":
|
case "TSFunctionType":
|
return ["Function"];
|
case "TSArrayType":
|
case "TSTupleType":
|
return ["Array"];
|
case "TSLiteralType":
|
switch (node.literal.type) {
|
case "StringLiteral":
|
return ["String"];
|
case "BooleanLiteral":
|
return ["Boolean"];
|
case "NumericLiteral":
|
case "BigIntLiteral":
|
return ["Number"];
|
default:
|
return [UNKNOWN_TYPE];
|
}
|
case "TSTypeReference": {
|
const resolved = resolveTypeReference(ctx, node, scope);
|
if (resolved) {
|
return inferRuntimeType(ctx, resolved, resolved._ownerScope);
|
}
|
if (node.typeName.type === "Identifier") {
|
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 "Partial":
|
case "Required":
|
case "Readonly":
|
case "Record":
|
case "Pick":
|
case "Omit":
|
case "InstanceType":
|
return ["Object"];
|
case "Uppercase":
|
case "Lowercase":
|
case "Capitalize":
|
case "Uncapitalize":
|
return ["String"];
|
case "Parameters":
|
case "ConstructorParameters":
|
return ["Array"];
|
case "NonNullable":
|
if (node.typeParameters && node.typeParameters.params[0]) {
|
return inferRuntimeType(
|
ctx,
|
node.typeParameters.params[0],
|
scope
|
).filter((t) => t !== "null");
|
}
|
break;
|
case "Extract":
|
if (node.typeParameters && node.typeParameters.params[1]) {
|
return inferRuntimeType(
|
ctx,
|
node.typeParameters.params[1],
|
scope
|
);
|
}
|
break;
|
case "Exclude":
|
case "OmitThisParameter":
|
if (node.typeParameters && node.typeParameters.params[0]) {
|
return inferRuntimeType(
|
ctx,
|
node.typeParameters.params[0],
|
scope
|
);
|
}
|
break;
|
}
|
}
|
break;
|
}
|
case "TSParenthesizedType":
|
return inferRuntimeType(ctx, node.typeAnnotation, scope);
|
case "TSUnionType":
|
return flattenTypes(ctx, node.types, scope);
|
case "TSIntersectionType": {
|
return flattenTypes(ctx, node.types, scope).filter(
|
(t) => t !== UNKNOWN_TYPE
|
);
|
}
|
case "TSEnumDeclaration":
|
return inferEnumType(node);
|
case "TSSymbolKeyword":
|
return ["Symbol"];
|
case "TSIndexedAccessType": {
|
const types = resolveIndexType(ctx, node, scope);
|
return flattenTypes(ctx, types, scope);
|
}
|
case "ClassDeclaration":
|
return ["Object"];
|
case "TSImportType": {
|
const sourceScope = importSourceToScope(
|
ctx,
|
node.argument,
|
scope,
|
node.argument.value
|
);
|
const resolved = resolveTypeReference(ctx, node, sourceScope);
|
if (resolved) {
|
return inferRuntimeType(ctx, resolved, resolved._ownerScope);
|
}
|
break;
|
}
|
case "TSTypeQuery": {
|
const id = node.exprName;
|
if (id.type === "Identifier") {
|
const matched = scope.declares[id.name];
|
if (matched) {
|
return inferRuntimeType(ctx, matched, matched._ownerScope);
|
}
|
}
|
break;
|
}
|
}
|
} catch (e) {
|
}
|
return [UNKNOWN_TYPE];
|
}
|
function flattenTypes(ctx, types, scope) {
|
if (types.length === 1) {
|
return inferRuntimeType(ctx, types[0], scope);
|
}
|
return [
|
...new Set(
|
[].concat(
|
...types.map((t) => inferRuntimeType(ctx, t, scope))
|
)
|
)
|
];
|
}
|
function inferEnumType(node) {
|
const types = /* @__PURE__ */ new Set();
|
for (const m of node.members) {
|
if (m.initializer) {
|
switch (m.initializer.type) {
|
case "StringLiteral":
|
types.add("String");
|
break;
|
case "NumericLiteral":
|
types.add("Number");
|
break;
|
}
|
}
|
}
|
return types.size ? [...types] : ["Number"];
|
}
|
function resolveExtractPropTypes({ props }, scope) {
|
const res = { props: {} };
|
for (const key in props) {
|
const raw = props[key];
|
res.props[key] = reverseInferType(
|
raw.key,
|
raw.typeAnnotation.typeAnnotation,
|
scope
|
);
|
}
|
return res;
|
}
|
function reverseInferType(key, node, scope, optional = true, checkObjectSyntax = true) {
|
if (checkObjectSyntax && node.type === "TSTypeLiteral") {
|
const typeType = findStaticPropertyType(node, "type");
|
if (typeType) {
|
const requiredType = findStaticPropertyType(node, "required");
|
const optional2 = requiredType && requiredType.type === "TSLiteralType" && requiredType.literal.type === "BooleanLiteral" ? !requiredType.literal.value : true;
|
return reverseInferType(key, typeType, scope, optional2, false);
|
}
|
} else if (node.type === "TSTypeReference" && node.typeName.type === "Identifier") {
|
if (node.typeName.name.endsWith("Constructor")) {
|
return createProperty(
|
key,
|
ctorToType(node.typeName.name),
|
scope,
|
optional
|
);
|
} else if (node.typeName.name === "PropType" && node.typeParameters) {
|
return createProperty(key, node.typeParameters.params[0], scope, optional);
|
}
|
}
|
if ((node.type === "TSTypeReference" || node.type === "TSImportType") && node.typeParameters) {
|
for (const t of node.typeParameters.params) {
|
const inferred = reverseInferType(key, t, scope, optional);
|
if (inferred)
|
return inferred;
|
}
|
}
|
return createProperty(key, { type: `TSNullKeyword` }, scope, optional);
|
}
|
function ctorToType(ctorType) {
|
const ctor = ctorType.slice(0, -11);
|
switch (ctor) {
|
case "String":
|
case "Number":
|
case "Boolean":
|
return { type: `TS${ctor}Keyword` };
|
case "Array":
|
case "Function":
|
case "Object":
|
case "Set":
|
case "Map":
|
case "WeakSet":
|
case "WeakMap":
|
case "Date":
|
case "Promise":
|
return {
|
type: "TSTypeReference",
|
typeName: { type: "Identifier", name: ctor }
|
};
|
}
|
return { type: `TSNullKeyword` };
|
}
|
function findStaticPropertyType(node, key) {
|
const prop = node.members.find(
|
(m) => m.type === "TSPropertySignature" && !m.computed && getId(m.key) === key && m.typeAnnotation
|
);
|
return prop && prop.typeAnnotation.typeAnnotation;
|
}
|
function resolveReturnType(ctx, arg, scope) {
|
var _a;
|
let resolved = arg;
|
if (arg.type === "TSTypeReference" || arg.type === "TSTypeQuery" || arg.type === "TSImportType") {
|
resolved = resolveTypeReference(ctx, arg, scope);
|
}
|
if (!resolved)
|
return;
|
if (resolved.type === "TSFunctionType") {
|
return (_a = resolved.typeAnnotation) == null ? void 0 : _a.typeAnnotation;
|
}
|
if (resolved.type === "TSDeclareFunction") {
|
return resolved.returnType;
|
}
|
}
|
function resolveUnionType(ctx, node, scope) {
|
if (node.type === "TSTypeReference") {
|
const resolved = resolveTypeReference(ctx, node, scope);
|
if (resolved)
|
node = resolved;
|
}
|
let types;
|
if (node.type === "TSUnionType") {
|
types = node.types.flatMap((node2) => resolveUnionType(ctx, node2, scope));
|
} else {
|
types = [node];
|
}
|
return types;
|
}
|
|
const DEFINE_MODEL = "defineModel";
|
function processDefineModel(ctx, node, declId) {
|
if (!ctx.options.defineModel || !isCallOf(node, DEFINE_MODEL)) {
|
return false;
|
}
|
warnOnce$4(
|
`This project is using defineModel(), which is an experimental feature. It may receive breaking changes or be removed in the future, so use at your own risk.
|
To stay updated, follow the RFC at https://github.com/vuejs/rfcs/discussions/503.`
|
);
|
ctx.hasDefineModelCall = true;
|
const type = node.typeParameters && node.typeParameters.params[0] || void 0;
|
let modelName;
|
let options;
|
const arg0 = node.arguments[0] && unwrapTSNode(node.arguments[0]);
|
if (arg0 && arg0.type === "StringLiteral") {
|
modelName = arg0.value;
|
options = node.arguments[1];
|
} else {
|
modelName = "modelValue";
|
options = arg0;
|
}
|
if (ctx.modelDecls[modelName]) {
|
ctx.error(`duplicate model name ${JSON.stringify(modelName)}`, node);
|
}
|
const optionsString = options && ctx.getString(options);
|
ctx.modelDecls[modelName] = {
|
type,
|
options: optionsString,
|
identifier: declId && declId.type === "Identifier" ? declId.name : void 0
|
};
|
ctx.bindingMetadata[modelName] = "props";
|
let runtimeOptions = "";
|
if (options) {
|
if (options.type === "ObjectExpression") {
|
const local = options.properties.find(
|
(p) => p.type === "ObjectProperty" && (p.key.type === "Identifier" && p.key.name === "local" || p.key.type === "StringLiteral" && p.key.value === "local")
|
);
|
if (local) {
|
runtimeOptions = `{ ${ctx.getString(local)} }`;
|
} else {
|
for (const p of options.properties) {
|
if (p.type === "SpreadElement" || p.computed) {
|
runtimeOptions = optionsString;
|
break;
|
}
|
}
|
}
|
} else {
|
runtimeOptions = optionsString;
|
}
|
}
|
ctx.s.overwrite(
|
ctx.startOffset + node.start,
|
ctx.startOffset + node.end,
|
`${ctx.helper("useModel")}(__props, ${JSON.stringify(modelName)}${runtimeOptions ? `, ${runtimeOptions}` : ``})`
|
);
|
return true;
|
}
|
function genModelProps(ctx) {
|
if (!ctx.hasDefineModelCall)
|
return;
|
const isProd = !!ctx.options.isProd;
|
let modelPropsDecl = "";
|
for (const [name, { type, options }] of Object.entries(ctx.modelDecls)) {
|
let skipCheck = false;
|
let runtimeTypes = type && inferRuntimeType(ctx, type);
|
if (runtimeTypes) {
|
const hasUnknownType = runtimeTypes.includes(UNKNOWN_TYPE);
|
runtimeTypes = runtimeTypes.filter((el) => {
|
if (el === UNKNOWN_TYPE)
|
return false;
|
return isProd ? el === "Boolean" || el === "Function" && options : true;
|
});
|
skipCheck = !isProd && hasUnknownType && runtimeTypes.length > 0;
|
}
|
let runtimeType = runtimeTypes && runtimeTypes.length > 0 && toRuntimeTypeString(runtimeTypes) || void 0;
|
const codegenOptions = concatStrings([
|
runtimeType && `type: ${runtimeType}`,
|
skipCheck && "skipCheck: true"
|
]);
|
let decl;
|
if (runtimeType && options) {
|
decl = ctx.isTS ? `{ ${codegenOptions}, ...${options} }` : `Object.assign({ ${codegenOptions} }, ${options})`;
|
} else {
|
decl = options || (runtimeType ? `{ ${codegenOptions} }` : "{}");
|
}
|
modelPropsDecl += `
|
${JSON.stringify(name)}: ${decl},`;
|
}
|
return `{${modelPropsDecl}
|
}`;
|
}
|
|
const DEFINE_PROPS = "defineProps";
|
const WITH_DEFAULTS = "withDefaults";
|
function processDefineProps(ctx, node, declId) {
|
if (!isCallOf(node, DEFINE_PROPS)) {
|
return processWithDefaults(ctx, node, declId);
|
}
|
if (ctx.hasDefinePropsCall) {
|
ctx.error(`duplicate ${DEFINE_PROPS}() call`, node);
|
}
|
ctx.hasDefinePropsCall = true;
|
ctx.propsRuntimeDecl = node.arguments[0];
|
if (ctx.propsRuntimeDecl) {
|
for (const key of getObjectOrArrayExpressionKeys(ctx.propsRuntimeDecl)) {
|
if (!(key in ctx.bindingMetadata)) {
|
ctx.bindingMetadata[key] = "props";
|
}
|
}
|
}
|
if (node.typeParameters) {
|
if (ctx.propsRuntimeDecl) {
|
ctx.error(
|
`${DEFINE_PROPS}() cannot accept both type and non-type arguments at the same time. Use one or the other.`,
|
node
|
);
|
}
|
ctx.propsTypeDecl = node.typeParameters.params[0];
|
}
|
if (declId) {
|
if (declId.type === "ObjectPattern") {
|
processPropsDestructure(ctx, declId);
|
} else {
|
ctx.propsIdentifier = ctx.getString(declId);
|
}
|
}
|
return true;
|
}
|
function processWithDefaults(ctx, node, declId) {
|
if (!isCallOf(node, WITH_DEFAULTS)) {
|
return false;
|
}
|
if (processDefineProps(ctx, node.arguments[0], declId)) {
|
if (ctx.propsRuntimeDecl) {
|
ctx.error(
|
`${WITH_DEFAULTS} can only be used with type-based ${DEFINE_PROPS} declaration.`,
|
node
|
);
|
}
|
if (ctx.propsDestructureDecl) {
|
ctx.error(
|
`${WITH_DEFAULTS}() is unnecessary when using destructure with ${DEFINE_PROPS}().
|
Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(...).`,
|
node.callee
|
);
|
}
|
ctx.propsRuntimeDefaults = node.arguments[1];
|
if (!ctx.propsRuntimeDefaults) {
|
ctx.error(`The 2nd argument of ${WITH_DEFAULTS} is required.`, node);
|
}
|
} else {
|
ctx.error(
|
`${WITH_DEFAULTS}' first argument must be a ${DEFINE_PROPS} call.`,
|
node.arguments[0] || node
|
);
|
}
|
return true;
|
}
|
function genRuntimeProps(ctx) {
|
let propsDecls;
|
if (ctx.propsRuntimeDecl) {
|
propsDecls = ctx.getString(ctx.propsRuntimeDecl).trim();
|
if (ctx.propsDestructureDecl) {
|
const defaults = [];
|
for (const key in ctx.propsDestructuredBindings) {
|
const d = genDestructuredDefaultValue(ctx, key);
|
const finalKey = getEscapedKey(key);
|
if (d)
|
defaults.push(
|
`${finalKey}: ${d.valueString}${d.needSkipFactory ? `, __skip_${finalKey}: true` : ``}`
|
);
|
}
|
if (defaults.length) {
|
propsDecls = `${ctx.helper(
|
`mergeDefaults`
|
)}(${propsDecls}, {
|
${defaults.join(",\n ")}
|
})`;
|
}
|
}
|
} else if (ctx.propsTypeDecl) {
|
propsDecls = genRuntimePropsFromTypes(ctx);
|
}
|
const modelsDecls = genModelProps(ctx);
|
if (propsDecls && modelsDecls) {
|
return `${ctx.helper("mergeModels")}(${propsDecls}, ${modelsDecls})`;
|
} else {
|
return modelsDecls || propsDecls;
|
}
|
}
|
function genRuntimePropsFromTypes(ctx) {
|
const props = resolveRuntimePropsFromType(ctx, ctx.propsTypeDecl);
|
if (!props.length) {
|
return;
|
}
|
const propStrings = [];
|
const hasStaticDefaults = hasStaticWithDefaults(ctx);
|
for (const prop of props) {
|
propStrings.push(genRuntimePropFromType(ctx, prop, hasStaticDefaults));
|
if (!(prop.key in ctx.bindingMetadata)) {
|
ctx.bindingMetadata[prop.key] = "props";
|
}
|
}
|
let propsDecls = `{
|
${propStrings.join(",\n ")}
|
}`;
|
if (ctx.propsRuntimeDefaults && !hasStaticDefaults) {
|
propsDecls = `${ctx.helper("mergeDefaults")}(${propsDecls}, ${ctx.getString(
|
ctx.propsRuntimeDefaults
|
)})`;
|
}
|
return propsDecls;
|
}
|
function resolveRuntimePropsFromType(ctx, node) {
|
const props = [];
|
const elements = resolveTypeElements(ctx, node);
|
for (const key in elements.props) {
|
const e = elements.props[key];
|
let type = inferRuntimeType(ctx, e);
|
let skipCheck = false;
|
if (type.includes(UNKNOWN_TYPE)) {
|
if (type.includes("Boolean") || type.includes("Function")) {
|
type = type.filter((t) => t !== UNKNOWN_TYPE);
|
skipCheck = true;
|
} else {
|
type = ["null"];
|
}
|
}
|
props.push({
|
key,
|
required: !e.optional,
|
type: type || [`null`],
|
skipCheck
|
});
|
}
|
return props;
|
}
|
function genRuntimePropFromType(ctx, { key, required, type, skipCheck }, hasStaticDefaults) {
|
let defaultString;
|
const destructured = genDestructuredDefaultValue(ctx, key, type);
|
if (destructured) {
|
defaultString = `default: ${destructured.valueString}${destructured.needSkipFactory ? `, skipFactory: true` : ``}`;
|
} else if (hasStaticDefaults) {
|
const prop = ctx.propsRuntimeDefaults.properties.find(
|
(node) => {
|
if (node.type === "SpreadElement")
|
return false;
|
return resolveObjectKey(node.key, node.computed) === key;
|
}
|
);
|
if (prop) {
|
if (prop.type === "ObjectProperty") {
|
defaultString = `default: ${ctx.getString(prop.value)}`;
|
} else {
|
defaultString = `${prop.async ? "async " : ""}${prop.kind !== "method" ? `${prop.kind} ` : ""}default() ${ctx.getString(prop.body)}`;
|
}
|
}
|
}
|
const finalKey = getEscapedKey(key);
|
if (!ctx.options.isProd) {
|
return `${finalKey}: { ${concatStrings([
|
`type: ${toRuntimeTypeString(type)}`,
|
`required: ${required}`,
|
skipCheck && "skipCheck: true",
|
defaultString
|
])} }`;
|
} else if (type.some(
|
(el) => el === "Boolean" || (!hasStaticDefaults || defaultString) && el === "Function"
|
)) {
|
return `${finalKey}: { ${concatStrings([
|
`type: ${toRuntimeTypeString(type)}`,
|
defaultString
|
])} }`;
|
} else {
|
return `${finalKey}: ${defaultString ? `{ ${defaultString} }` : `{}`}`;
|
}
|
}
|
function hasStaticWithDefaults(ctx) {
|
return !!(ctx.propsRuntimeDefaults && ctx.propsRuntimeDefaults.type === "ObjectExpression" && ctx.propsRuntimeDefaults.properties.every(
|
(node) => node.type !== "SpreadElement" && (!node.computed || node.key.type.endsWith("Literal"))
|
));
|
}
|
function genDestructuredDefaultValue(ctx, key, inferredType) {
|
const destructured = ctx.propsDestructuredBindings[key];
|
const defaultVal = destructured && destructured.default;
|
if (defaultVal) {
|
const value = ctx.getString(defaultVal);
|
const unwrapped = unwrapTSNode(defaultVal);
|
if (inferredType && inferredType.length && !inferredType.includes("null")) {
|
const valueType = inferValueType(unwrapped);
|
if (valueType && !inferredType.includes(valueType)) {
|
ctx.error(
|
`Default value of prop "${key}" does not match declared type.`,
|
unwrapped
|
);
|
}
|
}
|
const needSkipFactory = !inferredType && (isFunctionType(unwrapped) || unwrapped.type === "Identifier");
|
const needFactoryWrap = !needSkipFactory && !isLiteralNode(unwrapped) && !(inferredType == null ? void 0 : inferredType.includes("Function"));
|
return {
|
valueString: needFactoryWrap ? `() => (${value})` : value,
|
needSkipFactory
|
};
|
}
|
}
|
function inferValueType(node) {
|
switch (node.type) {
|
case "StringLiteral":
|
return "String";
|
case "NumericLiteral":
|
return "Number";
|
case "BooleanLiteral":
|
return "Boolean";
|
case "ObjectExpression":
|
return "Object";
|
case "ArrayExpression":
|
return "Array";
|
case "FunctionExpression":
|
case "ArrowFunctionExpression":
|
return "Function";
|
}
|
}
|
|
function processPropsDestructure(ctx, declId) {
|
if (!ctx.options.propsDestructure && !ctx.options.reactivityTransform) {
|
ctx.propsIdentifier = ctx.getString(declId);
|
return;
|
}
|
warnOnce$4(
|
`This project is using reactive props destructure, which is an experimental feature. It may receive breaking changes or be removed in the future, so use at your own risk.
|
To stay updated, follow the RFC at https://github.com/vuejs/rfcs/discussions/502.`
|
);
|
ctx.propsDestructureDecl = declId;
|
const registerBinding = (key, local, defaultValue) => {
|
ctx.propsDestructuredBindings[key] = { local, default: defaultValue };
|
if (local !== key) {
|
ctx.bindingMetadata[local] = "props-aliased";
|
(ctx.bindingMetadata.__propsAliases || (ctx.bindingMetadata.__propsAliases = {}))[local] = key;
|
}
|
};
|
for (const prop of declId.properties) {
|
if (prop.type === "ObjectProperty") {
|
const propKey = resolveObjectKey(prop.key, prop.computed);
|
if (!propKey) {
|
ctx.error(
|
`${DEFINE_PROPS}() destructure cannot use computed key.`,
|
prop.key
|
);
|
}
|
if (prop.value.type === "AssignmentPattern") {
|
const { left, right } = prop.value;
|
if (left.type !== "Identifier") {
|
ctx.error(
|
`${DEFINE_PROPS}() destructure does not support nested patterns.`,
|
left
|
);
|
}
|
registerBinding(propKey, left.name, right);
|
} else if (prop.value.type === "Identifier") {
|
registerBinding(propKey, prop.value.name);
|
} else {
|
ctx.error(
|
`${DEFINE_PROPS}() destructure does not support nested patterns.`,
|
prop.value
|
);
|
}
|
} else {
|
ctx.propsDestructureRestId = prop.argument.name;
|
ctx.bindingMetadata[ctx.propsDestructureRestId] = "setup-reactive-const";
|
}
|
}
|
}
|
function transformDestructuredProps(ctx, vueImportAliases) {
|
if (!ctx.options.propsDestructure && !ctx.options.reactivityTransform) {
|
return;
|
}
|
const rootScope = {};
|
const scopeStack = [rootScope];
|
let currentScope = rootScope;
|
const excludedIds = /* @__PURE__ */ new WeakSet();
|
const parentStack = [];
|
const propsLocalToPublicMap = /* @__PURE__ */ Object.create(null);
|
for (const key in ctx.propsDestructuredBindings) {
|
const { local } = ctx.propsDestructuredBindings[key];
|
rootScope[local] = true;
|
propsLocalToPublicMap[local] = key;
|
}
|
function pushScope() {
|
scopeStack.push(currentScope = Object.create(currentScope));
|
}
|
function popScope() {
|
scopeStack.pop();
|
currentScope = scopeStack[scopeStack.length - 1] || null;
|
}
|
function registerLocalBinding(id) {
|
excludedIds.add(id);
|
if (currentScope) {
|
currentScope[id.name] = false;
|
} else {
|
ctx.error(
|
"registerBinding called without active scope, something is wrong.",
|
id
|
);
|
}
|
}
|
function walkScope(node, isRoot = false) {
|
for (const stmt of node.body) {
|
if (stmt.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt, isRoot);
|
} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
|
if (stmt.declare || !stmt.id)
|
continue;
|
registerLocalBinding(stmt.id);
|
} else if ((stmt.type === "ForOfStatement" || stmt.type === "ForInStatement") && stmt.left.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt.left);
|
} else if (stmt.type === "ExportNamedDeclaration" && stmt.declaration && stmt.declaration.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt.declaration, isRoot);
|
} else if (stmt.type === "LabeledStatement" && stmt.body.type === "VariableDeclaration") {
|
walkVariableDeclaration(stmt.body, isRoot);
|
}
|
}
|
}
|
function walkVariableDeclaration(stmt, isRoot = false) {
|
if (stmt.declare) {
|
return;
|
}
|
for (const decl of stmt.declarations) {
|
const isDefineProps = isRoot && decl.init && isCallOf(unwrapTSNode(decl.init), "defineProps");
|
for (const id of extractIdentifiers(decl.id)) {
|
if (isDefineProps) {
|
excludedIds.add(id);
|
} else {
|
registerLocalBinding(id);
|
}
|
}
|
}
|
}
|
function rewriteId(id, parent, parentStack2) {
|
if (parent.type === "AssignmentExpression" && id === parent.left || parent.type === "UpdateExpression") {
|
ctx.error(`Cannot assign to destructured props as they are readonly.`, id);
|
}
|
if (isStaticProperty(parent) && parent.shorthand) {
|
if (!parent.inPattern || isInDestructureAssignment(parent, parentStack2)) {
|
ctx.s.appendLeft(
|
id.end + ctx.startOffset,
|
`: ${genPropsAccessExp(propsLocalToPublicMap[id.name])}`
|
);
|
}
|
} else {
|
ctx.s.overwrite(
|
id.start + ctx.startOffset,
|
id.end + ctx.startOffset,
|
genPropsAccessExp(propsLocalToPublicMap[id.name])
|
);
|
}
|
}
|
function checkUsage(node, method, alias = method) {
|
if (isCallOf(node, alias)) {
|
const arg = unwrapTSNode(node.arguments[0]);
|
if (arg.type === "Identifier" && currentScope[arg.name]) {
|
ctx.error(
|
`"${arg.name}" is a destructured prop and should not be passed directly to ${method}(). Pass a getter () => ${arg.name} instead.`,
|
arg
|
);
|
}
|
}
|
}
|
const ast = ctx.scriptSetupAst;
|
walkScope(ast, true);
|
walk$1(ast, {
|
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();
|
}
|
checkUsage(node, "watch", vueImportAliases.watch);
|
checkUsage(node, "toRef", vueImportAliases.toRef);
|
if (isFunctionType(node)) {
|
pushScope();
|
walkFunctionParams(node, registerLocalBinding);
|
if (node.body.type === "BlockStatement") {
|
walkScope(node.body);
|
}
|
return;
|
}
|
if (node.type === "CatchClause") {
|
pushScope();
|
if (node.param && node.param.type === "Identifier") {
|
registerLocalBinding(node.param);
|
}
|
walkScope(node.body);
|
return;
|
}
|
if (node.type === "BlockStatement" && !isFunctionType(parent)) {
|
pushScope();
|
walkScope(node);
|
return;
|
}
|
if (node.type === "Identifier") {
|
if (isReferencedIdentifier(node, parent, parentStack) && !excludedIds.has(node)) {
|
if (currentScope[node.name]) {
|
rewriteId(node, parent, parentStack);
|
}
|
}
|
}
|
},
|
leave(node, parent) {
|
parent && parentStack.pop();
|
if (node.type === "BlockStatement" && !isFunctionType(parent) || isFunctionType(node)) {
|
popScope();
|
}
|
}
|
});
|
}
|
|
const DEFINE_EMITS = "defineEmits";
|
function processDefineEmits(ctx, node, declId) {
|
if (!isCallOf(node, DEFINE_EMITS)) {
|
return false;
|
}
|
if (ctx.hasDefineEmitCall) {
|
ctx.error(`duplicate ${DEFINE_EMITS}() call`, node);
|
}
|
ctx.hasDefineEmitCall = true;
|
ctx.emitsRuntimeDecl = node.arguments[0];
|
if (node.typeParameters) {
|
if (ctx.emitsRuntimeDecl) {
|
ctx.error(
|
`${DEFINE_EMITS}() cannot accept both type and non-type arguments at the same time. Use one or the other.`,
|
node
|
);
|
}
|
ctx.emitsTypeDecl = node.typeParameters.params[0];
|
}
|
if (declId) {
|
ctx.emitIdentifier = declId.type === "Identifier" ? declId.name : ctx.getString(declId);
|
}
|
return true;
|
}
|
function genRuntimeEmits(ctx) {
|
let emitsDecl = "";
|
if (ctx.emitsRuntimeDecl) {
|
emitsDecl = ctx.getString(ctx.emitsRuntimeDecl).trim();
|
} else if (ctx.emitsTypeDecl) {
|
const typeDeclaredEmits = extractRuntimeEmits(ctx);
|
emitsDecl = typeDeclaredEmits.size ? `[${Array.from(typeDeclaredEmits).map((k) => JSON.stringify(k)).join(", ")}]` : ``;
|
}
|
if (ctx.hasDefineModelCall) {
|
let modelEmitsDecl = `[${Object.keys(ctx.modelDecls).map((n) => JSON.stringify(`update:${n}`)).join(", ")}]`;
|
emitsDecl = emitsDecl ? `${ctx.helper("mergeModels")}(${emitsDecl}, ${modelEmitsDecl})` : modelEmitsDecl;
|
}
|
return emitsDecl;
|
}
|
function extractRuntimeEmits(ctx) {
|
const emits = /* @__PURE__ */ new Set();
|
const node = ctx.emitsTypeDecl;
|
if (node.type === "TSFunctionType") {
|
extractEventNames(ctx, node.parameters[0], emits);
|
return emits;
|
}
|
const { props, calls } = resolveTypeElements(ctx, node);
|
let hasProperty = false;
|
for (const key in props) {
|
emits.add(key);
|
hasProperty = true;
|
}
|
if (calls) {
|
if (hasProperty) {
|
ctx.error(
|
`defineEmits() type cannot mixed call signature and property syntax.`,
|
node
|
);
|
}
|
for (const call of calls) {
|
extractEventNames(ctx, call.parameters[0], emits);
|
}
|
}
|
return emits;
|
}
|
function extractEventNames(ctx, eventName, emits) {
|
if (eventName.type === "Identifier" && eventName.typeAnnotation && eventName.typeAnnotation.type === "TSTypeAnnotation") {
|
const types = resolveUnionType(ctx, eventName.typeAnnotation.typeAnnotation);
|
for (const type of types) {
|
if (type.type === "TSLiteralType") {
|
if (type.literal.type !== "UnaryExpression" && type.literal.type !== "TemplateLiteral") {
|
emits.add(String(type.literal.value));
|
}
|
}
|
}
|
}
|
}
|
|
const DEFINE_EXPOSE = "defineExpose";
|
function processDefineExpose(ctx, node) {
|
if (isCallOf(node, DEFINE_EXPOSE)) {
|
if (ctx.hasDefineExposeCall) {
|
ctx.error(`duplicate ${DEFINE_EXPOSE}() call`, node);
|
}
|
ctx.hasDefineExposeCall = true;
|
return true;
|
}
|
return false;
|
}
|
|
const DEFINE_SLOTS = "defineSlots";
|
function processDefineSlots(ctx, node, declId) {
|
if (!isCallOf(node, DEFINE_SLOTS)) {
|
return false;
|
}
|
if (ctx.hasDefineSlotsCall) {
|
ctx.error(`duplicate ${DEFINE_SLOTS}() call`, node);
|
}
|
ctx.hasDefineSlotsCall = true;
|
if (node.arguments.length > 0) {
|
ctx.error(`${DEFINE_SLOTS}() cannot accept arguments`, node);
|
}
|
if (declId) {
|
ctx.s.overwrite(
|
ctx.startOffset + node.start,
|
ctx.startOffset + node.end,
|
`${ctx.helper("useSlots")}()`
|
);
|
}
|
return true;
|
}
|
|
const DEFINE_OPTIONS = "defineOptions";
|
function processDefineOptions(ctx, node) {
|
if (!isCallOf(node, DEFINE_OPTIONS)) {
|
return false;
|
}
|
if (ctx.hasDefineOptionsCall) {
|
ctx.error(`duplicate ${DEFINE_OPTIONS}() call`, node);
|
}
|
if (node.typeParameters) {
|
ctx.error(`${DEFINE_OPTIONS}() cannot accept type arguments`, node);
|
}
|
if (!node.arguments[0])
|
return true;
|
ctx.hasDefineOptionsCall = true;
|
ctx.optionsRuntimeDecl = unwrapTSNode(node.arguments[0]);
|
let propsOption = void 0;
|
let emitsOption = void 0;
|
let exposeOption = void 0;
|
let slotsOption = void 0;
|
if (ctx.optionsRuntimeDecl.type === "ObjectExpression") {
|
for (const prop of ctx.optionsRuntimeDecl.properties) {
|
if ((prop.type === "ObjectProperty" || prop.type === "ObjectMethod") && prop.key.type === "Identifier") {
|
if (prop.key.name === "props")
|
propsOption = prop;
|
if (prop.key.name === "emits")
|
emitsOption = prop;
|
if (prop.key.name === "expose")
|
exposeOption = prop;
|
if (prop.key.name === "slots")
|
slotsOption = prop;
|
}
|
}
|
}
|
if (propsOption) {
|
ctx.error(
|
`${DEFINE_OPTIONS}() cannot be used to declare props. Use ${DEFINE_PROPS}() instead.`,
|
propsOption
|
);
|
}
|
if (emitsOption) {
|
ctx.error(
|
`${DEFINE_OPTIONS}() cannot be used to declare emits. Use ${DEFINE_EMITS}() instead.`,
|
emitsOption
|
);
|
}
|
if (exposeOption) {
|
ctx.error(
|
`${DEFINE_OPTIONS}() cannot be used to declare expose. Use ${DEFINE_EXPOSE}() instead.`,
|
exposeOption
|
);
|
}
|
if (slotsOption) {
|
ctx.error(
|
`${DEFINE_OPTIONS}() cannot be used to declare slots. Use ${DEFINE_SLOTS}() instead.`,
|
slotsOption
|
);
|
}
|
return true;
|
}
|
|
function processAwait(ctx, node, needSemi, isStatement) {
|
const argumentStart = node.argument.extra && node.argument.extra.parenthesized ? node.argument.extra.parenStart : node.argument.start;
|
const startOffset = ctx.startOffset;
|
const argumentStr = ctx.descriptor.source.slice(
|
argumentStart + startOffset,
|
node.argument.end + startOffset
|
);
|
const containsNestedAwait = /\bawait\b/.test(argumentStr);
|
ctx.s.overwrite(
|
node.start + startOffset,
|
argumentStart + startOffset,
|
`${needSemi ? `;` : ``}(
|
([__temp,__restore] = ${ctx.helper(
|
`withAsyncContext`
|
)}(${containsNestedAwait ? `async ` : ``}() => `
|
);
|
ctx.s.appendLeft(
|
node.end + startOffset,
|
`)),
|
${isStatement ? `` : `__temp = `}await __temp,
|
__restore()${isStatement ? `` : `,
|
__temp`}
|
)`
|
);
|
}
|
|
var __defProp = Object.defineProperty;
|
var __defProps = Object.defineProperties;
|
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
var __spreadValues = (a, b) => {
|
for (var prop in b || (b = {}))
|
if (__hasOwnProp.call(b, prop))
|
__defNormalProp(a, prop, b[prop]);
|
if (__getOwnPropSymbols)
|
for (var prop of __getOwnPropSymbols(b)) {
|
if (__propIsEnum.call(b, prop))
|
__defNormalProp(a, prop, b[prop]);
|
}
|
return a;
|
};
|
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
|
function compileScript(sfc, options) {
|
var _a;
|
if (!options.id) {
|
warnOnce$4(
|
`compileScript now requires passing the \`id\` option.
|
Upgrade your vite or vue-loader version for compatibility with the latest experimental proposals.`
|
);
|
}
|
const ctx = new ScriptCompileContext(sfc, options);
|
const { script, scriptSetup, source, filename } = sfc;
|
const hoistStatic = options.hoistStatic !== false && !script;
|
const scopeId = options.id ? options.id.replace(/^data-v-/, "") : "";
|
const scriptLang = script && script.lang;
|
const scriptSetupLang = scriptSetup && scriptSetup.lang;
|
const enableReactivityTransform = !!options.reactivityTransform;
|
let refBindings;
|
if (!scriptSetup) {
|
if (!script) {
|
throw new Error(`[@vue/compiler-sfc] SFC contains no <script> tags.`);
|
}
|
return processNormalScript(ctx, scopeId);
|
}
|
if (script && scriptLang !== scriptSetupLang) {
|
throw new Error(
|
`[@vue/compiler-sfc] <script> and <script setup> must have the same language type.`
|
);
|
}
|
if (scriptSetupLang && !ctx.isJS && !ctx.isTS) {
|
return scriptSetup;
|
}
|
const scriptBindings = /* @__PURE__ */ Object.create(null);
|
const setupBindings = /* @__PURE__ */ Object.create(null);
|
let defaultExport;
|
let hasAwait = false;
|
let hasInlinedSsrRenderFn = false;
|
const startOffset = ctx.startOffset;
|
const endOffset = ctx.endOffset;
|
const scriptStartOffset = script && script.loc.start.offset;
|
const scriptEndOffset = script && script.loc.end.offset;
|
function hoistNode(node) {
|
const start = node.start + startOffset;
|
let end = node.end + startOffset;
|
if (node.trailingComments && node.trailingComments.length > 0) {
|
const lastCommentNode = node.trailingComments[node.trailingComments.length - 1];
|
end = lastCommentNode.end + startOffset;
|
}
|
while (end <= source.length) {
|
if (!/\s/.test(source.charAt(end))) {
|
break;
|
}
|
end++;
|
}
|
ctx.s.move(start, end, 0);
|
}
|
function registerUserImport(source2, local, imported, isType, isFromSetup, needTemplateUsageCheck) {
|
let isUsedInTemplate = needTemplateUsageCheck;
|
if (needTemplateUsageCheck && ctx.isTS && sfc.template && !sfc.template.src && !sfc.template.lang) {
|
isUsedInTemplate = isImportUsed(local, sfc);
|
}
|
ctx.userImports[local] = {
|
isType,
|
imported,
|
local,
|
source: source2,
|
isFromSetup,
|
isUsedInTemplate
|
};
|
}
|
function checkInvalidScopeReference(node, method) {
|
if (!node)
|
return;
|
walkIdentifiers(node, (id) => {
|
const binding = setupBindings[id.name];
|
if (binding && binding !== "literal-const") {
|
ctx.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
|
);
|
}
|
});
|
}
|
const scriptAst = ctx.scriptAst;
|
const scriptSetupAst = ctx.scriptSetupAst;
|
if (scriptAst) {
|
for (const node of scriptAst.body) {
|
if (node.type === "ImportDeclaration") {
|
for (const specifier of node.specifiers) {
|
const imported = getImportedName(specifier);
|
registerUserImport(
|
node.source.value,
|
specifier.local.name,
|
imported,
|
node.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type",
|
false,
|
!options.inlineTemplate
|
);
|
}
|
}
|
}
|
}
|
for (const node of scriptSetupAst.body) {
|
if (node.type === "ImportDeclaration") {
|
hoistNode(node);
|
let removed = 0;
|
const removeSpecifier = (i) => {
|
const removeLeft = i > removed;
|
removed++;
|
const current = node.specifiers[i];
|
const next = node.specifiers[i + 1];
|
ctx.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;
|
const imported = getImportedName(specifier);
|
const source2 = node.source.value;
|
const existing = ctx.userImports[local];
|
if (source2 === "vue" && (imported === DEFINE_PROPS || imported === DEFINE_EMITS || imported === DEFINE_EXPOSE)) {
|
warnOnce$4(
|
`\`${imported}\` is a compiler macro and no longer needs to be imported.`
|
);
|
removeSpecifier(i);
|
} else if (existing) {
|
if (existing.source === source2 && existing.imported === imported) {
|
removeSpecifier(i);
|
} else {
|
ctx.error(
|
`different imports aliased to same local name.`,
|
specifier
|
);
|
}
|
} else {
|
registerUserImport(
|
source2,
|
local,
|
imported,
|
node.importKind === "type" || specifier.type === "ImportSpecifier" && specifier.importKind === "type",
|
true,
|
!options.inlineTemplate
|
);
|
}
|
}
|
if (node.specifiers.length && removed === node.specifiers.length) {
|
ctx.s.remove(node.start + startOffset, node.end + startOffset);
|
}
|
}
|
}
|
const vueImportAliases = {};
|
for (const key in ctx.userImports) {
|
const { source: source2, imported, local } = ctx.userImports[key];
|
if (source2 === "vue")
|
vueImportAliases[imported] = local;
|
}
|
if (script && scriptAst) {
|
for (const node of scriptAst.body) {
|
if (node.type === "ExportDefaultDeclaration") {
|
defaultExport = node;
|
let optionProperties;
|
if (defaultExport.declaration.type === "ObjectExpression") {
|
optionProperties = defaultExport.declaration.properties;
|
} else if (defaultExport.declaration.type === "CallExpression" && defaultExport.declaration.arguments[0] && defaultExport.declaration.arguments[0].type === "ObjectExpression") {
|
optionProperties = defaultExport.declaration.arguments[0].properties;
|
}
|
if (optionProperties) {
|
for (const p of optionProperties) {
|
if (p.type === "ObjectProperty" && p.key.type === "Identifier" && p.key.name === "name") {
|
ctx.hasDefaultExportName = true;
|
}
|
if ((p.type === "ObjectMethod" || p.type === "ObjectProperty") && p.key.type === "Identifier" && p.key.name === "render") {
|
ctx.hasDefaultExportRender = true;
|
}
|
}
|
}
|
const start = node.start + scriptStartOffset;
|
const end = node.declaration.start + scriptStartOffset;
|
ctx.s.overwrite(start, end, `const ${normalScriptDefaultVar} = `);
|
} else if (node.type === "ExportNamedDeclaration") {
|
const defaultSpecifier = node.specifiers.find(
|
(s) => s.exported.type === "Identifier" && s.exported.name === "default"
|
);
|
if (defaultSpecifier) {
|
defaultExport = node;
|
if (node.specifiers.length > 1) {
|
ctx.s.remove(
|
defaultSpecifier.start + scriptStartOffset,
|
defaultSpecifier.end + scriptStartOffset
|
);
|
} else {
|
ctx.s.remove(
|
node.start + scriptStartOffset,
|
node.end + scriptStartOffset
|
);
|
}
|
if (node.source) {
|
ctx.s.prepend(
|
`import { ${defaultSpecifier.local.name} as ${normalScriptDefaultVar} } from '${node.source.value}'
|
`
|
);
|
} else {
|
ctx.s.appendLeft(
|
scriptEndOffset,
|
`
|
const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
|
`
|
);
|
}
|
}
|
if (node.declaration) {
|
walkDeclaration(
|
"script",
|
node.declaration,
|
scriptBindings,
|
vueImportAliases,
|
hoistStatic
|
);
|
}
|
} else if ((node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration") && !node.declare) {
|
walkDeclaration(
|
"script",
|
node,
|
scriptBindings,
|
vueImportAliases,
|
hoistStatic
|
);
|
}
|
}
|
if (enableReactivityTransform && shouldTransform(script.content)) {
|
const { rootRefs, importedHelpers } = transformAST(
|
scriptAst,
|
ctx.s,
|
scriptStartOffset
|
);
|
refBindings = rootRefs;
|
for (const h of importedHelpers) {
|
ctx.helperImports.add(h);
|
}
|
}
|
if (scriptStartOffset > startOffset) {
|
if (!/\n$/.test(script.content.trim())) {
|
ctx.s.appendLeft(scriptEndOffset, `
|
`);
|
}
|
ctx.s.move(scriptStartOffset, scriptEndOffset, 0);
|
}
|
}
|
for (const node of scriptSetupAst.body) {
|
if (node.type === "ExpressionStatement") {
|
const expr = unwrapTSNode(node.expression);
|
if (processDefineProps(ctx, expr) || processDefineEmits(ctx, expr) || processDefineOptions(ctx, expr) || processDefineSlots(ctx, expr)) {
|
ctx.s.remove(node.start + startOffset, node.end + startOffset);
|
} else if (processDefineExpose(ctx, expr)) {
|
const callee = expr.callee;
|
ctx.s.overwrite(
|
callee.start + startOffset,
|
callee.end + startOffset,
|
"__expose"
|
);
|
} else {
|
processDefineModel(ctx, expr);
|
}
|
}
|
if (node.type === "VariableDeclaration" && !node.declare) {
|
const total = node.declarations.length;
|
let left = total;
|
let lastNonRemoved;
|
for (let i = 0; i < total; i++) {
|
const decl = node.declarations[i];
|
const init = decl.init && unwrapTSNode(decl.init);
|
if (init) {
|
if (processDefineOptions(ctx, init)) {
|
ctx.error(
|
`${DEFINE_OPTIONS}() has no returning value, it cannot be assigned.`,
|
node
|
);
|
}
|
const isDefineProps = processDefineProps(ctx, init, decl.id);
|
const isDefineEmits = !isDefineProps && processDefineEmits(ctx, init, decl.id);
|
!isDefineEmits && (processDefineSlots(ctx, init, decl.id) || processDefineModel(ctx, init, decl.id));
|
if (isDefineProps || isDefineEmits) {
|
if (left === 1) {
|
ctx.s.remove(node.start + startOffset, node.end + startOffset);
|
} else {
|
let start = decl.start + startOffset;
|
let end = decl.end + startOffset;
|
if (i === total - 1) {
|
start = node.declarations[lastNonRemoved].end + startOffset;
|
} else {
|
end = node.declarations[i + 1].start + startOffset;
|
}
|
ctx.s.remove(start, end);
|
left--;
|
}
|
} else {
|
lastNonRemoved = i;
|
}
|
}
|
}
|
}
|
let isAllLiteral = false;
|
if ((node.type === "VariableDeclaration" || node.type === "FunctionDeclaration" || node.type === "ClassDeclaration" || node.type === "TSEnumDeclaration") && !node.declare) {
|
isAllLiteral = walkDeclaration(
|
"scriptSetup",
|
node,
|
setupBindings,
|
vueImportAliases,
|
hoistStatic
|
);
|
}
|
if (hoistStatic && isAllLiteral) {
|
hoistNode(node);
|
}
|
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") {
|
hasAwait = true;
|
const currentScope = scope[scope.length - 1];
|
const needsSemi = currentScope.some((n, i) => {
|
return (scope.length === 1 || i > 0) && n.type === "ExpressionStatement" && n.start === child.start;
|
});
|
processAwait(
|
ctx,
|
child,
|
needsSemi,
|
parent.type === "ExpressionStatement"
|
);
|
}
|
},
|
exit(node2) {
|
if (node2.type === "BlockStatement")
|
scope.pop();
|
}
|
});
|
}
|
if (node.type === "ExportNamedDeclaration" && node.exportKind !== "type" || node.type === "ExportAllDeclaration" || node.type === "ExportDefaultDeclaration") {
|
ctx.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 (ctx.isTS) {
|
if (node.type.startsWith("TS") || node.type === "ExportNamedDeclaration" && node.exportKind === "type" || node.type === "VariableDeclaration" && node.declare) {
|
if (node.type !== "TSEnumDeclaration") {
|
hoistNode(node);
|
}
|
}
|
}
|
}
|
if (ctx.propsDestructureDecl) {
|
transformDestructuredProps(ctx, vueImportAliases);
|
}
|
if (enableReactivityTransform && // normal <script> had ref bindings that maybe used in <script setup>
|
(refBindings || shouldTransform(scriptSetup.content))) {
|
const { rootRefs, importedHelpers } = transformAST(
|
scriptSetupAst,
|
ctx.s,
|
startOffset,
|
refBindings
|
);
|
refBindings = refBindings ? [...refBindings, ...rootRefs] : rootRefs;
|
for (const h of importedHelpers) {
|
ctx.helperImports.add(h);
|
}
|
}
|
checkInvalidScopeReference(ctx.propsRuntimeDecl, DEFINE_PROPS);
|
checkInvalidScopeReference(ctx.propsRuntimeDefaults, DEFINE_PROPS);
|
checkInvalidScopeReference(ctx.propsDestructureDecl, DEFINE_PROPS);
|
checkInvalidScopeReference(ctx.emitsRuntimeDecl, DEFINE_EMITS);
|
checkInvalidScopeReference(ctx.optionsRuntimeDecl, DEFINE_OPTIONS);
|
if (script) {
|
if (startOffset < scriptStartOffset) {
|
ctx.s.remove(0, startOffset);
|
ctx.s.remove(endOffset, scriptStartOffset);
|
ctx.s.remove(scriptEndOffset, source.length);
|
} else {
|
ctx.s.remove(0, scriptStartOffset);
|
ctx.s.remove(scriptEndOffset, startOffset);
|
ctx.s.remove(endOffset, source.length);
|
}
|
} else {
|
ctx.s.remove(0, startOffset);
|
ctx.s.remove(endOffset, source.length);
|
}
|
if (scriptAst) {
|
Object.assign(ctx.bindingMetadata, analyzeScriptBindings(scriptAst.body));
|
}
|
for (const [key, { isType, imported, source: source2 }] of Object.entries(
|
ctx.userImports
|
)) {
|
if (isType)
|
continue;
|
ctx.bindingMetadata[key] = imported === "*" || imported === "default" && source2.endsWith(".vue") || source2 === "vue" ? "setup-const" : "setup-maybe-ref";
|
}
|
for (const key in scriptBindings) {
|
ctx.bindingMetadata[key] = scriptBindings[key];
|
}
|
for (const key in setupBindings) {
|
ctx.bindingMetadata[key] = setupBindings[key];
|
}
|
if (refBindings) {
|
for (const key of refBindings) {
|
ctx.bindingMetadata[key] = "setup-ref";
|
}
|
}
|
if (sfc.cssVars.length && // no need to do this when targeting SSR
|
!(options.inlineTemplate && ((_a = options.templateOptions) == null ? void 0 : _a.ssr))) {
|
ctx.helperImports.add(CSS_VARS_HELPER);
|
ctx.helperImports.add("unref");
|
ctx.s.prependLeft(
|
startOffset,
|
`
|
${genCssVarsCode(
|
sfc.cssVars,
|
ctx.bindingMetadata,
|
scopeId,
|
!!options.isProd
|
)}
|
`
|
);
|
}
|
let args = `__props`;
|
if (ctx.propsTypeDecl) {
|
args += `: any`;
|
}
|
if (ctx.propsIdentifier) {
|
ctx.s.prependLeft(
|
startOffset,
|
`
|
const ${ctx.propsIdentifier} = __props;
|
`
|
);
|
}
|
if (ctx.propsDestructureRestId) {
|
ctx.s.prependLeft(
|
startOffset,
|
`
|
const ${ctx.propsDestructureRestId} = ${ctx.helper(
|
`createPropsRestProxy`
|
)}(__props, ${JSON.stringify(
|
Object.keys(ctx.propsDestructuredBindings)
|
)});
|
`
|
);
|
}
|
if (hasAwait) {
|
const any = ctx.isTS ? `: any` : ``;
|
ctx.s.prependLeft(startOffset, `
|
let __temp${any}, __restore${any}
|
`);
|
}
|
const destructureElements = ctx.hasDefineExposeCall || !options.inlineTemplate ? [`expose: __expose`] : [];
|
if (ctx.emitIdentifier) {
|
destructureElements.push(
|
ctx.emitIdentifier === `emit` ? `emit` : `emit: ${ctx.emitIdentifier}`
|
);
|
}
|
if (destructureElements.length) {
|
args += `, { ${destructureElements.join(", ")} }`;
|
}
|
let returned;
|
if (!options.inlineTemplate || !sfc.template && ctx.hasDefaultExportRender) {
|
const allBindings = __spreadValues(__spreadValues({}, scriptBindings), setupBindings);
|
for (const key in ctx.userImports) {
|
if (!ctx.userImports[key].isType && ctx.userImports[key].isUsedInTemplate) {
|
allBindings[key] = true;
|
}
|
}
|
returned = `{ `;
|
for (const key in allBindings) {
|
if (allBindings[key] === true && ctx.userImports[key].source !== "vue" && !ctx.userImports[key].source.endsWith(".vue")) {
|
returned += `get ${key}() { return ${key} }, `;
|
} else if (ctx.bindingMetadata[key] === "setup-let") {
|
const setArg = key === "v" ? `_v` : `v`;
|
returned += `get ${key}() { return ${key} }, set ${key}(${setArg}) { ${key} = ${setArg} }, `;
|
} else {
|
returned += `${key}, `;
|
}
|
}
|
returned = returned.replace(/, $/, "") + ` }`;
|
} else {
|
if (sfc.template && !sfc.template.src) {
|
if (options.templateOptions && options.templateOptions.ssr) {
|
hasInlinedSsrRenderFn = true;
|
}
|
const { code, ast, preamble, tips, errors } = compileTemplate(__spreadProps(__spreadValues({
|
filename,
|
source: sfc.template.content,
|
inMap: sfc.template.map
|
}, options.templateOptions), {
|
id: scopeId,
|
scoped: sfc.styles.some((s) => s.scoped),
|
isProd: options.isProd,
|
ssrCssVars: sfc.cssVars,
|
compilerOptions: __spreadProps(__spreadValues({}, options.templateOptions && options.templateOptions.compilerOptions), {
|
inline: true,
|
isTS: ctx.isTS,
|
bindingMetadata: ctx.bindingMetadata
|
})
|
}));
|
if (tips.length) {
|
tips.forEach(warnOnce$4);
|
}
|
const err = errors[0];
|
if (typeof err === "string") {
|
throw new Error(err);
|
} else if (err) {
|
if (err.loc) {
|
err.message += `
|
|
` + sfc.filename + "\n" + generateCodeFrame(
|
source,
|
err.loc.start.offset,
|
err.loc.end.offset
|
) + `
|
`;
|
}
|
throw err;
|
}
|
if (preamble) {
|
ctx.s.prepend(preamble);
|
}
|
if (ast && ast.helpers.has(UNREF)) {
|
ctx.helperImports.delete("unref");
|
}
|
returned = code;
|
} else {
|
returned = `() => {}`;
|
}
|
}
|
if (!options.inlineTemplate && true) {
|
ctx.s.appendRight(
|
endOffset,
|
`
|
const __returned__ = ${returned}
|
Object.defineProperty(__returned__, '__isScriptSetup', { enumerable: false, value: true })
|
return __returned__
|
}
|
|
`
|
);
|
} else {
|
ctx.s.appendRight(endOffset, `
|
return ${returned}
|
}
|
|
`);
|
}
|
const genDefaultAs = options.genDefaultAs ? `const ${options.genDefaultAs} =` : `export default`;
|
let runtimeOptions = ``;
|
if (!ctx.hasDefaultExportName && filename && filename !== DEFAULT_FILENAME) {
|
const match = filename.match(/([^/\\]+)\.\w+$/);
|
if (match) {
|
runtimeOptions += `
|
__name: '${match[1]}',`;
|
}
|
}
|
if (hasInlinedSsrRenderFn) {
|
runtimeOptions += `
|
__ssrInlineRender: true,`;
|
}
|
const propsDecl = genRuntimeProps(ctx);
|
if (propsDecl)
|
runtimeOptions += `
|
props: ${propsDecl},`;
|
const emitsDecl = genRuntimeEmits(ctx);
|
if (emitsDecl)
|
runtimeOptions += `
|
emits: ${emitsDecl},`;
|
let definedOptions = "";
|
if (ctx.optionsRuntimeDecl) {
|
definedOptions = scriptSetup.content.slice(ctx.optionsRuntimeDecl.start, ctx.optionsRuntimeDecl.end).trim();
|
}
|
const exposeCall = ctx.hasDefineExposeCall || options.inlineTemplate ? `` : ` __expose();
|
`;
|
if (ctx.isTS) {
|
const def = (defaultExport ? `
|
...${normalScriptDefaultVar},` : ``) + (definedOptions ? `
|
...${definedOptions},` : "");
|
ctx.s.prependLeft(
|
startOffset,
|
`
|
${genDefaultAs} /*#__PURE__*/${ctx.helper(
|
`defineComponent`
|
)}({${def}${runtimeOptions}
|
${hasAwait ? `async ` : ``}setup(${args}) {
|
${exposeCall}`
|
);
|
ctx.s.appendRight(endOffset, `})`);
|
} else {
|
if (defaultExport || definedOptions) {
|
ctx.s.prependLeft(
|
startOffset,
|
`
|
${genDefaultAs} /*#__PURE__*/Object.assign(${defaultExport ? `${normalScriptDefaultVar}, ` : ""}${definedOptions ? `${definedOptions}, ` : ""}{${runtimeOptions}
|
${hasAwait ? `async ` : ``}setup(${args}) {
|
${exposeCall}`
|
);
|
ctx.s.appendRight(endOffset, `})`);
|
} else {
|
ctx.s.prependLeft(
|
startOffset,
|
`
|
${genDefaultAs} {${runtimeOptions}
|
${hasAwait ? `async ` : ``}setup(${args}) {
|
${exposeCall}`
|
);
|
ctx.s.appendRight(endOffset, `}`);
|
}
|
}
|
if (ctx.helperImports.size > 0) {
|
ctx.s.prepend(
|
`import { ${[...ctx.helperImports].map((h) => `${h} as _${h}`).join(", ")} } from 'vue'
|
`
|
);
|
}
|
ctx.s.trim();
|
return __spreadProps(__spreadValues({}, scriptSetup), {
|
bindings: ctx.bindingMetadata,
|
imports: ctx.userImports,
|
content: ctx.s.toString(),
|
map: options.sourceMap !== false ? ctx.s.generateMap({
|
source: filename,
|
hires: true,
|
includeContent: true
|
}) : void 0,
|
scriptAst: scriptAst == null ? void 0 : scriptAst.body,
|
scriptSetupAst: scriptSetupAst == null ? void 0 : scriptSetupAst.body,
|
deps: ctx.deps ? [...ctx.deps] : void 0
|
});
|
}
|
function registerBinding(bindings, node, type) {
|
bindings[node.name] = type;
|
}
|
function walkDeclaration(from, node, bindings, userImportAliases, hoistStatic) {
|
let isAllLiteral = false;
|
if (node.type === "VariableDeclaration") {
|
const isConst = node.kind === "const";
|
isAllLiteral = isConst && node.declarations.every(
|
(decl) => decl.id.type === "Identifier" && isStaticNode(decl.init)
|
);
|
for (const { id, init: _init } of node.declarations) {
|
const init = _init && unwrapTSNode(_init);
|
const isDefineCall = !!(isConst && isCallOf(
|
init,
|
(c) => c === DEFINE_PROPS || c === DEFINE_EMITS || c === WITH_DEFAULTS
|
));
|
if (id.type === "Identifier") {
|
let bindingType;
|
const userReactiveBinding = userImportAliases["reactive"];
|
if ((hoistStatic || from === "script") && (isAllLiteral || isConst && isStaticNode(init))) {
|
bindingType = "literal-const";
|
} else if (isCallOf(init, userReactiveBinding)) {
|
bindingType = isConst ? "setup-reactive-const" : "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" : "setup-const";
|
} else if (isConst) {
|
if (isCallOf(
|
init,
|
(m) => m === userImportAliases["ref"] || m === userImportAliases["computed"] || m === userImportAliases["shallowRef"] || m === userImportAliases["customRef"] || m === userImportAliases["toRef"] || m === DEFINE_MODEL
|
)) {
|
bindingType = "setup-ref";
|
} else {
|
bindingType = "setup-maybe-ref";
|
}
|
} else {
|
bindingType = "setup-let";
|
}
|
registerBinding(bindings, id, bindingType);
|
} else {
|
if (isCallOf(init, DEFINE_PROPS)) {
|
continue;
|
}
|
if (id.type === "ObjectPattern") {
|
walkObjectPattern(id, bindings, isConst, isDefineCall);
|
} else if (id.type === "ArrayPattern") {
|
walkArrayPattern(id, bindings, isConst, isDefineCall);
|
}
|
}
|
}
|
} else if (node.type === "TSEnumDeclaration") {
|
isAllLiteral = node.members.every(
|
(member) => !member.initializer || isStaticNode(member.initializer)
|
);
|
bindings[node.id.name] = isAllLiteral ? "literal-const" : "setup-const";
|
} else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
|
bindings[node.id.name] = "setup-const";
|
}
|
return isAllLiteral;
|
}
|
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) {
|
const type = isDefineCall ? "setup-const" : isConst ? "setup-maybe-ref" : "setup-let";
|
registerBinding(bindings, p.key, type);
|
} else {
|
walkPattern(p.value, bindings, isConst, isDefineCall);
|
}
|
} else {
|
const type = isConst ? "setup-const" : "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" : isConst ? "setup-maybe-ref" : "setup-let";
|
registerBinding(bindings, node, type);
|
} else if (node.type === "RestElement") {
|
const type = isConst ? "setup-const" : "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" : isConst ? "setup-maybe-ref" : "setup-let";
|
registerBinding(bindings, node.left, type);
|
} else {
|
walkPattern(node.left, bindings, isConst);
|
}
|
}
|
}
|
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 (isLiteralNode(node)) {
|
return true;
|
}
|
return false;
|
}
|
}
|
function isStaticNode(node) {
|
node = unwrapTSNode(node);
|
switch (node.type) {
|
case "UnaryExpression":
|
return isStaticNode(node.argument);
|
case "LogicalExpression":
|
case "BinaryExpression":
|
return isStaticNode(node.left) && isStaticNode(node.right);
|
case "ConditionalExpression": {
|
return isStaticNode(node.test) && isStaticNode(node.consequent) && isStaticNode(node.alternate);
|
}
|
case "SequenceExpression":
|
case "TemplateLiteral":
|
return node.expressions.every((expr) => isStaticNode(expr));
|
case "ParenthesizedExpression":
|
return isStaticNode(node.expression);
|
case "StringLiteral":
|
case "NumericLiteral":
|
case "BooleanLiteral":
|
case "NullLiteral":
|
case "BigIntLiteral":
|
return true;
|
}
|
return false;
|
}
|
|
const version = "3.3.4";
|
const walk = walk$1;
|
|
export { MagicString, parse_1$1 as babelParse, compileScript, compileStyle, compileStyleAsync, compileTemplate, extractIdentifiers, generateCodeFrame, inferRuntimeType, invalidateTypeCache, isInDestructureAssignment, isStaticProperty, parse$7 as parse, parseCache, registerTS, resolveTypeElements, rewriteDefault, rewriteDefaultAST, shouldTransform as shouldTransformRef, transform as transformRef, transformAST as transformRefAST, version, walk, walkIdentifiers };
|
