/ * *
* @ author Toru Nagashima < https : //github.com/mysticatea>
* See LICENSE file in root directory for full license .
* /
'use strict' ;
Object . defineProperty ( exports , '__esModule' , { value : true } ) ;
var path = require ( 'path' ) ;
var Evk = require ( 'eslint-visitor-keys' ) ;
var sortedLastIndex = require ( 'lodash/sortedLastIndex' ) ;
var assert = require ( 'assert' ) ;
var last = require ( 'lodash/last' ) ;
var findLastIndex = require ( 'lodash/findLastIndex' ) ;
var debugFactory = require ( 'debug' ) ;
var first = require ( 'lodash/first' ) ;
var sortedIndexBy = require ( 'lodash/sortedIndexBy' ) ;
var escope = require ( 'eslint-scope' ) ;
var Module = require ( 'module' ) ;
var semver = require ( 'semver' ) ;
var dependencyEspree = require ( 'espree' ) ;
var sortedLastIndexBy = require ( 'lodash/sortedLastIndexBy' ) ;
var EventEmitter = require ( 'events' ) ;
var esquery = require ( 'esquery' ) ;
var union = require ( 'lodash/union' ) ;
var intersection = require ( 'lodash/intersection' ) ;
var memoize = require ( 'lodash/memoize' ) ;
function _ interopDefaultLegacy ( e ) { return e && typeof e === 'object' && 'default' in e ? e : { 'default' : e } ; }
function _ interopNamespace ( e ) {
if ( e && e . __ esModule ) return e ;
var n = Object . create ( null ) ;
if ( e ) {
Object . keys ( e ) . forEach ( function ( k ) {
if ( k !== 'default' ) {
var d = Object . getOwnPropertyDescriptor ( e , k ) ;
Object . defineProperty ( n , k , d . get ? d : {
enumerable : true ,
get : function ( ) { return e [ k ] ; }
} ) ;
}
} ) ;
}
n [ "default" ] = e ;
return Object . freeze ( n ) ;
}
var path__namespace = /*#__PURE__*/ _ interopNamespace ( path ) ;
var path__default = /*#__PURE__*/ _ interopDefaultLegacy ( path ) ;
var Evk__namespace = /*#__PURE__*/ _ interopNamespace ( Evk ) ;
var sortedLastIndex__default = /*#__PURE__*/ _ interopDefaultLegacy ( sortedLastIndex ) ;
var assert__default = /*#__PURE__*/ _ interopDefaultLegacy ( assert ) ;
var last__default = /*#__PURE__*/ _ interopDefaultLegacy ( last ) ;
var findLastIndex__default = /*#__PURE__*/ _ interopDefaultLegacy ( findLastIndex ) ;
var debugFactory__default = /*#__PURE__*/ _ interopDefaultLegacy ( debugFactory ) ;
var first__default = /*#__PURE__*/ _ interopDefaultLegacy ( first ) ;
var sortedIndexBy__default = /*#__PURE__*/ _ interopDefaultLegacy ( sortedIndexBy ) ;
var escope__namespace = /*#__PURE__*/ _ interopNamespace ( escope ) ;
var Module__default = /*#__PURE__*/ _ interopDefaultLegacy ( Module ) ;
var dependencyEspree__namespace = /*#__PURE__*/ _ interopNamespace ( dependencyEspree ) ;
var sortedLastIndexBy__default = /*#__PURE__*/ _ interopDefaultLegacy ( sortedLastIndexBy ) ;
var EventEmitter__default = /*#__PURE__*/ _ interopDefaultLegacy ( EventEmitter ) ;
var esquery__default = /*#__PURE__*/ _ interopDefaultLegacy ( esquery ) ;
var union__default = /*#__PURE__*/ _ interopDefaultLegacy ( union ) ;
var intersection__default = /*#__PURE__*/ _ interopDefaultLegacy ( intersection ) ;
var memoize__default = /*#__PURE__*/ _ interopDefaultLegacy ( memoize ) ;
function isAcornStyleParseError ( x ) {
return ( typeof x . message === "string" &&
typeof x . pos === "number" &&
typeof x . loc === "object" &&
x . loc !== null &&
typeof x . loc . line === "number" &&
typeof x . loc . column === "number" ) ;
}
function isTSError ( x ) {
return ( ! ( x instanceof ParseError ) &&
typeof x . message === "string" &&
typeof x . index === "number" &&
typeof x . lineNumber === "number" &&
typeof x . column === "number" &&
x . name === "TSError" ) ;
}
class ParseError extends SyntaxError {
constructor ( message , code , offset , line , column ) {
super ( message ) ;
this . code = code ;
this . index = offset ;
this . lineNumber = line ;
this . column = column ;
}
static fromCode ( code , offset , line , column ) {
return new ParseError ( code , code , offset , line , column ) ;
}
static normalize ( x ) {
if ( isTSError ( x ) ) {
return new ParseError ( x . message , undefined , x . index , x . lineNumber , x . column ) ;
}
if ( ParseError . isParseError ( x ) ) {
return x ;
}
if ( isAcornStyleParseError ( x ) ) {
return new ParseError ( x . message , undefined , x . pos , x . loc . line , x . loc . column ) ;
}
return null ;
}
static isParseError ( x ) {
return ( x instanceof ParseError ||
( typeof x . message === "string" &&
typeof x . index === "number" &&
typeof x . lineNumber === "number" &&
typeof x . column === "number" ) ) ;
}
}
const NS = Object . freeze ( {
HTML : "http://www.w3.org/1999/xhtml" ,
MathML : "http://www.w3.org/1998/Math/MathML" ,
SVG : "http://www.w3.org/2000/svg" ,
XLink : "http://www.w3.org/1999/xlink" ,
XML : "http://www.w3.org/XML/1998/namespace" ,
XMLNS : "http://www.w3.org/2000/xmlns/" ,
} ) ;
const KEYS = Evk__namespace . unionWith ( {
VAttribute : [ "key" , "value" ] ,
VDirectiveKey : [ "name" , "argument" , "modifiers" ] ,
VDocumentFragment : [ "children" ] ,
VElement : [ "startTag" , "children" , "endTag" ] ,
VEndTag : [ ] ,
VExpressionContainer : [ "expression" ] ,
VFilter : [ "callee" , "arguments" ] ,
VFilterSequenceExpression : [ "expression" , "filters" ] ,
VForExpression : [ "left" , "right" ] ,
VIdentifier : [ ] ,
VLiteral : [ ] ,
VOnExpression : [ "body" ] ,
VSlotScopeExpression : [ "params" ] ,
VStartTag : [ "attributes" ] ,
VText : [ ] ,
} ) ;
function fallbackKeysFilter ( key ) {
let value = null ;
return ( key !== "comments" &&
key !== "leadingComments" &&
key !== "loc" &&
key !== "parent" &&
key !== "range" &&
key !== "tokens" &&
key !== "trailingComments" &&
( value = this [ key ] ) !== null &&
typeof value === "object" &&
( typeof value . type === "string" || Array . isArray ( value ) ) ) ;
}
function getFallbackKeys ( node ) {
return Object . keys ( node ) . filter ( fallbackKeysFilter , node ) ;
}
function isNode ( x ) {
return x !== null && typeof x === "object" && typeof x . type === "string" ;
}
function traverse ( node , parent , visitor ) {
let i = 0 ;
let j = 0 ;
visitor . enterNode ( node , parent ) ;
const keys = ( visitor . visitorKeys || KEYS ) [ node . type ] || getFallbackKeys ( node ) ;
for ( i = 0 ; i < keys . length ; ++ i ) {
const child = node [ keys [ i ] ] ;
if ( Array . isArray ( child ) ) {
for ( j = 0 ; j < child . length ; ++ j ) {
if ( isNode ( child [ j ] ) ) {
traverse ( child [ j ] , node , visitor ) ;
}
}
}
else if ( isNode ( child ) ) {
traverse ( child , node , visitor ) ;
}
}
visitor . leaveNode ( node , parent ) ;
}
function traverseNodes ( node , visitor ) {
traverse ( node , null , visitor ) ;
}
var index = /*#__PURE__*/ Object . freeze ( {
__ proto__ : null ,
ParseError : ParseError ,
NS : NS ,
KEYS : KEYS ,
traverseNodes : traverseNodes ,
getFallbackKeys : getFallbackKeys
} ) ;
class LinesAndColumns {
constructor ( ltOffsets ) {
this . ltOffsets = ltOffsets ;
}
getLocFromIndex ( index ) {
const line = sortedLastIndex__default [ "default" ] ( this . ltOffsets , index ) + 1 ;
const column = index - ( line === 1 ? 0 : this . ltOffsets [ line - 2 ] ) ;
return { line , column } ;
}
createOffsetLocationCalculator ( offset ) {
return {
getFixOffset ( ) {
return offset ;
} ,
getLocFromIndex : this . getLocFromIndex . bind ( this ) ,
} ;
}
}
class LocationCalculatorForHtml extends LinesAndColumns {
constructor ( gapOffsets , ltOffsets , baseOffset , shiftOffset = 0 ) {
super ( ltOffsets ) ;
this . gapOffsets = gapOffsets ;
this . ltOffsets = ltOffsets ;
this . baseOffset = baseOffset || 0 ;
this . baseIndexOfGap =
this . baseOffset === 0
? 0
: sortedLastIndex__default [ "default" ] ( gapOffsets , this . baseOffset ) ;
this . shiftOffset = shiftOffset ;
}
getSubCalculatorAfter ( offset ) {
return new LocationCalculatorForHtml ( this . gapOffsets , this . ltOffsets , this . baseOffset + offset , this . shiftOffset ) ;
}
getSubCalculatorShift ( offset ) {
return new LocationCalculatorForHtml ( this . gapOffsets , this . ltOffsets , this . baseOffset , this . shiftOffset + offset ) ;
}
_ getGap ( index ) {
const offsets = this . gapOffsets ;
let g0 = sortedLastIndex__default [ "default" ] ( offsets , index + this . baseOffset ) ;
let pos = index + this . baseOffset + g0 - this . baseIndexOfGap ;
while ( g0 < offsets . length && offsets [ g0 ] <= pos ) {
g0 += 1 ;
pos += 1 ;
}
return g0 - this . baseIndexOfGap ;
}
getLocation ( index ) {
return this . getLocFromIndex ( this . getOffsetWithGap ( index ) ) ;
}
getOffsetWithGap ( index ) {
return index + this . getFixOffset ( index ) ;
}
getFixOffset ( offset ) {
const shiftOffset = this . shiftOffset ;
const gap = this . _ getGap ( offset + shiftOffset ) ;
return this . baseOffset + gap + shiftOffset ;
}
}
const debug = debugFactory__default [ "default" ] ( "vue-eslint-parser" ) ;
function isScriptElement ( node ) {
return node . type === "VElement" && node . name === "script" ;
}
function isScriptSetupElement ( script ) {
return ( isScriptElement ( script ) &&
script . startTag . attributes . some ( ( attr ) => ! attr . directive && attr . key . name === "setup" ) ) ;
}
function isTemplateElement ( node ) {
return node . type === "VElement" && node . name === "template" ;
}
function isStyleElement ( node ) {
return node . type === "VElement" && node . name === "style" ;
}
function getOwnerDocument ( leafNode ) {
let node = leafNode ;
while ( node != null && node . type !== "VDocumentFragment" ) {
node = node . parent ;
}
return node ;
}
function isLang ( attribute ) {
return attribute . directive === false && attribute . key . name === "lang" ;
}
function getLang ( element ) {
const langAttr = element && element . startTag . attributes . find ( isLang ) ;
const lang = langAttr && langAttr . value && langAttr . value . value ;
return lang || null ;
}
function isTSLang ( element ) {
const lang = getLang ( element ) ;
return lang === "ts" || lang === "tsx" ;
}
function findGenericDirective ( element ) {
return ( element . startTag . attributes . find ( ( attr ) => {
var _ a , _ b ;
return attr . directive &&
( ( _ b = ( _ a = attr . value ) === null || _ a === void 0 ? void 0 : _ a . expression ) === null || _ b === void 0 ? void 0 : _ b . type ) === "VGenericExpression" ;
} ) || null ) ;
}
function isParserObject ( value ) {
return isEnhancedParserObject ( value ) || isBasicParserObject ( value ) ;
}
function isEnhancedParserObject ( value ) {
return Boolean ( value && typeof value . parseForESLint === "function" ) ;
}
function isBasicParserObject ( value ) {
return Boolean ( value && typeof value . parse === "function" ) ;
}
function isSFCFile ( parserOptions ) {
if ( parserOptions . filePath === "<input>" ) {
return true ;
}
return path__namespace . extname ( parserOptions . filePath || "unknown.vue" ) === ".vue" ;
}
function getScriptParser ( parser , getParserLang ) {
if ( isParserObject ( parser ) ) {
return parser ;
}
if ( parser && typeof parser === "object" ) {
const parserLang = getParserLang ( ) ;
const parserLangs = parserLang == null
? [ ]
: typeof parserLang === "string"
? [ parserLang ]
: parserLang ;
for ( const lang of parserLangs ) {
const parserForLang = lang && parser [ lang ] ;
if ( typeof parserForLang === "string" ||
isParserObject ( parserForLang ) ) {
return parserForLang ;
}
}
return parser . js ;
}
return typeof parser === "string" ? parser : undefined ;
}
function getParserLangFromSFC ( doc ) {
if ( doc ) {
const scripts = doc . children . filter ( isScriptElement ) ;
const script = ( scripts . length === 2 && scripts . find ( isScriptSetupElement ) ) ||
scripts [ 0 ] ;
if ( script ) {
return getLang ( script ) ;
}
}
return null ;
}
const createRequire = Module__default [ "default" ] . createRequire ||
Module__default [ "default" ] . createRequireFromPath ||
( ( modname ) => {
const mod = new Module__default [ "default" ] ( modname ) ;
mod . filename = modname ;
mod . paths = Module__default [ "default" ] . _ nodeModulePaths ( path__default [ "default" ] . dirname ( modname ) ) ;
mod . _ compile ( "module.exports = require;" , modname ) ;
return mod . exports ;
} ) ;
function isLinterPath ( p ) {
return ( p . includes ( ` eslint ${ path__default [ "default" ] . sep } lib ${ path__default [ "default" ] . sep } linter ${ path__default [ "default" ] . sep } linter.js ` ) ||
p . includes ( ` eslint ${ path__default [ "default" ] . sep } lib ${ path__default [ "default" ] . sep } linter.js ` ) ) ;
}
function getLinterRequire ( ) {
const linterPath = Object . keys ( require . cache ) . find ( isLinterPath ) ;
if ( linterPath ) {
try {
return createRequire ( linterPath ) ;
}
catch ( _ a ) {
}
}
return null ;
}
let escopeCache = null ;
function getEslintScope ( ) {
var _ a ;
if ( ! escopeCache ) {
escopeCache = ( _ a = getLinterRequire ( ) ) === null || _ a === void 0 ? void 0 : _ a ( "eslint-scope" ) ;
if ( ! escopeCache ||
escopeCache . version == null ||
semver . lte ( escopeCache . version , escope__namespace . version ) ) {
escopeCache = escope__namespace ;
}
}
return escopeCache ;
}
let espreeCache = null ;
function getEspreeFromEcmaVersion ( ecmaVersion ) {
const linterEspree = getEspreeFromLinter ( ) ;
if ( ecmaVersion == null ) {
return linterEspree ;
}
if ( ecmaVersion === "latest" ) {
return getNewestEspree ( ) ;
}
if ( normalizeEcmaVersion ( ecmaVersion ) <= getLatestEcmaVersion ( linterEspree ) ) {
return linterEspree ;
}
const userEspree = getEspreeFromUser ( ) ;
if ( normalizeEcmaVersion ( ecmaVersion ) <= getLatestEcmaVersion ( userEspree ) ) {
return userEspree ;
}
return linterEspree ;
}
function getEspreeFromUser ( ) {
try {
const cwd = process . cwd ( ) ;
const relativeTo = path__default [ "default" ] . join ( cwd , "__placeholder__.js" ) ;
return createRequire ( relativeTo ) ( "espree" ) ;
}
catch ( _ a ) {
return getEspreeFromLinter ( ) ;
}
}
function getEspreeFromLinter ( ) {
var _ a ;
if ( ! espreeCache ) {
espreeCache = ( _ a = getLinterRequire ( ) ) === null || _ a === void 0 ? void 0 : _ a ( "espree" ) ;
if ( ! espreeCache ) {
espreeCache = dependencyEspree__namespace ;
}
}
return espreeCache ;
}
function getNewestEspree ( ) {
let newest = dependencyEspree__namespace ;
const linterEspree = getEspreeFromLinter ( ) ;
if ( linterEspree . version != null &&
semver . lte ( newest . version , linterEspree . version ) ) {
newest = linterEspree ;
}
const userEspree = getEspreeFromUser ( ) ;
if ( userEspree . version != null && semver . lte ( newest . version , userEspree . version ) ) {
newest = userEspree ;
}
return newest ;
}
function getEcmaVersionIfUseEspree ( parserOptions , getDefault ) {
var _ a ;
if ( parserOptions . parser != null && parserOptions . parser !== "espree" ) {
return undefined ;
}
if ( parserOptions . ecmaVersion === "latest" ) {
return normalizeEcmaVersion ( getLatestEcmaVersion ( getNewestEspree ( ) ) ) ;
}
if ( parserOptions . ecmaVersion == null ) {
const defVer = getDefaultEcmaVersion$1 ( ) ;
return ( _ a = getDefault === null || getDefault === void 0 ? void 0 : getDefault ( defVer ) ) !== null && _ a !== void 0 ? _ a : defVer ;
}
return normalizeEcmaVersion ( parserOptions . ecmaVersion ) ;
}
function getDefaultEcmaVersion$1 ( ) {
if ( semver . lt ( getEspreeFromLinter ( ) . version , "9.0.0" ) ) {
return 5 ;
}
return normalizeEcmaVersion ( getLatestEcmaVersion ( getNewestEspree ( ) ) ) ;
}
function normalizeEcmaVersion ( version ) {
if ( version > 5 && version < 2015 ) {
return version + 2009 ;
}
return version ;
}
function getLatestEcmaVersion ( espree ) {
if ( espree . latestEcmaVersion == null ) {
for ( const { v , latest } of [
{ v : "6.1.0" , latest : 2020 } ,
{ v : "4.0.0" , latest : 2019 } ,
] ) {
if ( semver . lte ( v , espree . version ) ) {
return latest ;
}
}
return 2018 ;
}
return normalizeEcmaVersion ( espree . latestEcmaVersion ) ;
}
function isUnique ( reference , index , references ) {
return ( index === 0 || reference . identifier !== references [ index - 1 ] . identifier ) ;
}
function hasDefinition ( variable ) {
return variable . defs . length >= 1 ;
}
function transformReference ( reference ) {
const ret = {
id : reference . identifier ,
mode : reference . isReadOnly ( )
? "r"
: reference . isWriteOnly ( )
? "w"
: "rw" ,
variable : null ,
isValueReference : reference . isValueReference ,
isTypeReference : reference . isTypeReference ,
} ;
Object . defineProperty ( ret , "variable" , { enumerable : false } ) ;
return ret ;
}
function transformVariable ( variable , kind ) {
const ret = {
id : variable . defs [ 0 ] . name ,
kind ,
references : [ ] ,
} ;
Object . defineProperty ( ret , "references" , { enumerable : false } ) ;
return ret ;
}
function getForScope ( scope ) {
const child = scope . childScopes [ 0 ] ;
return child . block === scope . block ? child . childScopes [ 0 ] : child ;
}
function analyzeScope ( ast , parserOptions ) {
const ecmaVersion = getEcmaVersionIfUseEspree ( parserOptions ) || 2022 ;
const ecmaFeatures = parserOptions . ecmaFeatures || { } ;
const sourceType = parserOptions . sourceType || "script" ;
const result = getEslintScope ( ) . analyze ( ast , {
ignoreEval : true ,
nodejsScope : false ,
impliedStrict : ecmaFeatures . impliedStrict ,
ecmaVersion ,
sourceType ,
fallback : getFallbackKeys ,
} ) ;
return result ;
}
function analyze ( parserResult , parserOptions ) {
const scopeManager = parserResult . scopeManager ||
analyzeScope ( parserResult . ast , parserOptions ) ;
return scopeManager . globalScope ;
}
function analyzeExternalReferences ( parserResult , parserOptions ) {
const scope = analyze ( parserResult , parserOptions ) ;
return scope . through . filter ( isUnique ) . map ( transformReference ) ;
}
function analyzeVariablesAndExternalReferences ( parserResult , kind , parserOptions ) {
const scope = analyze ( parserResult , parserOptions ) ;
return {
variables : getForScope ( scope )
. variables . filter ( hasDefinition )
. map ( ( v ) => transformVariable ( v , kind ) ) ,
references : scope . through . filter ( isUnique ) . map ( transformReference ) ,
} ;
}
function fixLocations ( result , locationCalculator ) {
fixNodeLocations ( result . ast , result . visitorKeys , locationCalculator ) ;
for ( const token of result . ast . tokens || [ ] ) {
fixLocation ( token , locationCalculator ) ;
}
for ( const comment of result . ast . comments || [ ] ) {
fixLocation ( comment , locationCalculator ) ;
}
}
function fixNodeLocations ( rootNode , visitorKeys , locationCalculator ) {
const traversed = new Map ( ) ;
traverseNodes ( rootNode , {
visitorKeys ,
enterNode ( node , parent ) {
if ( ! traversed . has ( node ) ) {
traversed . set ( node , node ) ;
node . parent = parent ;
if ( traversed . has ( node . range ) ) {
if ( ! traversed . has ( node . loc ) ) {
node . loc . start = locationCalculator . getLocFromIndex ( node . range [ 0 ] ) ;
node . loc . end = locationCalculator . getLocFromIndex ( node . range [ 1 ] ) ;
traversed . set ( node . loc , node ) ;
}
else if ( node . start != null || node . end != null ) {
const traversedNode = traversed . get ( node . range ) ;
if ( traversedNode . type === node . type ) {
node . start = traversedNode . start ;
node . end = traversedNode . end ;
}
}
}
else {
fixLocation ( node , locationCalculator ) ;
traversed . set ( node . range , node ) ;
traversed . set ( node . loc , node ) ;
}
}
} ,
leaveNode ( ) {
} ,
} ) ;
}
function fixLocation ( node , locationCalculator ) {
const range = node . range ;
const loc = node . loc ;
const d0 = locationCalculator . getFixOffset ( range [ 0 ] , "start" ) ;
const d1 = locationCalculator . getFixOffset ( range [ 1 ] , "end" ) ;
if ( d0 !== 0 ) {
range [ 0 ] += d0 ;
if ( node . start != null ) {
node . start += d0 ;
}
loc . start = locationCalculator . getLocFromIndex ( range [ 0 ] ) ;
}
if ( d1 !== 0 ) {
range [ 1 ] += d1 ;
if ( node . end != null ) {
node . end += d0 ;
}
loc . end = locationCalculator . getLocFromIndex ( range [ 1 ] ) ;
}
return node ;
}
function fixErrorLocation ( error , locationCalculator ) {
const diff = locationCalculator . getFixOffset ( error . index , "start" ) ;
error . index += diff ;
const loc = locationCalculator . getLocFromIndex ( error . index ) ;
error . lineNumber = loc . line ;
error . column = loc . column ;
}
const DEFAULT_ECMA_VERSION = 2017 ;
function getScriptSetupParserOptions ( parserOptions ) {
const espreeEcmaVersion = getEcmaVersionIfUseEspree ( parserOptions , getDefaultEcmaVersion ) ;
return Object . assign ( Object . assign ( { } , parserOptions ) , { ecmaVersion : espreeEcmaVersion } ) ;
}
function getDefaultEcmaVersion ( def ) {
if ( semver . lte ( "8.0.0" , getEspreeFromUser ( ) . version ) ) {
return getEspreeFromUser ( ) . latestEcmaVersion ;
}
return Math . max ( def , DEFAULT_ECMA_VERSION ) ;
}
function extractGeneric ( element ) {
const genericAttr = findGenericDirective ( element ) ;
if ( ! genericAttr ) {
return null ;
}
const genericNode = genericAttr . value . expression ;
const defineTypes = genericNode . params . map ( ( t , i ) => ( {
node : t ,
define : ` type ${ t . name . name } = ${ getConstraint ( t , genericNode . rawParams [ i ] ) } ` ,
} ) ) ;
return {
node : genericNode ,
defineTypes ,
postprocess ( { result , getTypeBlock , isRemoveTarget , getTypeDefScope } ) {
var _ a ;
const node = ( _ a = getTypeBlock === null || getTypeBlock === void 0 ? void 0 : getTypeBlock ( result . ast ) ) !== null && _ a !== void 0 ? _ a : result . ast ;
removeTypeDeclarations ( node , isRemoveTarget ) ;
if ( result . ast . tokens ) {
removeTypeDeclarationTokens ( result . ast . tokens , isRemoveTarget ) ;
}
if ( result . ast . comments ) {
removeTypeDeclarationTokens ( result . ast . comments , isRemoveTarget ) ;
}
if ( result . scopeManager ) {
const typeDefScope = getTypeDefScope ( result . scopeManager ) ;
restoreScope ( result . scopeManager , typeDefScope , isRemoveTarget ) ;
}
} ,
} ;
function removeTypeDeclarations ( node , isRemoveTarget ) {
for ( let index = node . body . length - 1 ; index >= 0 ; index -- ) {
if ( isRemoveTarget ( node . body [ index ] ) ) {
node . body . splice ( index , 1 ) ;
}
}
}
function removeTypeDeclarationTokens ( tokens , isRemoveTarget ) {
for ( let index = tokens . length - 1 ; index >= 0 ; index -- ) {
if ( isRemoveTarget ( tokens [ index ] ) ) {
tokens . splice ( index , 1 ) ;
}
}
}
function restoreScope ( scopeManager , typeDefScope , isRemoveTarget ) {
for ( const variable of [ ... typeDefScope . variables ] ) {
let def = variable . defs . find ( ( d ) => isRemoveTarget ( d . name ) ) ;
while ( def ) {
removeVariableDef ( variable , def , typeDefScope ) ;
def = variable . defs . find ( ( d ) => isRemoveTarget ( d . name ) ) ;
}
}
for ( const reference of [ ... typeDefScope . references ] ) {
if ( isRemoveTarget ( reference . identifier ) ) {
removeReference ( reference , typeDefScope ) ;
}
}
for ( const scope of [ ... scopeManager . scopes ] ) {
if ( isRemoveTarget ( scope . block ) ) {
removeScope ( scopeManager , scope ) ;
}
}
}
}
function getConstraint ( node , rawParam ) {
if ( ! node . constraint ) {
return "unknown" ;
}
const start = node . range [ 0 ] ;
return rawParam . slice ( node . constraint . range [ 0 ] - start , node . constraint . range [ 1 ] - start ) ;
}
function removeVariableDef ( variable , def , scope ) {
const defIndex = variable . defs . indexOf ( def ) ;
if ( defIndex < 0 ) {
return ;
}
variable . defs . splice ( defIndex , 1 ) ;
if ( variable . defs . length === 0 ) {
referencesToThrough ( variable . references , scope ) ;
variable . references . forEach ( ( r ) => {
if ( r . init ) {
r . init = false ;
}
r . resolved = null ;
} ) ;
scope . variables . splice ( scope . variables . indexOf ( variable ) , 1 ) ;
const name = variable . name ;
if ( variable === scope . set . get ( name ) ) {
scope . set . delete ( name ) ;
}
}
else {
const idIndex = variable . identifiers . indexOf ( def . name ) ;
if ( idIndex >= 0 ) {
variable . identifiers . splice ( idIndex , 1 ) ;
}
}
}
function referencesToThrough ( references , baseScope ) {
let scope = baseScope ;
while ( scope ) {
addAllReferences ( scope . through , references ) ;
scope = scope . upper ;
}
}
function addAllReferences ( list , elements ) {
list . push ( ... elements ) ;
list . sort ( ( a , b ) => a . identifier . range [ 0 ] - b . identifier . range [ 0 ] ) ;
}
function removeReference ( reference , baseScope ) {
if ( reference . resolved ) {
if ( reference . resolved . defs . some ( ( d ) => d . name === reference . identifier ) ) {
const varIndex = baseScope . variables . indexOf ( reference . resolved ) ;
if ( varIndex >= 0 ) {
baseScope . variables . splice ( varIndex , 1 ) ;
}
const name = reference . identifier . name ;
if ( reference . resolved === baseScope . set . get ( name ) ) {
baseScope . set . delete ( name ) ;
}
}
else {
const refIndex = reference . resolved . references . indexOf ( reference ) ;
if ( refIndex >= 0 ) {
reference . resolved . references . splice ( refIndex , 1 ) ;
}
}
}
let scope = baseScope ;
while ( scope ) {
const refIndex = scope . references . indexOf ( reference ) ;
if ( refIndex >= 0 ) {
scope . references . splice ( refIndex , 1 ) ;
}
const throughIndex = scope . through . indexOf ( reference ) ;
if ( throughIndex >= 0 ) {
scope . through . splice ( throughIndex , 1 ) ;
}
scope = scope . upper ;
}
}
function removeScope ( scopeManager , scope ) {
for ( const childScope of scope . childScopes ) {
removeScope ( scopeManager , childScope ) ;
}
while ( scope . references [ 0 ] ) {
removeReference ( scope . references [ 0 ] , scope ) ;
}
const upper = scope . upper ;
if ( upper ) {
const index = upper . childScopes . indexOf ( scope ) ;
if ( index >= 0 ) {
upper . childScopes . splice ( index , 1 ) ;
}
}
const index = scopeManager . scopes . indexOf ( scope ) ;
if ( index >= 0 ) {
scopeManager . scopes . splice ( index , 1 ) ;
}
}
const ALIAS_ITERATOR = /^([\s\S]*?(?:\s|\)))(\bin\b|\bof\b)([\s\S]*)$/u ;
const PARENS = /^(\s*\()([\s\S]*?)(\)\s*)$/u ;
const DUMMY_PARENT$2 = { } ;
const IS_FUNCTION_EXPRESSION = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^function\s*\(/u ;
const IS_SIMPLE_PATH = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?'\]|\["[^"]*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/u ;
function processVForAliasAndIterator ( code ) {
const match = ALIAS_ITERATOR . exec ( code ) ;
if ( match != null ) {
const aliases = match [ 1 ] ;
const parenMatch = PARENS . exec ( aliases ) ;
return {
aliases ,
hasParens : Boolean ( parenMatch ) ,
aliasesWithBrackets : parenMatch
? ` ${ parenMatch [ 1 ] . slice ( 0 , - 1 ) } [ ${ parenMatch [ 2 ] } ] ${ parenMatch [ 3 ] . slice ( 1 ) } `
: ` [ ${ aliases . slice ( 0 , - 1 ) } ] ` ,
delimiter : match [ 2 ] || "" ,
iterator : match [ 3 ] ,
} ;
}
return {
aliases : "" ,
hasParens : false ,
aliasesWithBrackets : "" ,
delimiter : "" ,
iterator : code ,
} ;
}
function getCommaTokenBeforeNode ( tokens , node ) {
let tokenIndex = sortedIndexBy__default [ "default" ] ( tokens , { range : node . range } , ( t ) => t . range [ 0 ] ) ;
while ( tokenIndex >= 0 ) {
const token = tokens [ tokenIndex ] ;
if ( token . type === "Punctuator" && token . value === "," ) {
return token ;
}
tokenIndex -= 1 ;
}
return null ;
}
function throwEmptyError ( locationCalculator , expected ) {
const loc = locationCalculator . getLocation ( 0 ) ;
const err = new ParseError ( ` Expected to be ${ expected } , but got empty. ` , undefined , 0 , loc . line , loc . column ) ;
fixErrorLocation ( err , locationCalculator ) ;
throw err ;
}
function throwUnexpectedTokenError ( name , token ) {
const err = new ParseError ( ` Unexpected token ' ${ name } '. ` , undefined , token . range [ 0 ] , token . loc . start . line , token . loc . start . column ) ;
throw err ;
}
function throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) {
if ( ParseError . isParseError ( err ) ) {
const endOffset = locationCalculator . getOffsetWithGap ( code . length ) ;
if ( err . index >= endOffset ) {
err . message = "Unexpected end of expression." ;
}
}
throw err ;
}
function parseScriptFragment ( code , locationCalculator , parserOptions ) {
try {
const result = parseScript$1 ( code , parserOptions ) ;
fixLocations ( result , locationCalculator ) ;
return result ;
}
catch ( err ) {
const perr = ParseError . normalize ( err ) ;
if ( perr ) {
fixErrorLocation ( perr , locationCalculator ) ;
throw perr ;
}
throw err ;
}
}
const validDivisionCharRE = /[\w).+\-_$\]]/u ;
function splitFilters ( exp ) {
const result = [ ] ;
let inSingle = false ;
let inDouble = false ;
let inTemplateString = false ;
let inRegex = false ;
let curly = 0 ;
let square = 0 ;
let paren = 0 ;
let lastFilterIndex = 0 ;
let c = 0 ;
let prev = 0 ;
for ( let i = 0 ; i < exp . length ; i ++ ) {
prev = c ;
c = exp . charCodeAt ( i ) ;
if ( inSingle ) {
if ( c === 0x27 && prev !== 0x5c ) {
inSingle = false ;
}
}
else if ( inDouble ) {
if ( c === 0x22 && prev !== 0x5c ) {
inDouble = false ;
}
}
else if ( inTemplateString ) {
if ( c === 0x60 && prev !== 0x5c ) {
inTemplateString = false ;
}
}
else if ( inRegex ) {
if ( c === 0x2f && prev !== 0x5c ) {
inRegex = false ;
}
}
else if ( c === 0x7c &&
exp . charCodeAt ( i + 1 ) !== 0x7c &&
exp . charCodeAt ( i - 1 ) !== 0x7c &&
! curly &&
! square &&
! paren ) {
result . push ( exp . slice ( lastFilterIndex , i ) ) ;
lastFilterIndex = i + 1 ;
}
else {
switch ( c ) {
case 0x22 :
inDouble = true ;
break ;
case 0x27 :
inSingle = true ;
break ;
case 0x60 :
inTemplateString = true ;
break ;
case 0x28 :
paren ++ ;
break ;
case 0x29 :
paren -- ;
break ;
case 0x5b :
square ++ ;
break ;
case 0x5d :
square -- ;
break ;
case 0x7b :
curly ++ ;
break ;
case 0x7d :
curly -- ;
break ;
}
if ( c === 0x2f ) {
let j = i - 1 ;
let p ;
for ( ; j >= 0 ; j -- ) {
p = exp . charAt ( j ) ;
if ( p !== " " ) {
break ;
}
}
if ( ! p || ! validDivisionCharRE . test ( p ) ) {
inRegex = true ;
}
}
}
}
result . push ( exp . slice ( lastFilterIndex ) ) ;
return result ;
}
function parseExpressionBody ( code , locationCalculator , parserOptions , allowEmpty = false ) {
debug ( '[script] parse expression: "0(%s)"' , code ) ;
try {
const result = parseScriptFragment ( ` 0( ${ code } ) ` , locationCalculator . getSubCalculatorShift ( - 2 ) , parserOptions ) ;
const { ast } = result ;
const tokens = ast . tokens || [ ] ;
const comments = ast . comments || [ ] ;
const references = analyzeExternalReferences ( result , parserOptions ) ;
const statement = ast . body [ 0 ] ;
const callExpression = statement . expression ;
const expression = callExpression . arguments [ 0 ] ;
if ( ! allowEmpty && ! expression ) {
return throwEmptyError ( locationCalculator , "an expression" ) ;
}
if ( expression && expression . type === "SpreadElement" ) {
return throwUnexpectedTokenError ( "..." , expression ) ;
}
if ( callExpression . arguments [ 1 ] ) {
const node = callExpression . arguments [ 1 ] ;
return throwUnexpectedTokenError ( "," , getCommaTokenBeforeNode ( tokens , node ) || node ) ;
}
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . pop ( ) ;
return { expression , tokens , comments , references , variables : [ ] } ;
}
catch ( err ) {
return throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) ;
}
}
function parseFilter ( code , locationCalculator , parserOptions ) {
debug ( '[script] parse filter: "%s"' , code ) ;
try {
const expression = {
type : "VFilter" ,
parent : null ,
range : [ 0 , 0 ] ,
loc : { } ,
callee : null ,
arguments : [ ] ,
} ;
const tokens = [ ] ;
const comments = [ ] ;
const references = [ ] ;
const paren = code . indexOf ( "(" ) ;
const calleeCode = paren === - 1 ? code : code . slice ( 0 , paren ) ;
const argsCode = paren === - 1 ? null : code . slice ( paren ) ;
if ( calleeCode . trim ( ) ) {
const spaces = /^\s*/u . exec ( calleeCode ) [ 0 ] ;
const subCalculator = locationCalculator . getSubCalculatorShift ( spaces . length ) ;
const { ast } = parseScriptFragment ( ` " ${ calleeCode . trim ( ) } " ` , subCalculator , parserOptions ) ;
const statement = ast . body [ 0 ] ;
const callee = statement . expression ;
if ( callee . type !== "Literal" ) {
const { loc , range } = ast . tokens [ 0 ] ;
return throwUnexpectedTokenError ( '"' , {
range : [ range [ 1 ] - 1 , range [ 1 ] ] ,
loc : {
start : {
line : loc . end . line ,
column : loc . end . column - 1 ,
} ,
end : loc . end ,
} ,
} ) ;
}
expression . callee = {
type : "Identifier" ,
parent : expression ,
range : [
callee . range [ 0 ] ,
subCalculator . getOffsetWithGap ( calleeCode . trim ( ) . length ) ,
] ,
loc : {
start : callee . loc . start ,
end : subCalculator . getLocation ( calleeCode . trim ( ) . length ) ,
} ,
name : String ( callee . value ) ,
} ;
tokens . push ( {
type : "Identifier" ,
value : calleeCode . trim ( ) ,
range : expression . callee . range ,
loc : expression . callee . loc ,
} ) ;
}
else {
return throwEmptyError ( locationCalculator , "a filter name" ) ;
}
if ( argsCode != null ) {
const result = parseScriptFragment ( ` 0 ${ argsCode } ` , locationCalculator
. getSubCalculatorAfter ( paren )
. getSubCalculatorShift ( - 1 ) , parserOptions ) ;
const { ast } = result ;
const statement = ast . body [ 0 ] ;
const callExpression = statement . expression ;
ast . tokens . shift ( ) ;
if ( callExpression . type !== "CallExpression" ||
callExpression . callee . type !== "Literal" ) {
let nestCount = 1 ;
for ( const token of ast . tokens . slice ( 1 ) ) {
if ( nestCount === 0 ) {
return throwUnexpectedTokenError ( token . value , token ) ;
}
if ( token . type === "Punctuator" && token . value === "(" ) {
nestCount += 1 ;
}
if ( token . type === "Punctuator" && token . value === ")" ) {
nestCount -= 1 ;
}
}
const token = last__default [ "default" ] ( ast . tokens ) ;
return throwUnexpectedTokenError ( token . value , token ) ;
}
for ( const argument of callExpression . arguments ) {
argument . parent = expression ;
expression . arguments . push ( argument ) ;
}
tokens . push ( ... ast . tokens ) ;
comments . push ( ... ast . comments ) ;
references . push ( ... analyzeExternalReferences ( result , parserOptions ) ) ;
}
const firstToken = tokens [ 0 ] ;
const lastToken = last__default [ "default" ] ( tokens ) ;
expression . range = [ firstToken . range [ 0 ] , lastToken . range [ 1 ] ] ;
expression . loc = { start : firstToken . loc . start , end : lastToken . loc . end } ;
return { expression , tokens , comments , references , variables : [ ] } ;
}
catch ( err ) {
return throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) ;
}
}
function loadParser ( parser ) {
if ( parser !== "espree" ) {
return require ( parser ) ;
}
return getEspreeFromUser ( ) ;
}
function parseScript$1 ( code , parserOptions ) {
const parser = typeof parserOptions . parser === "string"
? loadParser ( parserOptions . parser )
: isParserObject ( parserOptions . parser )
? parserOptions . parser
: getEspreeFromEcmaVersion ( parserOptions . ecmaVersion ) ;
const result = isEnhancedParserObject ( parser )
? parser . parseForESLint ( code , parserOptions )
: parser . parse ( code , parserOptions ) ;
if ( result . ast != null ) {
return result ;
}
return { ast : result } ;
}
function parseScriptElement ( node , sfcCode , linesAndColumns , originalParserOptions ) {
var _ a , _ b ;
const parserOptions = isScriptSetupElement ( node )
? getScriptSetupParserOptions ( originalParserOptions )
: Object . assign ( Object . assign ( { } , originalParserOptions ) , { ecmaVersion : originalParserOptions . ecmaVersion || DEFAULT_ECMA_VERSION } ) ;
let generic = null ;
let code ;
let offset ;
const textNode = node . children [ 0 ] ;
if ( textNode != null && textNode . type === "VText" ) {
const [ scriptStartOffset , scriptEndOffset ] = textNode . range ;
code = sfcCode . slice ( scriptStartOffset , scriptEndOffset ) ;
offset = scriptStartOffset ;
generic = extractGeneric ( node ) ;
if ( generic ) {
const defineTypesCode = ` ${ generic . defineTypes
. map ( ( e ) => e . define )
. join ( ";" ) } ; \ n ` ;
code = defineTypesCode + code ;
offset -= defineTypesCode . length ;
}
}
else {
code = "" ;
offset = node . startTag . range [ 1 ] ;
}
const locationCalculator = linesAndColumns . createOffsetLocationCalculator ( offset ) ;
const result = parseScriptFragment ( code , locationCalculator , parserOptions ) ;
if ( generic ) {
generic . postprocess ( {
result ,
isRemoveTarget ( nodeOrToken ) {
return nodeOrToken . range [ 1 ] <= textNode . range [ 0 ] ;
} ,
getTypeDefScope ( scopeManager ) {
var _ a ;
return ( ( _ a = scopeManager . globalScope . childScopes . find ( ( s ) => s . type === "module" ) ) !== null && _ a !== void 0 ? _ a : scopeManager . globalScope ) ;
} ,
} ) ;
const startToken = [
result . ast . body [ 0 ] ,
( _ a = result . ast . tokens ) === null || _ a === void 0 ? void 0 : _ a [ 0 ] ,
( _ b = result . ast . comments ) === null || _ b === void 0 ? void 0 : _ b [ 0 ] ,
]
. filter ( ( e ) => Boolean ( e ) )
. sort ( ( a , b ) => a . range [ 0 ] - b . range [ 0 ] )
. find ( ( t ) => Boolean ( t ) ) ;
if ( startToken && result . ast . range [ 0 ] !== startToken . range [ 0 ] ) {
result . ast . range [ 0 ] = startToken . range [ 0 ] ;
if ( result . ast . start != null ) {
result . ast . start = startToken . start ;
}
result . ast . loc . start = Object . assign ( { } , startToken . loc . start ) ;
}
}
if ( result . ast . tokens != null ) {
const startTag = node . startTag ;
const endTag = node . endTag ;
result . ast . tokens . unshift ( {
type : "Punctuator" ,
range : startTag . range ,
loc : startTag . loc ,
value : "<script>" ,
} ) ;
if ( endTag != null ) {
result . ast . tokens . push ( {
type : "Punctuator" ,
range : endTag . range ,
loc : endTag . loc ,
value : "</script>" ,
} ) ;
}
}
return result ;
}
function parseExpression ( code , locationCalculator , parserOptions , { allowEmpty = false , allowFilters = false } = { } ) {
var _ a , _ b ;
debug ( '[script] parse expression: "%s"' , code ) ;
const [ mainCode , ... filterCodes ] = allowFilters && ( ( _ b = ( _ a = parserOptions . vueFeatures ) === null || _ a === void 0 ? void 0 : _ a . filter ) !== null && _ b !== void 0 ? _ b : true )
? splitFilters ( code )
: [ code ] ;
if ( filterCodes . length === 0 ) {
return parseExpressionBody ( code , locationCalculator , parserOptions , allowEmpty ) ;
}
const retB = parseExpressionBody ( mainCode , locationCalculator , parserOptions ) ;
if ( ! retB . expression ) {
return retB ;
}
const ret = retB ;
ret . expression = {
type : "VFilterSequenceExpression" ,
parent : null ,
expression : retB . expression ,
filters : [ ] ,
range : retB . expression . range . slice ( 0 ) ,
loc : Object . assign ( { } , retB . expression . loc ) ,
} ;
ret . expression . expression . parent = ret . expression ;
let prevLoc = mainCode . length ;
for ( const filterCode of filterCodes ) {
ret . tokens . push ( fixLocation ( {
type : "Punctuator" ,
value : "|" ,
range : [ prevLoc , prevLoc + 1 ] ,
loc : { } ,
} , locationCalculator ) ) ;
const retF = parseFilter ( filterCode , locationCalculator . getSubCalculatorShift ( prevLoc + 1 ) , parserOptions ) ;
if ( retF ) {
if ( retF . expression ) {
ret . expression . filters . push ( retF . expression ) ;
retF . expression . parent = ret . expression ;
}
ret . tokens . push ( ... retF . tokens ) ;
ret . comments . push ( ... retF . comments ) ;
ret . references . push ( ... retF . references ) ;
}
prevLoc += 1 + filterCode . length ;
}
const lastToken = last__default [ "default" ] ( ret . tokens ) ;
ret . expression . range [ 1 ] = lastToken . range [ 1 ] ;
ret . expression . loc . end = lastToken . loc . end ;
return ret ;
}
function parseVForExpression ( code , locationCalculator , parserOptions ) {
if ( code . trim ( ) === "" ) {
throwEmptyError ( locationCalculator , "'<alias> in <expression>'" ) ;
}
if ( isEcmaVersion5 ( parserOptions ) ) {
return parseVForExpressionForEcmaVersion5 ( code , locationCalculator , parserOptions ) ;
}
const processed = processVForAliasAndIterator ( code ) ;
if ( ! processed . aliases . trim ( ) ) {
return throwEmptyError ( locationCalculator , "an alias" ) ;
}
try {
debug ( '[script] parse v-for expression: "for(%s%s%s);"' , processed . aliasesWithBrackets , processed . delimiter , processed . iterator ) ;
const result = parseScriptFragment ( ` for(let ${ processed . aliasesWithBrackets } ${ processed . delimiter } ${ processed . iterator } ); ` , locationCalculator . getSubCalculatorShift ( processed . hasParens ? - 8 : - 9 ) , parserOptions ) ;
const { ast } = result ;
const tokens = ast . tokens || [ ] ;
const comments = ast . comments || [ ] ;
const scope = analyzeVariablesAndExternalReferences ( result , "v-for" , parserOptions ) ;
const references = scope . references ;
const variables = scope . variables ;
const statement = ast . body [ 0 ] ;
const varDecl = statement . left ;
const id = varDecl . declarations [ 0 ] . id ;
const left = id . elements ;
const right = statement . right ;
if ( ! processed . hasParens && ! left . length ) {
return throwEmptyError ( locationCalculator , "an alias" ) ;
}
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . pop ( ) ;
tokens . pop ( ) ;
const closeOffset = statement . left . range [ 1 ] - 1 ;
const closeIndex = tokens . findIndex ( ( t ) => t . range [ 0 ] === closeOffset ) ;
if ( processed . hasParens ) {
const open = tokens [ 0 ] ;
if ( open != null ) {
open . value = "(" ;
}
const close = tokens [ closeIndex ] ;
if ( close != null ) {
close . value = ")" ;
}
}
else {
tokens . splice ( closeIndex , 1 ) ;
tokens . shift ( ) ;
}
const firstToken = tokens [ 0 ] || statement . left ;
const lastToken = tokens [ tokens . length - 1 ] || statement . right ;
const expression = {
type : "VForExpression" ,
range : [ firstToken . range [ 0 ] , lastToken . range [ 1 ] ] ,
loc : { start : firstToken . loc . start , end : lastToken . loc . end } ,
parent : DUMMY_PARENT$2 ,
left ,
right ,
} ;
for ( const l of left ) {
if ( l != null ) {
l . parent = expression ;
}
}
right . parent = expression ;
return { expression , tokens , comments , references , variables } ;
}
catch ( err ) {
return throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) ;
}
}
function isEcmaVersion5 ( parserOptions ) {
const ecmaVersion = getEcmaVersionIfUseEspree ( parserOptions ) ;
return ecmaVersion != null && ecmaVersion <= 5 ;
}
function parseVForExpressionForEcmaVersion5 ( code , locationCalculator , parserOptions ) {
const processed = processVForAliasAndIterator ( code ) ;
if ( ! processed . aliases . trim ( ) ) {
return throwEmptyError ( locationCalculator , "an alias" ) ;
}
try {
const tokens = [ ] ;
const comments = [ ] ;
const parsedAliases = parseVForAliasesForEcmaVersion5 ( processed . aliasesWithBrackets , locationCalculator . getSubCalculatorShift ( processed . hasParens ? 0 : - 1 ) , parserOptions ) ;
if ( processed . hasParens ) {
const open = parsedAliases . tokens [ 0 ] ;
if ( open != null ) {
open . value = "(" ;
}
const close = last__default [ "default" ] ( parsedAliases . tokens ) ;
if ( close != null ) {
close . value = ")" ;
}
}
else {
parsedAliases . tokens . shift ( ) ;
parsedAliases . tokens . pop ( ) ;
}
tokens . push ( ... parsedAliases . tokens ) ;
comments . push ( ... parsedAliases . comments ) ;
const { left , variables } = parsedAliases ;
if ( ! processed . hasParens && ! left . length ) {
return throwEmptyError ( locationCalculator , "an alias" ) ;
}
const delimiterStart = processed . aliases . length ;
const delimiterEnd = delimiterStart + processed . delimiter . length ;
tokens . push ( fixLocation ( {
type : processed . delimiter === "in" ? "Keyword" : "Identifier" ,
value : processed . delimiter ,
start : delimiterStart ,
end : delimiterEnd ,
loc : { } ,
range : [ delimiterStart , delimiterEnd ] ,
} , locationCalculator ) ) ;
const parsedIterator = parseVForIteratorForEcmaVersion5 ( processed . iterator , locationCalculator . getSubCalculatorShift ( delimiterEnd ) , parserOptions ) ;
tokens . push ( ... parsedIterator . tokens ) ;
comments . push ( ... parsedIterator . comments ) ;
const { right , references } = parsedIterator ;
const firstToken = tokens [ 0 ] ;
const lastToken = last__default [ "default" ] ( tokens ) || firstToken ;
const expression = {
type : "VForExpression" ,
range : [ firstToken . range [ 0 ] , lastToken . range [ 1 ] ] ,
loc : { start : firstToken . loc . start , end : lastToken . loc . end } ,
parent : DUMMY_PARENT$2 ,
left ,
right ,
} ;
for ( const l of left ) {
if ( l != null ) {
l . parent = expression ;
}
}
right . parent = expression ;
return { expression , tokens , comments , references , variables } ;
}
catch ( err ) {
return throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) ;
}
}
function parseVForAliasesForEcmaVersion5 ( code , locationCalculator , parserOptions ) {
const result = parseScriptFragment ( ` 0( ${ code } ) ` , locationCalculator . getSubCalculatorShift ( - 2 ) , parserOptions ) ;
const { ast } = result ;
const tokens = ast . tokens || [ ] ;
const comments = ast . comments || [ ] ;
const variables = analyzeExternalReferences ( result , parserOptions ) . map ( transformVariable ) ;
const statement = ast . body [ 0 ] ;
const callExpression = statement . expression ;
const expression = callExpression . arguments [ 0 ] ;
const left = expression . elements . filter ( ( e ) => {
if ( e == null || e . type === "Identifier" ) {
return true ;
}
const errorToken = tokens . find ( ( t ) => e . range [ 0 ] <= t . range [ 0 ] && t . range [ 1 ] <= e . range [ 1 ] ) ;
return throwUnexpectedTokenError ( errorToken . value , errorToken ) ;
} ) ;
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . pop ( ) ;
return { left , tokens , comments , variables } ;
function transformVariable ( reference ) {
const ret = {
id : reference . id ,
kind : "v-for" ,
references : [ ] ,
} ;
Object . defineProperty ( ret , "references" , { enumerable : false } ) ;
return ret ;
}
}
function parseVForIteratorForEcmaVersion5 ( code , locationCalculator , parserOptions ) {
const result = parseScriptFragment ( ` 0( ${ code } ) ` , locationCalculator . getSubCalculatorShift ( - 2 ) , parserOptions ) ;
const { ast } = result ;
const tokens = ast . tokens || [ ] ;
const comments = ast . comments || [ ] ;
const references = analyzeExternalReferences ( result , parserOptions ) ;
const statement = ast . body [ 0 ] ;
const callExpression = statement . expression ;
const expression = callExpression . arguments [ 0 ] ;
if ( ! expression ) {
return throwEmptyError ( locationCalculator , "an expression" ) ;
}
if ( expression && expression . type === "SpreadElement" ) {
return throwUnexpectedTokenError ( "..." , expression ) ;
}
const right = expression ;
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . pop ( ) ;
return { right , tokens , comments , references } ;
}
function parseVOnExpression ( code , locationCalculator , parserOptions ) {
if ( IS_FUNCTION_EXPRESSION . test ( code ) || IS_SIMPLE_PATH . test ( code ) ) {
return parseExpressionBody ( code , locationCalculator , parserOptions ) ;
}
return parseVOnExpressionBody ( code , locationCalculator , parserOptions ) ;
}
function parseVOnExpressionBody ( code , locationCalculator , parserOptions ) {
debug ( '[script] parse v-on expression: "void function($event){%s}"' , code ) ;
if ( code . trim ( ) === "" ) {
throwEmptyError ( locationCalculator , "statements" ) ;
}
try {
const result = parseScriptFragment ( ` void function( $ event){ ${ code } } ` , locationCalculator . getSubCalculatorShift ( - 22 ) , parserOptions ) ;
const { ast } = result ;
const references = analyzeExternalReferences ( result , parserOptions ) ;
const outermostStatement = ast . body [ 0 ] ;
const functionDecl = outermostStatement . expression . argument ;
const block = functionDecl . body ;
const body = block . body ;
const firstStatement = first__default [ "default" ] ( body ) ;
const lastStatement = last__default [ "default" ] ( body ) ;
const expression = {
type : "VOnExpression" ,
range : [
firstStatement != null
? firstStatement . range [ 0 ]
: block . range [ 0 ] + 1 ,
lastStatement != null
? lastStatement . range [ 1 ]
: block . range [ 1 ] - 1 ,
] ,
loc : {
start : firstStatement != null
? firstStatement . loc . start
: locationCalculator . getLocation ( 1 ) ,
end : lastStatement != null
? lastStatement . loc . end
: locationCalculator . getLocation ( code . length + 1 ) ,
} ,
parent : DUMMY_PARENT$2 ,
body ,
} ;
const tokens = ast . tokens || [ ] ;
const comments = ast . comments || [ ] ;
for ( const b of body ) {
b . parent = expression ;
}
tokens . splice ( 0 , 6 ) ;
tokens . pop ( ) ;
return { expression , tokens , comments , references , variables : [ ] } ;
}
catch ( err ) {
return throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) ;
}
}
function parseSlotScopeExpression ( code , locationCalculator , parserOptions ) {
debug ( '[script] parse slot-scope expression: "void function(%s) {}"' , code ) ;
if ( code . trim ( ) === "" ) {
throwEmptyError ( locationCalculator , "an identifier or an array/object pattern" ) ;
}
try {
const result = parseScriptFragment ( ` void function( ${ code } ) {} ` , locationCalculator . getSubCalculatorShift ( - 14 ) , parserOptions ) ;
const { ast } = result ;
const statement = ast . body [ 0 ] ;
const rawExpression = statement . expression ;
const functionDecl = rawExpression . argument ;
const params = functionDecl . params ;
if ( params . length === 0 ) {
return {
expression : null ,
tokens : [ ] ,
comments : [ ] ,
references : [ ] ,
variables : [ ] ,
} ;
}
const tokens = ast . tokens || [ ] ;
const comments = ast . comments || [ ] ;
const scope = analyzeVariablesAndExternalReferences ( result , "scope" , parserOptions ) ;
const references = scope . references ;
const variables = scope . variables ;
const firstParam = first__default [ "default" ] ( params ) ;
const lastParam = last__default [ "default" ] ( params ) ;
const expression = {
type : "VSlotScopeExpression" ,
range : [ firstParam . range [ 0 ] , lastParam . range [ 1 ] ] ,
loc : { start : firstParam . loc . start , end : lastParam . loc . end } ,
parent : DUMMY_PARENT$2 ,
params : functionDecl . params ,
} ;
for ( const param of params ) {
param . parent = expression ;
}
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . pop ( ) ;
tokens . pop ( ) ;
tokens . pop ( ) ;
return { expression , tokens , comments , references , variables } ;
}
catch ( err ) {
return throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) ;
}
}
function parseGenericExpression ( code , locationCalculator , parserOptions ) {
debug ( '[script] parse generic definition: "void function<%s>() {}"' , code ) ;
if ( code . trim ( ) === "" ) {
throwEmptyError ( locationCalculator , "a type parameter" ) ;
}
try {
const result = parseScriptFragment ( ` void function< ${ code } >(){} ` , locationCalculator . getSubCalculatorShift ( - 14 ) , Object . assign ( Object . assign ( { } , parserOptions ) , { project : undefined } ) ) ;
const { ast } = result ;
const statement = ast . body [ 0 ] ;
const rawExpression = statement . expression ;
const classDecl = rawExpression . argument ;
const typeParameters = classDecl
. typeParameters ;
const params = typeParameters === null || typeParameters === void 0 ? void 0 : typeParameters . params ;
if ( ! params || params . length === 0 ) {
return {
expression : null ,
tokens : [ ] ,
comments : [ ] ,
references : [ ] ,
variables : [ ] ,
} ;
}
const tokens = ast . tokens || [ ] ;
const comments = ast . comments || [ ] ;
const scope = analyzeVariablesAndExternalReferences ( result , "generic" , parserOptions ) ;
const references = scope . references ;
const variables = scope . variables ;
const firstParam = first__default [ "default" ] ( params ) ;
const lastParam = last__default [ "default" ] ( params ) ;
const expression = {
type : "VGenericExpression" ,
range : [ firstParam . range [ 0 ] , lastParam . range [ 1 ] ] ,
loc : { start : firstParam . loc . start , end : lastParam . loc . end } ,
parent : DUMMY_PARENT$2 ,
params ,
rawParams : params . map ( ( param ) => code . slice ( param . range [ 0 ] - typeParameters . range [ 0 ] - 1 , param . range [ 1 ] - typeParameters . range [ 0 ] - 1 ) ) ,
} ;
for ( const param of params ) {
;
param . parent = expression ;
}
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . shift ( ) ;
tokens . pop ( ) ;
tokens . pop ( ) ;
tokens . pop ( ) ;
tokens . pop ( ) ;
tokens . pop ( ) ;
return { expression , tokens , comments , references , variables } ;
}
catch ( err ) {
return throwErrorAsAdjustingOutsideOfCode ( err , code , locationCalculator ) ;
}
}
function replaceTokens ( document , node , newTokens ) {
if ( document == null ) {
return ;
}
const index = sortedIndexBy__default [ "default" ] ( document . tokens , node , byRange0 ) ;
const count = sortedLastIndexBy__default [ "default" ] ( document . tokens , node , byRange1 ) - index ;
document . tokens . splice ( index , count , ... newTokens ) ;
}
function replaceAndSplitTokens ( document , node , newTokens ) {
if ( document == null ) {
return ;
}
const index = sortedIndexBy__default [ "default" ] ( document . tokens , node , byRange0 ) ;
if ( document . tokens . length === index ||
node . range [ 0 ] < document . tokens [ index ] . range [ 0 ] ) {
const beforeToken = document . tokens [ index - 1 ] ;
const value = beforeToken . value ;
const splitOffset = node . range [ 0 ] - beforeToken . range [ 0 ] ;
const afterToken = {
type : beforeToken . type ,
range : [ node . range [ 0 ] , beforeToken . range [ 1 ] ] ,
loc : {
start : Object . assign ( { } , node . loc . start ) ,
end : Object . assign ( { } , beforeToken . loc . end ) ,
} ,
value : value . slice ( splitOffset ) ,
} ;
beforeToken . range [ 1 ] = node . range [ 0 ] ;
beforeToken . loc . end = Object . assign ( { } , node . loc . start ) ;
beforeToken . value = value . slice ( 0 , splitOffset ) ;
document . tokens . splice ( index , 0 , afterToken ) ;
}
let lastIndex = sortedLastIndexBy__default [ "default" ] ( document . tokens , node , byRange1 ) ;
if ( lastIndex === 0 ||
node . range [ 1 ] < document . tokens [ lastIndex ] . range [ 1 ] ) {
const beforeToken = document . tokens [ lastIndex ] ;
const value = beforeToken . value ;
const splitOffset = beforeToken . range [ 1 ] -
beforeToken . range [ 0 ] -
( beforeToken . range [ 1 ] - node . range [ 1 ] ) ;
const afterToken = {
type : beforeToken . type ,
range : [ node . range [ 1 ] , beforeToken . range [ 1 ] ] ,
loc : {
start : Object . assign ( { } , node . loc . end ) ,
end : Object . assign ( { } , beforeToken . loc . end ) ,
} ,
value : value . slice ( splitOffset ) ,
} ;
beforeToken . range [ 1 ] = node . range [ 1 ] ;
beforeToken . loc . end = Object . assign ( { } , node . loc . end ) ;
beforeToken . value = value . slice ( 0 , splitOffset ) ;
document . tokens . splice ( lastIndex + 1 , 0 , afterToken ) ;
lastIndex ++ ;
}
const count = lastIndex - index ;
document . tokens . splice ( index , count , ... newTokens ) ;
}
function insertComments ( document , newComments ) {
if ( document == null || newComments . length === 0 ) {
return ;
}
const index = sortedIndexBy__default [ "default" ] ( document . comments , newComments [ 0 ] , byRange0 ) ;
document . comments . splice ( index , 0 , ... newComments ) ;
}
function createSimpleToken ( type , start , end , value , linesAndColumns ) {
return {
type ,
range : [ start , end ] ,
loc : {
start : linesAndColumns . getLocFromIndex ( start ) ,
end : linesAndColumns . getLocFromIndex ( end ) ,
} ,
value ,
} ;
}
function byRange0 ( x ) {
return x . range [ 0 ] ;
}
function byRange1 ( x ) {
return x . range [ 1 ] ;
}
function insertError ( document , error ) {
if ( document == null ) {
return ;
}
const index = sortedIndexBy__default [ "default" ] ( document . errors , error , byIndex ) ;
document . errors . splice ( index , 0 , error ) ;
}
function byIndex ( x ) {
return x . index ;
}
const shorthandSign = /^[.:@#]/u ;
const shorthandNameMap = { ":" : "bind" , "." : "bind" , "@" : "on" , "#" : "slot" } ;
const invalidDynamicArgumentNextChar = /^[\s\r\n=/>]$/u ;
function getTagName$1 ( startTagOrElement , isSFC ) {
return isSFC ? startTagOrElement . rawName : startTagOrElement . name ;
}
function parseDirectiveKeyStatically ( node , document ) {
const { name : text , rawName : rawText , range : [ offset ] , loc : { start : { column , line } , } , } = node ;
const directiveKey = {
type : "VDirectiveKey" ,
range : node . range ,
loc : node . loc ,
parent : node . parent ,
name : null ,
argument : null ,
modifiers : [ ] ,
} ;
let i = 0 ;
function createIdentifier ( start , end , name ) {
return {
type : "VIdentifier" ,
parent : directiveKey ,
range : [ offset + start , offset + end ] ,
loc : {
start : { column : column + start , line } ,
end : { column : column + end , line } ,
} ,
name : name || text . slice ( start , end ) ,
rawName : rawText . slice ( start , end ) ,
} ;
}
if ( shorthandSign . test ( text ) ) {
const sign = text [ 0 ] ;
directiveKey . name = createIdentifier ( 0 , 1 , shorthandNameMap [ sign ] ) ;
i = 1 ;
}
else {
const colon = text . indexOf ( ":" ) ;
if ( colon !== - 1 ) {
directiveKey . name = createIdentifier ( 0 , colon ) ;
i = colon + 1 ;
}
}
if ( directiveKey . name != null && text [ i ] === "[" ) {
const len = text . slice ( i ) . lastIndexOf ( "]" ) ;
if ( len !== - 1 ) {
directiveKey . argument = createIdentifier ( i , i + len + 1 ) ;
i = i + len + 1 + ( text [ i + len + 1 ] === "." ? 1 : 0 ) ;
}
}
const modifiers = text
. slice ( i )
. split ( "." )
. map ( ( modifierName ) => {
const modifier = createIdentifier ( i , i + modifierName . length ) ;
if ( modifierName === "" && i < text . length ) {
insertError ( document , new ParseError ( ` Unexpected token ' ${ text [ i ] } ' ` , undefined , offset + i , line , column + i ) ) ;
}
i += modifierName . length + 1 ;
return modifier ;
} ) ;
if ( directiveKey . name == null ) {
directiveKey . name = modifiers . shift ( ) ;
}
else if ( directiveKey . argument == null && modifiers [ 0 ] . name !== "" ) {
directiveKey . argument = modifiers . shift ( ) || null ;
}
directiveKey . modifiers = modifiers . filter ( isNotEmptyModifier ) ;
if ( directiveKey . name . name === "v-" ) {
insertError ( document , new ParseError ( ` Unexpected token ' ${ text [ directiveKey . name . range [ 1 ] - offset ] } ' ` , undefined , directiveKey . name . range [ 1 ] , directiveKey . name . loc . end . line , directiveKey . name . loc . end . column ) ) ;
}
if ( directiveKey . name . rawName === "." &&
! directiveKey . modifiers . some ( isPropModifier ) ) {
const pos = ( directiveKey . argument || directiveKey . name ) . range [ 1 ] - offset ;
const propModifier = createIdentifier ( pos , pos , "prop" ) ;
directiveKey . modifiers . unshift ( propModifier ) ;
}
return directiveKey ;
}
function isPropModifier ( node ) {
return node . name === "prop" ;
}
function isNotEmptyModifier ( node ) {
return node . name !== "" ;
}
function parseDirectiveKeyTokens ( node ) {
const { name , argument , modifiers } = node ;
const shorthand = name . range [ 1 ] - name . range [ 0 ] === 1 ;
const tokens = [ ] ;
if ( shorthand ) {
tokens . push ( {
type : "Punctuator" ,
range : name . range ,
loc : name . loc ,
value : name . rawName ,
} ) ;
}
else {
tokens . push ( {
type : "HTMLIdentifier" ,
range : name . range ,
loc : name . loc ,
value : name . rawName ,
} ) ;
if ( argument ) {
tokens . push ( {
type : "Punctuator" ,
range : [ name . range [ 1 ] , argument . range [ 0 ] ] ,
loc : { start : name . loc . end , end : argument . loc . start } ,
value : ":" ,
} ) ;
}
}
if ( argument ) {
tokens . push ( {
type : "HTMLIdentifier" ,
range : argument . range ,
loc : argument . loc ,
value : argument . rawName ,
} ) ;
}
let lastNode = argument || name ;
for ( const modifier of modifiers ) {
if ( modifier . rawName === "" ) {
continue ;
}
tokens . push ( {
type : "Punctuator" ,
range : [ lastNode . range [ 1 ] , modifier . range [ 0 ] ] ,
loc : { start : lastNode . loc . end , end : modifier . loc . start } ,
value : "." ,
} , {
type : "HTMLIdentifier" ,
range : modifier . range ,
loc : modifier . loc ,
value : modifier . rawName ,
} ) ;
lastNode = modifier ;
}
return tokens ;
}
function convertDynamicArgument ( node , document , parserOptions , locationCalculator ) {
const { argument } = node ;
if ( ! ( argument != null &&
argument . type === "VIdentifier" &&
argument . name . startsWith ( "[" ) &&
argument . name . endsWith ( "]" ) ) ) {
return ;
}
const { rawName , range , loc } = argument ;
try {
const { comments , expression , references , tokens } = parseExpression ( rawName . slice ( 1 , - 1 ) , locationCalculator . getSubCalculatorAfter ( range [ 0 ] + 1 ) , parserOptions ) ;
node . argument = {
type : "VExpressionContainer" ,
range ,
loc ,
parent : node ,
expression ,
references ,
} ;
if ( expression != null ) {
expression . parent = node . argument ;
}
tokens . unshift ( createSimpleToken ( "Punctuator" , range [ 0 ] , range [ 0 ] + 1 , "[" , locationCalculator ) ) ;
tokens . push ( createSimpleToken ( "Punctuator" , range [ 1 ] - 1 , range [ 1 ] , "]" , locationCalculator ) ) ;
replaceTokens ( document , node . argument , tokens ) ;
insertComments ( document , comments ) ;
}
catch ( error ) {
debug ( "[template] Parse error: %s" , error ) ;
if ( ParseError . isParseError ( error ) ) {
node . argument = {
type : "VExpressionContainer" ,
range ,
loc ,
parent : node ,
expression : null ,
references : [ ] ,
} ;
insertError ( document , error ) ;
}
else {
throw error ;
}
}
}
function createDirectiveKey ( node , document , parserOptions , locationCalculator ) {
const directiveKey = parseDirectiveKeyStatically ( node , document ) ;
const tokens = parseDirectiveKeyTokens ( directiveKey ) ;
replaceTokens ( document , directiveKey , tokens ) ;
if ( directiveKey . name . name . startsWith ( "v-" ) ) {
directiveKey . name . name = directiveKey . name . name . slice ( 2 ) ;
}
if ( directiveKey . name . rawName . startsWith ( "v-" ) ) {
directiveKey . name . rawName = directiveKey . name . rawName . slice ( 2 ) ;
}
convertDynamicArgument ( directiveKey , document , parserOptions , locationCalculator ) ;
return directiveKey ;
}
function parseAttributeValue ( code , parserOptions , scriptParserOptions , globalLocationCalculator , node , element , directiveKey ) {
const firstChar = code [ node . range [ 0 ] ] ;
const quoted = firstChar === '"' || firstChar === "'" ;
const locationCalculator = globalLocationCalculator . getSubCalculatorAfter ( node . range [ 0 ] + ( quoted ? 1 : 0 ) ) ;
const directiveKind = getStandardDirectiveKind ( parserOptions , element , directiveKey ) ;
let result ;
if ( quoted && node . value === "" ) {
result = {
expression : null ,
tokens : [ ] ,
comments : [ ] ,
variables : [ ] ,
references : [ ] ,
} ;
}
else if ( directiveKind === "for" ) {
result = parseVForExpression ( node . value , locationCalculator , parserOptions ) ;
}
else if ( directiveKind === "on" && directiveKey . argument != null ) {
result = parseVOnExpression ( node . value , locationCalculator , parserOptions ) ;
}
else if ( directiveKind === "slot" ) {
result = parseSlotScopeExpression ( node . value , locationCalculator , parserOptions ) ;
}
else if ( directiveKind === "bind" ) {
result = parseExpression ( node . value , locationCalculator , parserOptions , { allowFilters : true } ) ;
}
else if ( directiveKind === "generic" ) {
result = parseGenericExpression ( node . value , locationCalculator , scriptParserOptions ) ;
}
else {
result = parseExpression ( node . value , locationCalculator , parserOptions ) ;
}
if ( quoted ) {
result . tokens . unshift ( createSimpleToken ( "Punctuator" , node . range [ 0 ] , node . range [ 0 ] + 1 , firstChar , globalLocationCalculator ) ) ;
result . tokens . push ( createSimpleToken ( "Punctuator" , node . range [ 1 ] - 1 , node . range [ 1 ] , firstChar , globalLocationCalculator ) ) ;
}
return result ;
}
function getStandardDirectiveKind ( parserOptions , element , directiveKey ) {
const directiveName = directiveKey . name . name ;
if ( directiveName === "for" ) {
return "for" ;
}
else if ( directiveName === "on" ) {
return "on" ;
}
else if ( directiveName === "slot" ||
directiveName === "slot-scope" ||
( directiveName === "scope" &&
getTagName$1 ( element , isSFCFile ( parserOptions ) ) === "template" ) ) {
return "slot" ;
}
else if ( directiveName === "bind" ) {
return "bind" ;
}
else if ( directiveName === "generic" &&
element . parent . type === "VDocumentFragment" &&
getTagName$1 ( element , isSFCFile ( parserOptions ) ) === "script" &&
isScriptSetupElement ( element ) &&
isTSLang ( element ) ) {
return "generic" ;
}
return null ;
}
function resolveReference ( referene , element ) {
let node = element ;
while ( node != null && node . type === "VElement" ) {
for ( const variable of node . variables ) {
if ( variable . id . name === referene . id . name ) {
referene . variable = variable ;
variable . references . push ( referene ) ;
return ;
}
}
node = node . parent ;
}
}
function convertToDirective ( code , parserOptions , scriptParserOptions , locationCalculator , node ) {
debug ( '[template] convert to directive: %s="%s" %j' , node . key . name , node . value && node . value . value , node . range ) ;
const document = getOwnerDocument ( node ) ;
const directive = node ;
directive . directive = true ;
directive . key = createDirectiveKey ( node . key , document , parserOptions , locationCalculator ) ;
const { argument } = directive . key ;
if ( argument &&
argument . type === "VIdentifier" &&
argument . name . startsWith ( "[" ) ) {
const nextChar = code [ argument . range [ 1 ] ] ;
if ( nextChar == null || invalidDynamicArgumentNextChar . test ( nextChar ) ) {
const char = nextChar == null ? "EOF" : JSON . stringify ( nextChar ) . slice ( 1 , - 1 ) ;
insertError ( document , new ParseError ( ` Dynamic argument cannot contain the ' ${ char } ' character. ` , undefined , argument . range [ 1 ] , argument . loc . end . line , argument . loc . end . column ) ) ;
}
}
if ( node . value == null ) {
return ;
}
try {
const ret = parseAttributeValue ( code , parserOptions , scriptParserOptions , locationCalculator , node . value , node . parent . parent , directive . key ) ;
directive . value = {
type : "VExpressionContainer" ,
range : node . value . range ,
loc : node . value . loc ,
parent : directive ,
expression : ret . expression ,
references : ret . references ,
} ;
if ( ret . expression != null ) {
ret . expression . parent = directive . value ;
}
for ( const variable of ret . variables ) {
node . parent . parent . variables . push ( variable ) ;
}
replaceTokens ( document , node . value , ret . tokens ) ;
insertComments ( document , ret . comments ) ;
}
catch ( err ) {
debug ( "[template] Parse error: %s" , err ) ;
if ( ParseError . isParseError ( err ) ) {
directive . value = {
type : "VExpressionContainer" ,
range : node . value . range ,
loc : node . value . loc ,
parent : directive ,
expression : null ,
references : [ ] ,
} ;
insertError ( document , err ) ;
}
else {
throw err ;
}
}
}
function processMustache ( parserOptions , globalLocationCalculator , node , mustache ) {
const range = [
mustache . startToken . range [ 1 ] ,
mustache . endToken . range [ 0 ] ,
] ;
debug ( "[template] convert mustache {{%s}} %j" , mustache . value , range ) ;
const document = getOwnerDocument ( node ) ;
try {
const locationCalculator = globalLocationCalculator . getSubCalculatorAfter ( range [ 0 ] ) ;
const ret = parseExpression ( mustache . value , locationCalculator , parserOptions , { allowEmpty : true , allowFilters : true } ) ;
node . expression = ret . expression || null ;
node . references = ret . references ;
if ( ret . expression != null ) {
ret . expression . parent = node ;
}
replaceTokens ( document , { range } , ret . tokens ) ;
insertComments ( document , ret . comments ) ;
}
catch ( err ) {
debug ( "[template] Parse error: %s" , err ) ;
if ( ParseError . isParseError ( err ) ) {
insertError ( document , err ) ;
}
else {
throw err ;
}
}
}
function resolveReferences ( container ) {
let element = container . parent ;
while ( element != null && element . type !== "VElement" ) {
element = element . parent ;
}
if ( element != null ) {
for ( const reference of container . references ) {
resolveReference ( reference , element ) ;
}
}
}
const SVG_ATTRIBUTE_NAME_MAP = new Map ( [
[ "attributename" , "attributeName" ] ,
[ "attributetype" , "attributeType" ] ,
[ "basefrequency" , "baseFrequency" ] ,
[ "baseprofile" , "baseProfile" ] ,
[ "calcmode" , "calcMode" ] ,
[ "clippathunits" , "clipPathUnits" ] ,
[ "diffuseconstant" , "diffuseConstant" ] ,
[ "edgemode" , "edgeMode" ] ,
[ "filterunits" , "filterUnits" ] ,
[ "glyphref" , "glyphRef" ] ,
[ "gradienttransform" , "gradientTransform" ] ,
[ "gradientunits" , "gradientUnits" ] ,
[ "kernelmatrix" , "kernelMatrix" ] ,
[ "kernelunitlength" , "kernelUnitLength" ] ,
[ "keypoints" , "keyPoints" ] ,
[ "keysplines" , "keySplines" ] ,
[ "keytimes" , "keyTimes" ] ,
[ "lengthadjust" , "lengthAdjust" ] ,
[ "limitingconeangle" , "limitingConeAngle" ] ,
[ "markerheight" , "markerHeight" ] ,
[ "markerunits" , "markerUnits" ] ,
[ "markerwidth" , "markerWidth" ] ,
[ "maskcontentunits" , "maskContentUnits" ] ,
[ "maskunits" , "maskUnits" ] ,
[ "numoctaves" , "numOctaves" ] ,
[ "pathlength" , "pathLength" ] ,
[ "patterncontentunits" , "patternContentUnits" ] ,
[ "patterntransform" , "patternTransform" ] ,
[ "patternunits" , "patternUnits" ] ,
[ "pointsatx" , "pointsAtX" ] ,
[ "pointsaty" , "pointsAtY" ] ,
[ "pointsatz" , "pointsAtZ" ] ,
[ "preservealpha" , "preserveAlpha" ] ,
[ "preserveaspectratio" , "preserveAspectRatio" ] ,
[ "primitiveunits" , "primitiveUnits" ] ,
[ "refx" , "refX" ] ,
[ "refy" , "refY" ] ,
[ "repeatcount" , "repeatCount" ] ,
[ "repeatdur" , "repeatDur" ] ,
[ "requiredextensions" , "requiredExtensions" ] ,
[ "requiredfeatures" , "requiredFeatures" ] ,
[ "specularconstant" , "specularConstant" ] ,
[ "specularexponent" , "specularExponent" ] ,
[ "spreadmethod" , "spreadMethod" ] ,
[ "startoffset" , "startOffset" ] ,
[ "stddeviation" , "stdDeviation" ] ,
[ "stitchtiles" , "stitchTiles" ] ,
[ "surfacescale" , "surfaceScale" ] ,
[ "systemlanguage" , "systemLanguage" ] ,
[ "tablevalues" , "tableValues" ] ,
[ "targetx" , "targetX" ] ,
[ "targety" , "targetY" ] ,
[ "textlength" , "textLength" ] ,
[ "viewbox" , "viewBox" ] ,
[ "viewtarget" , "viewTarget" ] ,
[ "xchannelselector" , "xChannelSelector" ] ,
[ "ychannelselector" , "yChannelSelector" ] ,
[ "zoomandpan" , "zoomAndPan" ] ,
] ) ;
const MATHML_ATTRIBUTE_NAME_MAP = new Map ( [
[ "definitionurl" , "definitionUrl" ]
] ) ;
const HTML_VOID_ELEMENT_TAGS = new Set ( [
"area" , "base" , "br" , "col" , "embed" , "hr" , "img" , "input" , "link" , "meta" ,
"param" , "source" , "track" , "wbr" ,
] ) ;
const HTML_CAN_BE_LEFT_OPEN_TAGS = new Set ( [
"colgroup" , "li" , "options" , "p" , "td" , "tfoot" , "th" , "thead" ,
"tr" , "source" ,
] ) ;
const HTML_NON_FHRASING_TAGS = new Set ( [
"address" , "article" , "aside" , "base" , "blockquote" , "body" , "caption" ,
"col" , "colgroup" , "dd" , "details" , "dialog" , "div" , "dl" , "dt" , "fieldset" ,
"figcaption" , "figure" , "footer" , "form" , "h1" , "h2" , "h3" , "h4" , "h5" ,
"h6" , "head" , "header" , "hgroup" , "hr" , "html" , "legend" , "li" , "menuitem" ,
"meta" , "optgroup" , "option" , "param" , "rp" , "rt" , "source" , "style" ,
"summary" , "tbody" , "td" , "tfoot" , "th" , "thead" , "title" , "tr" , "track" ,
] ) ;
const HTML_RCDATA_TAGS = new Set ( [
"title" , "textarea" ,
] ) ;
const HTML_RAWTEXT_TAGS = new Set ( [
"style" , "xmp" , "iframe" , "noembed" , "noframes" , "noscript" , "script" ,
] ) ;
const SVG_TAGS$1 = new Set ( [
"a" , "altGlyph" , "altGlyphDef" , "altGlyphItem" , "animate" , "animateColor" ,
"animateMotion" , "animateTransform" , "animation" , "audio" , "canvas" ,
"circle" , "clipPath" , "color-profile" , "cursor" , "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" , "font" , "font-face" ,
"font-face-format" , "font-face-name" , "font-face-src" , "font-face-uri" ,
"foreignObject" , "g" , "glyph" , "glyphRef" , "handler" , "hatch" , "hatchpath" ,
"hkern" , "iframe" , "image" , "line" , "linearGradient" , "listener" , "marker" ,
"mask" , "mesh" , "meshgradient" , "meshpatch" , "meshrow" , "metadata" ,
"missing-glyph" , "mpath" , "path" , "pattern" , "polygon" , "polyline" ,
"prefetch" , "radialGradient" , "rect" , "script" , "set" , "solidColor" ,
"solidcolor" , "stop" , "style" , "svg" , "switch" , "symbol" , "tbreak" , "text" ,
"textArea" , "textPath" , "title" , "tref" , "tspan" , "unknown" , "use" , "video" ,
"view" , "vkern" ,
] ) ;
const SVG_ELEMENT_NAME_MAP = new Map ( ) ;
for ( const name of SVG_TAGS$1 ) {
if ( /[A-Z]/ . test ( name ) ) {
SVG_ELEMENT_NAME_MAP . set ( name . toLowerCase ( ) , name ) ;
}
}
const DUMMY_PARENT$1 = Object . freeze ( { } ) ;
function concat ( text , token ) {
return text + token . value ;
}
class IntermediateTokenizer {
constructor ( tokenizer ) {
this . tokenizer = tokenizer ;
this . currentToken = null ;
this . attribute = null ;
this . attributeNames = new Set ( ) ;
this . expressionStartToken = null ;
this . expressionTokens = [ ] ;
this . tokens = [ ] ;
this . comments = [ ] ;
}
get text ( ) {
return this . tokenizer . text ;
}
get errors ( ) {
return this . tokenizer . errors ;
}
get state ( ) {
return this . tokenizer . state ;
}
set state ( value ) {
this . tokenizer . state = value ;
}
get namespace ( ) {
return this . tokenizer . namespace ;
}
set namespace ( value ) {
this . tokenizer . namespace = value ;
}
get expressionEnabled ( ) {
return this . tokenizer . expressionEnabled ;
}
set expressionEnabled ( value ) {
this . tokenizer . expressionEnabled = value ;
}
nextToken ( ) {
let token = null ;
let result = null ;
while ( result == null && ( token = this . tokenizer . nextToken ( ) ) != null ) {
result = this [ token . type ] ( token ) ;
}
if ( result == null && token == null && this . currentToken != null ) {
result = this . commit ( ) ;
}
return result ;
}
commit ( ) {
assert__default [ "default" ] ( this . currentToken != null || this . expressionStartToken != null ) ;
let token = this . currentToken ;
this . currentToken = null ;
this . attribute = null ;
if ( this . expressionStartToken != null ) {
const start = this . expressionStartToken ;
const end = last__default [ "default" ] ( this . expressionTokens ) || start ;
const value = this . expressionTokens . reduce ( concat , start . value ) ;
this . expressionStartToken = null ;
this . expressionTokens = [ ] ;
if ( token == null ) {
token = {
type : "Text" ,
range : [ start . range [ 0 ] , end . range [ 1 ] ] ,
loc : { start : start . loc . start , end : end . loc . end } ,
value ,
} ;
}
else if ( token . type === "Text" ) {
token . range [ 1 ] = end . range [ 1 ] ;
token . loc . end = end . loc . end ;
token . value += value ;
}
else {
throw new Error ( "unreachable" ) ;
}
}
return token ;
}
reportParseError ( token , code ) {
const error = ParseError . fromCode ( code , token . range [ 0 ] , token . loc . start . line , token . loc . start . column ) ;
this . errors . push ( error ) ;
debug ( "[html] syntax error:" , error . message ) ;
}
processComment ( token ) {
this . comments . push ( token ) ;
if ( this . currentToken != null && this . currentToken . type === "Text" ) {
return this . commit ( ) ;
}
return null ;
}
processText ( token ) {
this . tokens . push ( token ) ;
let result = null ;
if ( this . expressionStartToken != null ) {
const lastToken = last__default [ "default" ] ( this . expressionTokens ) || this . expressionStartToken ;
if ( lastToken . range [ 1 ] === token . range [ 0 ] ) {
this . expressionTokens . push ( token ) ;
return null ;
}
result = this . commit ( ) ;
}
else if ( this . currentToken != null ) {
if ( this . currentToken . type === "Text" &&
this . currentToken . range [ 1 ] === token . range [ 0 ] ) {
this . currentToken . value += token . value ;
this . currentToken . range [ 1 ] = token . range [ 1 ] ;
this . currentToken . loc . end = token . loc . end ;
return null ;
}
result = this . commit ( ) ;
}
assert__default [ "default" ] ( this . currentToken == null ) ;
this . currentToken = {
type : "Text" ,
range : [ token . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : token . loc . start , end : token . loc . end } ,
value : token . value ,
} ;
return result ;
}
HTMLAssociation ( token ) {
this . tokens . push ( token ) ;
if ( this . attribute != null ) {
this . attribute . range [ 1 ] = token . range [ 1 ] ;
this . attribute . loc . end = token . loc . end ;
if ( this . currentToken == null ||
this . currentToken . type !== "StartTag" ) {
throw new Error ( "unreachable" ) ;
}
this . currentToken . range [ 1 ] = token . range [ 1 ] ;
this . currentToken . loc . end = token . loc . end ;
}
return null ;
}
HTMLBogusComment ( token ) {
return this . processComment ( token ) ;
}
HTMLCDataText ( token ) {
return this . processText ( token ) ;
}
HTMLComment ( token ) {
return this . processComment ( token ) ;
}
HTMLEndTagOpen ( token ) {
this . tokens . push ( token ) ;
let result = null ;
if ( this . currentToken != null || this . expressionStartToken != null ) {
result = this . commit ( ) ;
}
this . currentToken = {
type : "EndTag" ,
range : [ token . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : token . loc . start , end : token . loc . end } ,
name : token . value ,
} ;
return result ;
}
HTMLIdentifier ( token ) {
this . tokens . push ( token ) ;
if ( this . currentToken == null ||
this . currentToken . type === "Text" ||
this . currentToken . type === "Mustache" ) {
throw new Error ( "unreachable" ) ;
}
if ( this . currentToken . type === "EndTag" ) {
this . reportParseError ( token , "end-tag-with-attributes" ) ;
return null ;
}
if ( this . attributeNames . has ( token . value ) ) {
this . reportParseError ( token , "duplicate-attribute" ) ;
}
this . attributeNames . add ( token . value ) ;
this . attribute = {
type : "VAttribute" ,
range : [ token . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : token . loc . start , end : token . loc . end } ,
parent : DUMMY_PARENT$1 ,
directive : false ,
key : {
type : "VIdentifier" ,
range : [ token . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : token . loc . start , end : token . loc . end } ,
parent : DUMMY_PARENT$1 ,
name : token . value ,
rawName : this . text . slice ( token . range [ 0 ] , token . range [ 1 ] ) ,
} ,
value : null ,
} ;
this . attribute . key . parent = this . attribute ;
this . currentToken . range [ 1 ] = token . range [ 1 ] ;
this . currentToken . loc . end = token . loc . end ;
this . currentToken . attributes . push ( this . attribute ) ;
return null ;
}
HTMLLiteral ( token ) {
this . tokens . push ( token ) ;
if ( this . attribute != null ) {
this . attribute . range [ 1 ] = token . range [ 1 ] ;
this . attribute . loc . end = token . loc . end ;
this . attribute . value = {
type : "VLiteral" ,
range : [ token . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : token . loc . start , end : token . loc . end } ,
parent : this . attribute ,
value : token . value ,
} ;
if ( this . currentToken == null ||
this . currentToken . type !== "StartTag" ) {
throw new Error ( "unreachable" ) ;
}
this . currentToken . range [ 1 ] = token . range [ 1 ] ;
this . currentToken . loc . end = token . loc . end ;
}
return null ;
}
HTMLRCDataText ( token ) {
return this . processText ( token ) ;
}
HTMLRawText ( token ) {
return this . processText ( token ) ;
}
HTMLSelfClosingTagClose ( token ) {
this . tokens . push ( token ) ;
if ( this . currentToken == null || this . currentToken . type === "Text" ) {
throw new Error ( "unreachable" ) ;
}
if ( this . currentToken . type === "StartTag" ) {
this . currentToken . selfClosing = true ;
}
else {
this . reportParseError ( token , "end-tag-with-trailing-solidus" ) ;
}
this . currentToken . range [ 1 ] = token . range [ 1 ] ;
this . currentToken . loc . end = token . loc . end ;
return this . commit ( ) ;
}
HTMLTagClose ( token ) {
this . tokens . push ( token ) ;
if ( this . currentToken == null || this . currentToken . type === "Text" ) {
throw new Error ( "unreachable" ) ;
}
this . currentToken . range [ 1 ] = token . range [ 1 ] ;
this . currentToken . loc . end = token . loc . end ;
return this . commit ( ) ;
}
HTMLTagOpen ( token ) {
this . tokens . push ( token ) ;
let result = null ;
if ( this . currentToken != null || this . expressionStartToken != null ) {
result = this . commit ( ) ;
}
this . currentToken = {
type : "StartTag" ,
range : [ token . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : token . loc . start , end : token . loc . end } ,
name : token . value ,
rawName : this . text . slice ( token . range [ 0 ] + 1 , token . range [ 1 ] ) ,
selfClosing : false ,
attributes : [ ] ,
} ;
this . attribute = null ;
this . attributeNames . clear ( ) ;
return result ;
}
HTMLText ( token ) {
return this . processText ( token ) ;
}
HTMLWhitespace ( token ) {
return this . processText ( token ) ;
}
VExpressionStart ( token ) {
if ( this . expressionStartToken != null ) {
return this . processText ( token ) ;
}
const separated = this . currentToken != null &&
this . currentToken . range [ 1 ] !== token . range [ 0 ] ;
const result = separated ? this . commit ( ) : null ;
this . tokens . push ( token ) ;
this . expressionStartToken = token ;
return result ;
}
VExpressionEnd ( token ) {
if ( this . expressionStartToken == null ) {
return this . processText ( token ) ;
}
const start = this . expressionStartToken ;
const end = last__default [ "default" ] ( this . expressionTokens ) || start ;
if ( token . range [ 0 ] === start . range [ 1 ] ) {
this . tokens . pop ( ) ;
this . expressionStartToken = null ;
const result = this . processText ( start ) ;
this . processText ( token ) ;
return result ;
}
if ( end . range [ 1 ] !== token . range [ 0 ] ) {
const result = this . commit ( ) ;
this . processText ( token ) ;
return result ;
}
const value = this . expressionTokens . reduce ( concat , "" ) ;
this . tokens . push ( token ) ;
this . expressionStartToken = null ;
this . expressionTokens = [ ] ;
const result = this . currentToken != null ? this . commit ( ) : null ;
this . currentToken = {
type : "Mustache" ,
range : [ start . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : start . loc . start , end : token . loc . end } ,
value ,
startToken : start ,
endToken : token ,
} ;
return result || this . commit ( ) ;
}
}
const DIRECTIVE_NAME = /^(?:v-|[.:@#]).*[^.:@#]$/u ;
const DT_DD = /^d[dt]$/u ;
const DUMMY_PARENT = Object . freeze ( { } ) ;
function getTagName ( startTagOrElement , isSFC ) {
return isSFC ? startTagOrElement . rawName : startTagOrElement . name ;
}
function isMathMLIntegrationPoint ( element , isSFC ) {
if ( element . namespace === NS . MathML ) {
const name = getTagName ( element , isSFC ) ;
return ( name === "mi" ||
name === "mo" ||
name === "mn" ||
name === "ms" ||
name === "mtext" ) ;
}
return false ;
}
function isHTMLIntegrationPoint ( element , isSFC ) {
if ( element . namespace === NS . MathML ) {
return ( getTagName ( element , isSFC ) === "annotation-xml" &&
element . startTag . attributes . some ( ( a ) => a . directive === false &&
a . key . name === "encoding" &&
a . value != null &&
( a . value . value === "text/html" ||
a . value . value === "application/xhtml+xml" ) ) ) ;
}
if ( element . namespace === NS . SVG ) {
const name = getTagName ( element , isSFC ) ;
return name === "foreignObject" || name === "desc" || name === "title" ;
}
return false ;
}
function adjustElementName ( name , namespace ) {
if ( namespace === NS . SVG ) {
return SVG_ELEMENT_NAME_MAP . get ( name ) || name ;
}
return name ;
}
function adjustAttributeName ( name , namespace ) {
if ( namespace === NS . SVG ) {
return SVG_ATTRIBUTE_NAME_MAP . get ( name ) || name ;
}
if ( namespace === NS . MathML ) {
return MATHML_ATTRIBUTE_NAME_MAP . get ( name ) || name ;
}
return name ;
}
function propagateEndLocation ( node ) {
const lastChild = ( node . type === "VElement" ? node . endTag : null ) || last__default [ "default" ] ( node . children ) ;
if ( lastChild != null ) {
node . range [ 1 ] = lastChild . range [ 1 ] ;
node . loc . end = lastChild . loc . end ;
}
}
class Parser {
constructor ( tokenizer , parserOptions ) {
this . postProcessesForScript = [ ] ;
this . tokenizer = new IntermediateTokenizer ( tokenizer ) ;
this . locationCalculator = new LocationCalculatorForHtml ( tokenizer . gaps , tokenizer . lineTerminators ) ;
this . baseParserOptions = parserOptions ;
this . isSFC = isSFCFile ( parserOptions ) ;
this . document = {
type : "VDocumentFragment" ,
range : [ 0 , 0 ] ,
loc : {
start : { line : 1 , column : 0 } ,
end : { line : 1 , column : 0 } ,
} ,
parent : null ,
children : [ ] ,
tokens : this . tokens ,
comments : this . comments ,
errors : this . errors ,
} ;
this . elementStack = [ ] ;
this . vPreElement = null ;
this . postProcessesForScript = [ ] ;
}
get text ( ) {
return this . tokenizer . text ;
}
get tokens ( ) {
return this . tokenizer . tokens ;
}
get comments ( ) {
return this . tokenizer . comments ;
}
get errors ( ) {
return this . tokenizer . errors ;
}
get namespace ( ) {
return this . tokenizer . namespace ;
}
set namespace ( value ) {
this . tokenizer . namespace = value ;
}
get expressionEnabled ( ) {
return this . tokenizer . expressionEnabled ;
}
set expressionEnabled ( value ) {
this . tokenizer . expressionEnabled = value ;
}
get currentNode ( ) {
return last__default [ "default" ] ( this . elementStack ) || this . document ;
}
get isInVPreElement ( ) {
return this . vPreElement != null ;
}
parse ( ) {
let token = null ;
while ( ( token = this . tokenizer . nextToken ( ) ) != null ) {
this [ token . type ] ( token ) ;
}
this . popElementStackUntil ( 0 ) ;
propagateEndLocation ( this . document ) ;
const doc = this . document ;
const htmlParserOptions = Object . assign ( Object . assign ( { } , this . baseParserOptions ) , { parser : getScriptParser ( this . baseParserOptions . parser , function * ( ) {
yield "<template>" ;
yield getParserLangFromSFC ( doc ) ;
} ) } ) ;
const scriptParserOptions = Object . assign ( Object . assign ( { } , this . baseParserOptions ) , { parser : getScriptParser ( this . baseParserOptions . parser , ( ) => getParserLangFromSFC ( doc ) ) } ) ;
for ( const proc of this . postProcessesForScript ) {
proc ( htmlParserOptions , scriptParserOptions ) ;
}
this . postProcessesForScript = [ ] ;
return doc ;
}
reportParseError ( token , code ) {
const error = ParseError . fromCode ( code , token . range [ 0 ] , token . loc . start . line , token . loc . start . column ) ;
this . errors . push ( error ) ;
debug ( "[html] syntax error:" , error . message ) ;
}
popElementStack ( ) {
assert__default [ "default" ] ( this . elementStack . length >= 1 ) ;
const element = this . elementStack . pop ( ) ;
propagateEndLocation ( element ) ;
const current = this . currentNode ;
this . namespace =
current . type === "VElement" ? current . namespace : NS . HTML ;
if ( this . vPreElement === element ) {
this . vPreElement = null ;
this . expressionEnabled = true ;
}
if ( this . elementStack . length === 0 ) {
this . expressionEnabled = false ;
}
}
popElementStackUntil ( index ) {
while ( this . elementStack . length > index ) {
this . popElementStack ( ) ;
}
}
getTagName ( startTagOrElement ) {
return getTagName ( startTagOrElement , this . isSFC ) ;
}
detectNamespace ( token ) {
const name = this . getTagName ( token ) ;
let ns = this . namespace ;
if ( ns === NS . MathML || ns === NS . SVG ) {
const element = this . currentNode ;
if ( element . type === "VElement" ) {
if ( element . namespace === NS . MathML &&
this . getTagName ( element ) === "annotation-xml" &&
name === "svg" ) {
return NS . SVG ;
}
if ( isHTMLIntegrationPoint ( element , this . isSFC ) ||
( isMathMLIntegrationPoint ( element , this . isSFC ) &&
name !== "mglyph" &&
name !== "malignmark" ) ) {
ns = NS . HTML ;
}
}
}
if ( ns === NS . HTML ) {
if ( name === "svg" ) {
return NS . SVG ;
}
if ( name === "math" ) {
return NS . MathML ;
}
}
if ( name === "template" ) {
const xmlns = token . attributes . find ( ( a ) => a . key . name === "xmlns" ) ;
const value = xmlns && xmlns . value && xmlns . value . value ;
if ( value === NS . HTML || value === NS . MathML || value === NS . SVG ) {
return value ;
}
}
return ns ;
}
closeCurrentElementIfNecessary ( token ) {
const element = this . currentNode ;
if ( element . type !== "VElement" ) {
return ;
}
const name = this . getTagName ( token ) ;
const elementName = this . getTagName ( element ) ;
if ( elementName === "p" && HTML_NON_FHRASING_TAGS . has ( name ) ) {
this . popElementStack ( ) ;
}
if ( elementName === name && HTML_CAN_BE_LEFT_OPEN_TAGS . has ( name ) ) {
this . popElementStack ( ) ;
}
if ( DT_DD . test ( elementName ) && DT_DD . test ( name ) ) {
this . popElementStack ( ) ;
}
}
processAttribute ( node , namespace ) {
if ( this . needConvertToDirective ( node ) ) {
this . postProcessesForScript . push ( ( parserOptions , scriptParserOptions ) => {
convertToDirective ( this . text , parserOptions , scriptParserOptions , this . locationCalculator , node ) ;
} ) ;
return ;
}
node . key . name = adjustAttributeName ( node . key . name , namespace ) ;
const key = this . getTagName ( node . key ) ;
const value = node . value && node . value . value ;
if ( key === "xmlns" && value !== namespace ) {
this . reportParseError ( node , "x-invalid-namespace" ) ;
}
else if ( key === "xmlns:xlink" && value !== NS . XLink ) {
this . reportParseError ( node , "x-invalid-namespace" ) ;
}
}
needConvertToDirective ( node ) {
const element = node . parent . parent ;
const tagName = this . getTagName ( element ) ;
const attrName = this . getTagName ( node . key ) ;
if ( attrName === "generic" &&
element . parent . type === "VDocumentFragment" &&
isScriptSetupElement ( element ) &&
isTSLang ( element ) ) {
return true ;
}
const expressionEnabled = this . expressionEnabled ||
( attrName === "v-pre" && ! this . isInVPreElement ) ;
if ( ! expressionEnabled ) {
return false ;
}
return ( DIRECTIVE_NAME . test ( attrName ) ||
attrName === "slot-scope" ||
( tagName === "template" && attrName === "scope" ) ) ;
}
processTemplateText ( token , templateTokenizerOption ) {
const TemplateTokenizer = typeof templateTokenizerOption === "function"
? templateTokenizerOption
:
require ( templateTokenizerOption ) ;
const templateTokenizer = new TemplateTokenizer ( token . value , this . text , {
startingLine : token . loc . start . line ,
startingColumn : token . loc . start . column ,
} ) ;
const rootTokenizer = this . tokenizer ;
this . tokenizer = templateTokenizer ;
let templateToken = null ;
while ( ( templateToken = templateTokenizer . nextToken ( ) ) != null ) {
this [ templateToken . type ] ( templateToken ) ;
}
this . tokenizer = rootTokenizer ;
const index = sortedIndexBy__default [ "default" ] ( this . tokenizer . tokens , token , ( x ) => x . range [ 0 ] ) ;
const count = sortedLastIndexBy__default [ "default" ] ( this . tokenizer . tokens , token , ( x ) => x . range [ 1 ] ) -
index ;
this . tokenizer . tokens . splice ( index , count , ... templateTokenizer . tokens ) ;
this . tokenizer . comments . push ( ... templateTokenizer . comments ) ;
this . tokenizer . errors . push ( ... templateTokenizer . errors ) ;
}
StartTag ( token ) {
var _ a ;
debug ( "[html] StartTag %j" , token ) ;
this . closeCurrentElementIfNecessary ( token ) ;
const parent = this . currentNode ;
const namespace = this . detectNamespace ( token ) ;
const element = {
type : "VElement" ,
range : [ token . range [ 0 ] , token . range [ 1 ] ] ,
loc : { start : token . loc . start , end : token . loc . end } ,
parent ,
name : adjustElementName ( token . name , namespace ) ,
rawName : token . rawName ,
namespace ,
startTag : {
type : "VStartTag" ,
range : token . range ,
loc : token . loc ,
parent : DUMMY_PARENT ,
selfClosing : token . selfClosing ,
attributes : token . attributes ,
} ,
children : [ ] ,
endTag : null ,
variables : [ ] ,
} ;
const hasVPre = ! this . isInVPreElement &&
token . attributes . some ( ( a ) => this . getTagName ( a . key ) === "v-pre" ) ;
if ( hasVPre ) {
this . expressionEnabled = false ;
}
parent . children . push ( element ) ;
element . startTag . parent = element ;
for ( const attribute of token . attributes ) {
attribute . parent = element . startTag ;
this . processAttribute ( attribute , namespace ) ;
}
this . postProcessesForScript . push ( ( ) => {
for ( const attribute of element . startTag . attributes ) {
if ( attribute . directive ) {
if ( attribute . key . argument != null &&
attribute . key . argument . type === "VExpressionContainer" ) {
resolveReferences ( attribute . key . argument ) ;
}
if ( attribute . value != null ) {
resolveReferences ( attribute . value ) ;
}
}
}
} ) ;
const isVoid = namespace === NS . HTML &&
HTML_VOID_ELEMENT_TAGS . has ( this . getTagName ( element ) ) ;
if ( token . selfClosing && ! isVoid && namespace === NS . HTML ) {
this . reportParseError ( token , "non-void-html-element-start-tag-with-trailing-solidus" ) ;
}
if ( token . selfClosing || isVoid ) {
this . expressionEnabled = ! this . isInVPreElement ;
return ;
}
this . elementStack . push ( element ) ;
if ( hasVPre ) {
assert__default [ "default" ] ( this . vPreElement === null ) ;
this . vPreElement = element ;
}
this . namespace = namespace ;
if ( namespace === NS . HTML ) {
const elementName = this . getTagName ( element ) ;
if ( element . parent . type === "VDocumentFragment" ) {
const langAttr = element . startTag . attributes . find ( ( a ) => ! a . directive && a . key . name === "lang" ) ;
const lang = ( _ a = langAttr === null || langAttr === void 0 ? void 0 : langAttr . value ) === null || _ a === void 0 ? void 0 : _ a . value ;
if ( elementName === "template" ) {
this . expressionEnabled = true ;
if ( lang && lang !== "html" ) {
this . tokenizer . state = "RAWTEXT" ;
this . expressionEnabled = false ;
}
}
else if ( this . isSFC ) {
if ( ! lang || lang !== "html" ) {
this . tokenizer . state = "RAWTEXT" ;
}
}
else {
if ( HTML_RCDATA_TAGS . has ( elementName ) ) {
this . tokenizer . state = "RCDATA" ;
}
if ( HTML_RAWTEXT_TAGS . has ( elementName ) ) {
this . tokenizer . state = "RAWTEXT" ;
}
}
}
else {
if ( HTML_RCDATA_TAGS . has ( elementName ) ) {
this . tokenizer . state = "RCDATA" ;
}
if ( HTML_RAWTEXT_TAGS . has ( elementName ) ) {
this . tokenizer . state = "RAWTEXT" ;
}
}
}
}
EndTag ( token ) {
debug ( "[html] EndTag %j" , token ) ;
const i = findLastIndex__default [ "default" ] ( this . elementStack , ( el ) => el . name . toLowerCase ( ) === token . name ) ;
if ( i === - 1 ) {
this . reportParseError ( token , "x-invalid-end-tag" ) ;
return ;
}
const element = this . elementStack [ i ] ;
element . endTag = {
type : "VEndTag" ,
range : token . range ,
loc : token . loc ,
parent : element ,
} ;
this . popElementStackUntil ( i ) ;
}
Text ( token ) {
var _ a , _ b ;
debug ( "[html] Text %j" , token ) ;
const parent = this . currentNode ;
if ( token . value &&
parent . type === "VElement" &&
parent . name === "template" &&
parent . parent . type === "VDocumentFragment" ) {
const langAttribute = parent . startTag . attributes . find ( ( a ) => a . key . name === "lang" ) ;
const lang = ( _ a = langAttribute === null || langAttribute === void 0 ? void 0 : langAttribute . value ) === null || _ a === void 0 ? void 0 : _ a . value ;
if ( lang && lang !== "html" ) {
const templateTokenizerOption = ( _ b = this . baseParserOptions . templateTokenizer ) === null || _ b === void 0 ? void 0 : _ b [ lang ] ;
if ( templateTokenizerOption ) {
this . processTemplateText ( token , templateTokenizerOption ) ;
return ;
}
}
}
parent . children . push ( {
type : "VText" ,
range : token . range ,
loc : token . loc ,
parent ,
value : token . value ,
} ) ;
}
Mustache ( token ) {
debug ( "[html] Mustache %j" , token ) ;
const parent = this . currentNode ;
const container = {
type : "VExpressionContainer" ,
range : token . range ,
loc : token . loc ,
parent ,
expression : null ,
references : [ ] ,
} ;
parent . children . push ( container ) ;
this . postProcessesForScript . push ( ( parserOptions ) => {
processMustache ( parserOptions , this . locationCalculator , container , token ) ;
resolveReferences ( container ) ;
} ) ;
}
}
const alternativeCR = new Map ( [ [ 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 entitySets = [ { "length" : 32 , "entities" : { "CounterClockwiseContourIntegral;" : [ 8755 ] } } , { "length" : 25 , "entities" : { "ClockwiseContourIntegral;" : [ 8754 ] , "DoubleLongLeftRightArrow;" : [ 10234 ] } } , { "length" : 24 , "entities" : { "NotNestedGreaterGreater;" : [ 10914 , 824 ] } } , { "length" : 23 , "entities" : { "DiacriticalDoubleAcute;" : [ 733 ] , "NotSquareSupersetEqual;" : [ 8931 ] } } , { "length" : 22 , "entities" : { "CloseCurlyDoubleQuote;" : [ 8221 ] , "DoubleContourIntegral;" : [ 8751 ] , "FilledVerySmallSquare;" : [ 9642 ] , "NegativeVeryThinSpace;" : [ 8203 ] , "NotPrecedesSlantEqual;" : [ 8928 ] , "NotRightTriangleEqual;" : [ 8941 ] , "NotSucceedsSlantEqual;" : [ 8929 ] } } , { "length" : 21 , "entities" : { "CapitalDifferentialD;" : [ 8517 ] , "DoubleLeftRightArrow;" : [ 8660 ] , "DoubleLongRightArrow;" : [ 10233 ] , "EmptyVerySmallSquare;" : [ 9643 ] , "NestedGreaterGreater;" : [ 8811 ] , "NotDoubleVerticalBar;" : [ 8742 ] , "NotGreaterSlantEqual;" : [ 10878 , 824 ] , "NotLeftTriangleEqual;" : [ 8940 ] , "NotSquareSubsetEqual;" : [ 8930 ] , "OpenCurlyDoubleQuote;" : [ 8220 ] , "ReverseUpEquilibrium;" : [ 10607 ] } } , { "length" : 20 , "entities" : { "DoubleLongLeftArrow;" : [ 10232 ] , "DownLeftRightVector;" : [ 10576 ] , "LeftArrowRightArrow;" : [ 8646 ] , "NegativeMediumSpace;" : [ 8203 ] , "NotGreaterFullEqual;" : [ 8807 , 824 ] , "NotRightTriangleBar;" : [ 10704 , 824 ] , "RightArrowLeftArrow;" : [ 8644 ] , "SquareSupersetEqual;" : [ 8850 ] , "leftrightsquigarrow;" : [ 8621 ] } } , { "length" : 19 , "entities" : { "DownRightTeeVector;" : [ 10591 ] , "DownRightVectorBar;" : [ 10583 ] , "LongLeftRightArrow;" : [ 10231 ] , "Longleftrightarrow;" : [ 10234 ] , "NegativeThickSpace;" : [ 8203 ] , "NotLeftTriangleBar;" : [ 10703 , 824 ] , "PrecedesSlantEqual;" : [ 8828 ] , "ReverseEquilibrium;" : [ 8651 ] , "RightDoubleBracket;" : [ 10215 ] , "RightDownTeeVector;" : [ 10589 ] , "RightDownVectorBar;" : [ 10581 ] , "RightTriangleEqual;" : [ 8885 ] , "SquareIntersection;" : [ 8851 ] , "SucceedsSlantEqual;" : [ 8829 ] , "blacktriangleright;" : [ 9656 ] , "longleftrightarrow;" : [ 10231 ] } } , { "length" : 18 , "entities" : { "DoubleUpDownArrow;" : [ 8661 ] , "DoubleVerticalBar;" : [ 8741 ] , "DownLeftTeeVector;" : [ 10590 ] , "DownLeftVectorBar;" : [ 10582 ] , "FilledSmallSquare;" : [ 9724 ] , "GreaterSlantEqual;" : [ 10878 ] , "LeftDoubleBracket;" : [ 10214 ] , "LeftDownTeeVector;" : [ 10593 ] , "LeftDownVectorBar;" : [ 10585 ] , "LeftTriangleEqual;" : [ 8884 ] , "NegativeThinSpace;" : [ 8203 ] , "NotGreaterGreater;" : [ 8811 , 824 ] , "NotLessSlantEqual;" : [ 10877 , 824 ] , "NotNestedLessLess;" : [ 10913 , 824 ] , "NotReverseElement;" : [ 8716 ] , "NotSquareSuperset;" : [ 8848 , 824 ] , "NotTildeFullEqual;" : [ 8775 ] , "RightAngleBracket;" : [ 10217 ] , "RightUpDownVector;" : [ 10575 ] , "SquareSubsetEqual;" : [ 8849 ] , "VerticalSeparator;" : [ 10072 ] , "blacktriangledown;" : [ 9662 ] , "blacktriangleleft;" : [ 9666 ] , "leftrightharpoons;" : [ 8651 ] , "rightleftharpoons;" : [ 8652 ] , "twoheadrightarrow;" : [ 8608 ] } } , { "length" : 17 , "entities" : { "DiacriticalAcute;" : [ 180 ] , "DiacriticalGrave;" : [ 96 ] , "DiacriticalTilde;" : [ 732 ] , "DoubleRightArrow;" : [ 8658 ] , "DownArrowUpArrow;" : [ 8693 ] , "EmptySmallSquare;" : [ 9723 ] , "GreaterEqualLess;" : [ 8923 ] , "GreaterFullEqual;" : [ 8807 ] , "LeftAngleBracket;" : [ 10216 ] , "LeftUpDownVector;" : [ 10577 ] , "LessEqualGreater;" : [ 8922 ] , "NonBreakingSpace;" : [ 160 ] , "NotPrecedesEqual;" : [ 10927 , 824 ] , "NotRightTriangle;" : [ 8939 ] , "NotSucceedsEqual;" : [ 10928 , 824 ] , "NotSucceedsTilde;" : [ 8831 , 824 ] , "NotSupersetEqual;" : [ 8841 ] , "RightTriangleBar;" : [ 10704 ] , "RightUpTeeVector;" : [ 10588 ] , "RightUpVectorBar;" : [ 10580 ] , "UnderParenthesis;" : [ 9181 ] , "UpArrowDownArrow;" : [ 8645 ] , "circlearrowright;" : [ 8635 ] , "downharpoonright;" : [ 8642 ] , "ntrianglerighteq;" : [ 8941 ] , "rightharpoondown;" : [ 8641 ] , "rightrightarrows;" : [ 8649 ] , "twoheadleftarrow;" : [ 8606 ] , "vartriangleright;" : [ 8883 ] } } , { "length" : 16 , "entities" : { "CloseCurlyQuote;" : [ 8217 ] , "ContourIntegral;" : [ 8750 ] , "DoubleDownArrow;" : [ 8659 ] , "DoubleLeftArrow;" : [ 8656 ] , "DownRightVector;" : [ 8641 ] , "LeftRightVector;" : [ 10574 ] , "LeftTriangleBar;" : [ 10703 ] , "LeftUpTeeVector;" : [ 10592 ] , "LeftUpVectorBar;" : [ 10584 ] , "LowerRightArrow;" : [ 8600 ] , "NotGreaterEqual;" : [ 8817 ] , "NotGreaterTilde;" : [ 8821 ] , "NotHumpDownHump;" : [ 8782 , 824 ] , " NotLeftTrian
const EOF = - 1 ;
const NULL = 0x00 ;
const TABULATION = 0x09 ;
const CARRIAGE_RETURN = 0x0D ;
const LINE_FEED = 0x0A ;
const FORM_FEED = 0x0C ;
const SPACE = 0x20 ;
const EXCLAMATION_MARK = 0x21 ;
const QUOTATION_MARK = 0x22 ;
const NUMBER_SIGN = 0x23 ;
const AMPERSAND = 0x26 ;
const APOSTROPHE = 0x27 ;
const LEFT_PARENTHESIS = 0x28 ;
const RIGHT_PARENTHESIS = 0x29 ;
const ASTERISK = 0x2A ;
const HYPHEN_MINUS = 0x2D ;
const SOLIDUS = 0x2F ;
const DIGIT_0 = 0x30 ;
const DIGIT_9 = 0x39 ;
const COLON = 0x3a ;
const SEMICOLON = 0x3B ;
const LESS_THAN_SIGN = 0x3C ;
const EQUALS_SIGN = 0x3D ;
const GREATER_THAN_SIGN = 0x3E ;
const QUESTION_MARK = 0x3F ;
const LATIN_CAPITAL_A = 0x41 ;
const LATIN_CAPITAL_D = 0x44 ;
const LATIN_CAPITAL_F = 0x46 ;
const LATIN_CAPITAL_X = 0x58 ;
const LATIN_CAPITAL_Z = 0x5A ;
const LEFT_SQUARE_BRACKET = 0x5B ;
const REVERSE_SOLIDUS = 0x5C ;
const RIGHT_SQUARE_BRACKET = 0x5D ;
const GRAVE_ACCENT = 0x60 ;
const LATIN_SMALL_A = 0x61 ;
const LATIN_SMALL_F = 0x66 ;
const LATIN_SMALL_X = 0x78 ;
const LATIN_SMALL_Z = 0x7A ;
const LEFT_CURLY_BRACKET = 0x7B ;
const RIGHT_CURLY_BRACKET = 0x7D ;
const NULL_REPLACEMENT = 0xFFFD ;
function isWhitespace ( cp ) {
return cp === TABULATION || cp === LINE_FEED || cp === FORM_FEED || cp === CARRIAGE_RETURN || cp === SPACE ;
}
function isUpperLetter ( cp ) {
return cp >= LATIN_CAPITAL_A && cp <= LATIN_CAPITAL_Z ;
}
function isLowerLetter ( cp ) {
return cp >= LATIN_SMALL_A && cp <= LATIN_SMALL_Z ;
}
function isLetter ( cp ) {
return isLowerLetter ( cp ) || isUpperLetter ( cp ) ;
}
function isDigit ( cp ) {
return cp >= DIGIT_0 && cp <= DIGIT_9 ;
}
function isUpperHexDigit ( cp ) {
return cp >= LATIN_CAPITAL_A && cp <= LATIN_CAPITAL_F ;
}
function isLowerHexDigit ( cp ) {
return cp >= LATIN_SMALL_A && cp <= LATIN_SMALL_F ;
}
function isHexDigit ( cp ) {
return isDigit ( cp ) || isUpperHexDigit ( cp ) || isLowerHexDigit ( cp ) ;
}
function isControl ( cp ) {
return ( cp >= 0 && cp <= 0x1F ) || ( cp >= 0x7F && cp <= 0x9F ) ;
}
function isSurrogate ( cp ) {
return cp >= 0xD800 && cp <= 0xDFFF ;
}
function isSurrogatePair ( cp ) {
return cp >= 0xDC00 && cp <= 0xDFFF ;
}
function isNonCharacter ( cp ) {
return ( ( cp >= 0xFDD0 && cp <= 0xFDEF ) ||
( ( cp & 0xFFFE ) === 0xFFFE && cp <= 0x10FFFF ) ) ;
}
function toLowerCodePoint ( cp ) {
return cp + 0x0020 ;
}
class Tokenizer {
constructor ( text , parserOptions ) {
this . vExpressionScriptState = null ;
debug ( "[html] the source code length: %d" , text . length ) ;
this . text = text ;
this . gaps = [ ] ;
this . lineTerminators = [ ] ;
this . parserOptions = parserOptions || { } ;
this . lastCodePoint = this . lastCodePointRaw = NULL ;
this . offset = - 1 ;
this . column = - 1 ;
this . line = 1 ;
this . state = "DATA" ;
this . returnState = "DATA" ;
this . reconsuming = false ;
this . buffer = [ ] ;
this . crStartOffset = - 1 ;
this . crCode = 0 ;
this . errors = [ ] ;
this . committedToken = null ;
this . provisionalToken = null ;
this . currentToken = null ;
this . lastTagOpenToken = null ;
this . tokenStartOffset = - 1 ;
this . tokenStartColumn = - 1 ;
this . tokenStartLine = 1 ;
this . namespace = NS . HTML ;
this . expressionEnabled = false ;
}
nextToken ( ) {
let cp = this . lastCodePoint ;
while ( this . committedToken == null &&
( cp !== EOF || this . reconsuming ) ) {
if ( this . provisionalToken != null && ! this . isProvisionalState ( ) ) {
this . commitProvisionalToken ( ) ;
if ( this . committedToken != null ) {
break ;
}
}
if ( this . reconsuming ) {
this . reconsuming = false ;
cp = this . lastCodePoint ;
}
else {
cp = this . consumeNextCodePoint ( ) ;
}
debug ( "[html] parse" , cp , this . state ) ;
this . state = this [ this . state ] ( cp ) ;
}
{
const token = this . consumeCommittedToken ( ) ;
if ( token != null ) {
return token ;
}
}
assert__default [ "default" ] ( cp === EOF ) ;
if ( this . currentToken != null ) {
this . endToken ( ) ;
const token = this . consumeCommittedToken ( ) ;
if ( token != null ) {
return token ;
}
}
return this . currentToken ;
}
consumeCommittedToken ( ) {
const token = this . committedToken ;
this . committedToken = null ;
return token ;
}
consumeNextCodePoint ( ) {
if ( this . offset >= this . text . length ) {
this . lastCodePoint = this . lastCodePointRaw = EOF ;
return EOF ;
}
this . offset += this . lastCodePoint >= 0x10000 ? 2 : 1 ;
if ( this . offset >= this . text . length ) {
this . advanceLocation ( ) ;
this . lastCodePoint = this . lastCodePointRaw = EOF ;
return EOF ;
}
const cp = this . text . codePointAt ( this . offset ) ;
if ( isSurrogate ( this . text . charCodeAt ( this . offset ) ) &&
! isSurrogatePair ( this . text . charCodeAt ( this . offset + 1 ) ) ) {
this . reportParseError ( "surrogate-in-input-stream" ) ;
}
if ( isNonCharacter ( cp ) ) {
this . reportParseError ( "noncharacter-in-input-stream" ) ;
}
if ( isControl ( cp ) && ! isWhitespace ( cp ) && cp !== NULL ) {
this . reportParseError ( "control-character-in-input-stream" ) ;
}
if ( this . lastCodePointRaw === CARRIAGE_RETURN && cp === LINE_FEED ) {
this . lastCodePoint = this . lastCodePointRaw = LINE_FEED ;
this . gaps . push ( this . offset ) ;
return this . consumeNextCodePoint ( ) ;
}
this . advanceLocation ( ) ;
this . lastCodePoint = this . lastCodePointRaw = cp ;
if ( cp === CARRIAGE_RETURN ) {
this . lastCodePoint = LINE_FEED ;
return LINE_FEED ;
}
return cp ;
}
advanceLocation ( ) {
if ( this . lastCodePointRaw === LINE_FEED ) {
this . lineTerminators . push ( this . offset ) ;
this . line += 1 ;
this . column = 0 ;
}
else {
this . column += this . lastCodePoint >= 0x10000 ? 2 : 1 ;
}
}
reconsumeAs ( state ) {
this . reconsuming = true ;
return state ;
}
reportParseError ( code ) {
const error = ParseError . fromCode ( code , this . offset , this . line , this . column ) ;
this . errors . push ( error ) ;
debug ( "[html] syntax error:" , error . message ) ;
}
setStartTokenMark ( ) {
this . tokenStartOffset = this . offset ;
this . tokenStartLine = this . line ;
this . tokenStartColumn = this . column ;
}
clearStartTokenMark ( ) {
this . tokenStartOffset = - 1 ;
}
startToken ( type ) {
if ( this . tokenStartOffset === - 1 ) {
this . setStartTokenMark ( ) ;
}
const offset = this . tokenStartOffset ;
const line = this . tokenStartLine ;
const column = this . tokenStartColumn ;
if ( this . currentToken != null ) {
this . endToken ( ) ;
}
this . tokenStartOffset = - 1 ;
const token = ( this . currentToken = {
type ,
range : [ offset , - 1 ] ,
loc : {
start : { line , column } ,
end : { line : - 1 , column : - 1 } ,
} ,
value : "" ,
} ) ;
debug ( "[html] start token: %d %s" , offset , token . type ) ;
return this . currentToken ;
}
endToken ( ) {
if ( this . currentToken == null ) {
throw new Error ( "Invalid state" ) ;
}
if ( this . tokenStartOffset === - 1 ) {
this . setStartTokenMark ( ) ;
}
const token = this . currentToken ;
const offset = this . tokenStartOffset ;
const line = this . tokenStartLine ;
const column = this . tokenStartColumn ;
const provisional = this . isProvisionalState ( ) ;
this . currentToken = null ;
this . tokenStartOffset = - 1 ;
token . range [ 1 ] = offset ;
token . loc . end . line = line ;
token . loc . end . column = column ;
if ( token . range [ 0 ] === offset && ! provisional ) {
debug ( "[html] abandon token: %j %s %j" , token . range , token . type , token . value ) ;
return null ;
}
if ( provisional ) {
if ( this . provisionalToken != null ) {
this . commitProvisionalToken ( ) ;
}
this . provisionalToken = token ;
debug ( "[html] provisional-commit token: %j %s %j" , token . range , token . type , token . value ) ;
}
else {
this . commitToken ( token ) ;
}
return token ;
}
commitToken ( token ) {
assert__default [ "default" ] ( this . committedToken == null , "Invalid state: the commited token existed already." ) ;
debug ( "[html] commit token: %j %j %s %j" , token . range , token . loc , token . type , token . value ) ;
this . committedToken = token ;
if ( token . type === "HTMLTagOpen" ) {
this . lastTagOpenToken = token ;
}
}
isProvisionalState ( ) {
return ( this . state . startsWith ( "RCDATA_" ) ||
this . state . startsWith ( "RAWTEXT_" ) ) ;
}
commitProvisionalToken ( ) {
assert__default [ "default" ] ( this . provisionalToken != null , "Invalid state: the provisional token was not found." ) ;
const token = this . provisionalToken ;
this . provisionalToken = null ;
if ( token . range [ 0 ] < token . range [ 1 ] ) {
this . commitToken ( token ) ;
}
}
rollbackProvisionalToken ( ) {
assert__default [ "default" ] ( this . currentToken != null ) ;
assert__default [ "default" ] ( this . provisionalToken != null ) ;
const token = this . currentToken ;
debug ( "[html] rollback token: %d %s" , token . range [ 0 ] , token . type ) ;
this . currentToken = this . provisionalToken ;
this . provisionalToken = null ;
}
appendTokenValue ( cp , expected ) {
const token = this . currentToken ;
if ( token == null || ( expected != null && token . type !== expected ) ) {
const msg1 = expected ? ` " ${ expected } " type ` : "any token" ;
const msg2 = token ? ` " ${ token . type } " type ` : "no token" ;
throw new Error ( ` Tokenizer: Invalid state. Expected ${ msg1 } , but got ${ msg2 } . ` ) ;
}
token . value += String . fromCodePoint ( cp ) ;
}
isAppropriateEndTagOpen ( ) {
return ( this . currentToken != null &&
this . lastTagOpenToken != null &&
this . currentToken . type === "HTMLEndTagOpen" &&
this . currentToken . value === this . lastTagOpenToken . value ) ;
}
DATA ( cp ) {
this . clearStartTokenMark ( ) ;
while ( true ) {
const type = isWhitespace ( cp ) ? "HTMLWhitespace" : "HTMLText" ;
if ( this . currentToken != null && this . currentToken . type !== type ) {
this . endToken ( ) ;
return this . reconsumeAs ( this . state ) ;
}
if ( this . currentToken == null ) {
this . startToken ( type ) ;
}
if ( cp === AMPERSAND ) {
this . returnState = "DATA" ;
return "CHARACTER_REFERENCE" ;
}
if ( cp === LESS_THAN_SIGN ) {
this . setStartTokenMark ( ) ;
return "TAG_OPEN" ;
}
if ( cp === LEFT_CURLY_BRACKET && this . expressionEnabled ) {
this . setStartTokenMark ( ) ;
this . returnState = "DATA" ;
return "V_EXPRESSION_START" ;
}
if ( cp === RIGHT_CURLY_BRACKET && this . expressionEnabled ) {
this . setStartTokenMark ( ) ;
this . returnState = "DATA" ;
return "V_EXPRESSION_END" ;
}
if ( cp === EOF ) {
return "DATA" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
}
this . appendTokenValue ( cp , type ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
RCDATA ( cp ) {
this . clearStartTokenMark ( ) ;
while ( true ) {
const type = isWhitespace ( cp ) ? "HTMLWhitespace" : "HTMLRCDataText" ;
if ( this . currentToken != null && this . currentToken . type !== type ) {
this . endToken ( ) ;
return this . reconsumeAs ( this . state ) ;
}
if ( this . currentToken == null ) {
this . startToken ( type ) ;
}
if ( cp === AMPERSAND ) {
this . returnState = "RCDATA" ;
return "CHARACTER_REFERENCE" ;
}
if ( cp === LESS_THAN_SIGN ) {
this . setStartTokenMark ( ) ;
return "RCDATA_LESS_THAN_SIGN" ;
}
if ( cp === LEFT_CURLY_BRACKET && this . expressionEnabled ) {
this . setStartTokenMark ( ) ;
this . returnState = "RCDATA" ;
return "V_EXPRESSION_START" ;
}
if ( cp === RIGHT_CURLY_BRACKET && this . expressionEnabled ) {
this . setStartTokenMark ( ) ;
this . returnState = "RCDATA" ;
return "V_EXPRESSION_END" ;
}
if ( cp === EOF ) {
return "DATA" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
this . appendTokenValue ( cp , type ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
RAWTEXT ( cp ) {
this . clearStartTokenMark ( ) ;
while ( true ) {
const type = isWhitespace ( cp ) ? "HTMLWhitespace" : "HTMLRawText" ;
if ( this . currentToken != null && this . currentToken . type !== type ) {
this . endToken ( ) ;
return this . reconsumeAs ( this . state ) ;
}
if ( this . currentToken == null ) {
this . startToken ( type ) ;
}
if ( cp === LESS_THAN_SIGN ) {
this . setStartTokenMark ( ) ;
return "RAWTEXT_LESS_THAN_SIGN" ;
}
if ( cp === LEFT_CURLY_BRACKET && this . expressionEnabled ) {
this . setStartTokenMark ( ) ;
this . returnState = "RAWTEXT" ;
return "V_EXPRESSION_START" ;
}
if ( cp === RIGHT_CURLY_BRACKET && this . expressionEnabled ) {
this . setStartTokenMark ( ) ;
this . returnState = "RAWTEXT" ;
return "V_EXPRESSION_END" ;
}
if ( cp === EOF ) {
return "DATA" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
this . appendTokenValue ( cp , type ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
TAG_OPEN ( cp ) {
if ( cp === EXCLAMATION_MARK ) {
return "MARKUP_DECLARATION_OPEN" ;
}
if ( cp === SOLIDUS ) {
return "END_TAG_OPEN" ;
}
if ( isLetter ( cp ) ) {
this . startToken ( "HTMLTagOpen" ) ;
return this . reconsumeAs ( "TAG_NAME" ) ;
}
if ( cp === QUESTION_MARK ) {
this . reportParseError ( "unexpected-question-mark-instead-of-tag-name" ) ;
this . startToken ( "HTMLBogusComment" ) ;
return this . reconsumeAs ( "BOGUS_COMMENT" ) ;
}
if ( cp === EOF ) {
this . clearStartTokenMark ( ) ;
this . reportParseError ( "eof-before-tag-name" ) ;
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLText" ) ;
return "DATA" ;
}
this . reportParseError ( "invalid-first-character-of-tag-name" ) ;
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLText" ) ;
return this . reconsumeAs ( "DATA" ) ;
}
END_TAG_OPEN ( cp ) {
if ( isLetter ( cp ) ) {
this . startToken ( "HTMLEndTagOpen" ) ;
return this . reconsumeAs ( "TAG_NAME" ) ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . endToken ( ) ;
this . reportParseError ( "missing-end-tag-name" ) ;
return "DATA" ;
}
if ( cp === EOF ) {
this . clearStartTokenMark ( ) ;
this . reportParseError ( "eof-before-tag-name" ) ;
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLText" ) ;
this . appendTokenValue ( SOLIDUS , "HTMLText" ) ;
return "DATA" ;
}
this . reportParseError ( "invalid-first-character-of-tag-name" ) ;
this . startToken ( "HTMLBogusComment" ) ;
return this . reconsumeAs ( "BOGUS_COMMENT" ) ;
}
TAG_NAME ( cp ) {
while ( true ) {
if ( isWhitespace ( cp ) ) {
this . endToken ( ) ;
return "BEFORE_ATTRIBUTE_NAME" ;
}
if ( cp === SOLIDUS ) {
this . endToken ( ) ;
this . setStartTokenMark ( ) ;
return "SELF_CLOSING_START_TAG" ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . startToken ( "HTMLTagClose" ) ;
return "DATA" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-tag" ) ;
return "DATA" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
this . appendTokenValue ( isUpperLetter ( cp ) ? toLowerCodePoint ( cp ) : cp , null ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
RCDATA_LESS_THAN_SIGN ( cp ) {
if ( cp === SOLIDUS ) {
this . buffer = [ ] ;
return "RCDATA_END_TAG_OPEN" ;
}
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLRCDataText" ) ;
return this . reconsumeAs ( "RCDATA" ) ;
}
RCDATA_END_TAG_OPEN ( cp ) {
if ( isLetter ( cp ) ) {
this . startToken ( "HTMLEndTagOpen" ) ;
return this . reconsumeAs ( "RCDATA_END_TAG_NAME" ) ;
}
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLRCDataText" ) ;
this . appendTokenValue ( SOLIDUS , "HTMLRCDataText" ) ;
return this . reconsumeAs ( "RCDATA" ) ;
}
RCDATA_END_TAG_NAME ( cp ) {
while ( true ) {
if ( isWhitespace ( cp ) && this . isAppropriateEndTagOpen ( ) ) {
this . endToken ( ) ;
return "BEFORE_ATTRIBUTE_NAME" ;
}
if ( cp === SOLIDUS && this . isAppropriateEndTagOpen ( ) ) {
this . endToken ( ) ;
this . setStartTokenMark ( ) ;
return "SELF_CLOSING_START_TAG" ;
}
if ( cp === GREATER_THAN_SIGN && this . isAppropriateEndTagOpen ( ) ) {
this . startToken ( "HTMLTagClose" ) ;
return "DATA" ;
}
if ( ! isLetter ( cp ) ) {
this . rollbackProvisionalToken ( ) ;
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLRCDataText" ) ;
this . appendTokenValue ( SOLIDUS , "HTMLRCDataText" ) ;
for ( const cp1 of this . buffer ) {
this . appendTokenValue ( cp1 , "HTMLRCDataText" ) ;
}
return this . reconsumeAs ( "RCDATA" ) ;
}
this . appendTokenValue ( isUpperLetter ( cp ) ? toLowerCodePoint ( cp ) : cp , "HTMLEndTagOpen" ) ;
this . buffer . push ( cp ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
RAWTEXT_LESS_THAN_SIGN ( cp ) {
if ( cp === SOLIDUS ) {
this . buffer = [ ] ;
return "RAWTEXT_END_TAG_OPEN" ;
}
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLRawText" ) ;
return this . reconsumeAs ( "RAWTEXT" ) ;
}
RAWTEXT_END_TAG_OPEN ( cp ) {
if ( isLetter ( cp ) ) {
this . startToken ( "HTMLEndTagOpen" ) ;
return this . reconsumeAs ( "RAWTEXT_END_TAG_NAME" ) ;
}
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLRawText" ) ;
this . appendTokenValue ( SOLIDUS , "HTMLRawText" ) ;
return this . reconsumeAs ( "RAWTEXT" ) ;
}
RAWTEXT_END_TAG_NAME ( cp ) {
while ( true ) {
if ( cp === SOLIDUS && this . isAppropriateEndTagOpen ( ) ) {
this . endToken ( ) ;
this . setStartTokenMark ( ) ;
return "SELF_CLOSING_START_TAG" ;
}
if ( cp === GREATER_THAN_SIGN && this . isAppropriateEndTagOpen ( ) ) {
this . startToken ( "HTMLTagClose" ) ;
return "DATA" ;
}
if ( isWhitespace ( cp ) && this . isAppropriateEndTagOpen ( ) ) {
this . endToken ( ) ;
return "BEFORE_ATTRIBUTE_NAME" ;
}
if ( ! isLetter ( cp ) && ! maybeValidCustomBlock . call ( this , cp ) ) {
this . rollbackProvisionalToken ( ) ;
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLRawText" ) ;
this . appendTokenValue ( SOLIDUS , "HTMLRawText" ) ;
for ( const cp1 of this . buffer ) {
this . appendTokenValue ( cp1 , "HTMLRawText" ) ;
}
return this . reconsumeAs ( "RAWTEXT" ) ;
}
this . appendTokenValue ( isUpperLetter ( cp ) ? toLowerCodePoint ( cp ) : cp , "HTMLEndTagOpen" ) ;
this . buffer . push ( cp ) ;
cp = this . consumeNextCodePoint ( ) ;
}
function maybeValidCustomBlock ( nextCp ) {
return ( this . currentToken &&
this . lastTagOpenToken &&
this . lastTagOpenToken . value . startsWith ( this . currentToken . value + String . fromCodePoint ( nextCp ) ) ) ;
}
}
BEFORE_ATTRIBUTE_NAME ( cp ) {
while ( isWhitespace ( cp ) ) {
cp = this . consumeNextCodePoint ( ) ;
}
if ( cp === SOLIDUS || cp === GREATER_THAN_SIGN || cp === EOF ) {
return this . reconsumeAs ( "AFTER_ATTRIBUTE_NAME" ) ;
}
if ( cp === EQUALS_SIGN ) {
this . reportParseError ( "unexpected-equals-sign-before-attribute-name" ) ;
this . startToken ( "HTMLIdentifier" ) ;
this . appendTokenValue ( cp , "HTMLIdentifier" ) ;
return "ATTRIBUTE_NAME" ;
}
this . startToken ( "HTMLIdentifier" ) ;
return this . reconsumeAs ( "ATTRIBUTE_NAME" ) ;
}
ATTRIBUTE_NAME ( cp ) {
while ( true ) {
if ( isWhitespace ( cp ) ||
cp === SOLIDUS ||
cp === GREATER_THAN_SIGN ||
cp === EOF ) {
this . endToken ( ) ;
return this . reconsumeAs ( "AFTER_ATTRIBUTE_NAME" ) ;
}
if ( cp === EQUALS_SIGN ) {
this . startToken ( "HTMLAssociation" ) ;
return "BEFORE_ATTRIBUTE_VALUE" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
if ( cp === QUOTATION_MARK ||
cp === APOSTROPHE ||
cp === LESS_THAN_SIGN ) {
this . reportParseError ( "unexpected-character-in-attribute-name" ) ;
}
this . appendTokenValue ( isUpperLetter ( cp ) ? toLowerCodePoint ( cp ) : cp , "HTMLIdentifier" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
AFTER_ATTRIBUTE_NAME ( cp ) {
while ( isWhitespace ( cp ) ) {
cp = this . consumeNextCodePoint ( ) ;
}
if ( cp === SOLIDUS ) {
this . setStartTokenMark ( ) ;
return "SELF_CLOSING_START_TAG" ;
}
if ( cp === EQUALS_SIGN ) {
this . startToken ( "HTMLAssociation" ) ;
return "BEFORE_ATTRIBUTE_VALUE" ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . startToken ( "HTMLTagClose" ) ;
return "DATA" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-tag" ) ;
return "DATA" ;
}
this . startToken ( "HTMLIdentifier" ) ;
return this . reconsumeAs ( "ATTRIBUTE_NAME" ) ;
}
BEFORE_ATTRIBUTE_VALUE ( cp ) {
this . endToken ( ) ;
while ( isWhitespace ( cp ) ) {
cp = this . consumeNextCodePoint ( ) ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . reportParseError ( "missing-attribute-value" ) ;
this . startToken ( "HTMLTagClose" ) ;
return "DATA" ;
}
this . startToken ( "HTMLLiteral" ) ;
if ( cp === QUOTATION_MARK ) {
return "ATTRIBUTE_VALUE_DOUBLE_QUOTED" ;
}
if ( cp === APOSTROPHE ) {
return "ATTRIBUTE_VALUE_SINGLE_QUOTED" ;
}
return this . reconsumeAs ( "ATTRIBUTE_VALUE_UNQUOTED" ) ;
}
ATTRIBUTE_VALUE_DOUBLE_QUOTED ( cp ) {
while ( true ) {
if ( cp === QUOTATION_MARK ) {
return "AFTER_ATTRIBUTE_VALUE_QUOTED" ;
}
if ( cp === AMPERSAND ) {
this . returnState = "ATTRIBUTE_VALUE_DOUBLE_QUOTED" ;
return "CHARACTER_REFERENCE" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-tag" ) ;
return "DATA" ;
}
this . appendTokenValue ( cp , "HTMLLiteral" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
ATTRIBUTE_VALUE_SINGLE_QUOTED ( cp ) {
while ( true ) {
if ( cp === APOSTROPHE ) {
return "AFTER_ATTRIBUTE_VALUE_QUOTED" ;
}
if ( cp === AMPERSAND ) {
this . returnState = "ATTRIBUTE_VALUE_SINGLE_QUOTED" ;
return "CHARACTER_REFERENCE" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-tag" ) ;
return "DATA" ;
}
this . appendTokenValue ( cp , "HTMLLiteral" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
ATTRIBUTE_VALUE_UNQUOTED ( cp ) {
while ( true ) {
if ( isWhitespace ( cp ) ) {
this . endToken ( ) ;
return "BEFORE_ATTRIBUTE_NAME" ;
}
if ( cp === AMPERSAND ) {
this . returnState = "ATTRIBUTE_VALUE_UNQUOTED" ;
return "CHARACTER_REFERENCE" ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . startToken ( "HTMLTagClose" ) ;
return "DATA" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
if ( cp === QUOTATION_MARK ||
cp === APOSTROPHE ||
cp === LESS_THAN_SIGN ||
cp === EQUALS_SIGN ||
cp === GRAVE_ACCENT ) {
this . reportParseError ( "unexpected-character-in-unquoted-attribute-value" ) ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-tag" ) ;
return "DATA" ;
}
this . appendTokenValue ( cp , "HTMLLiteral" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
AFTER_ATTRIBUTE_VALUE_QUOTED ( cp ) {
this . endToken ( ) ;
if ( isWhitespace ( cp ) ) {
return "BEFORE_ATTRIBUTE_NAME" ;
}
if ( cp === SOLIDUS ) {
this . setStartTokenMark ( ) ;
return "SELF_CLOSING_START_TAG" ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . startToken ( "HTMLTagClose" ) ;
return "DATA" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-tag" ) ;
return "DATA" ;
}
this . reportParseError ( "missing-whitespace-between-attributes" ) ;
return this . reconsumeAs ( "BEFORE_ATTRIBUTE_NAME" ) ;
}
SELF_CLOSING_START_TAG ( cp ) {
if ( cp === GREATER_THAN_SIGN ) {
this . startToken ( "HTMLSelfClosingTagClose" ) ;
return "DATA" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-tag" ) ;
return "DATA" ;
}
this . reportParseError ( "unexpected-solidus-in-tag" ) ;
this . clearStartTokenMark ( ) ;
return this . reconsumeAs ( "BEFORE_ATTRIBUTE_NAME" ) ;
}
BOGUS_COMMENT ( cp ) {
while ( true ) {
if ( cp === GREATER_THAN_SIGN ) {
return "DATA" ;
}
if ( cp === EOF ) {
return "DATA" ;
}
if ( cp === NULL ) {
cp = NULL_REPLACEMENT ;
}
this . appendTokenValue ( cp , null ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
MARKUP_DECLARATION_OPEN ( cp ) {
if ( cp === HYPHEN_MINUS && this . text [ this . offset + 1 ] === "-" ) {
this . offset += 1 ;
this . column += 1 ;
this . startToken ( "HTMLComment" ) ;
return "COMMENT_START" ;
}
if ( cp === LATIN_CAPITAL_D &&
this . text . slice ( this . offset + 1 , this . offset + 7 ) === "OCTYPE" ) {
this . startToken ( "HTMLBogusComment" ) ;
this . appendTokenValue ( cp , "HTMLBogusComment" ) ;
return "BOGUS_COMMENT" ;
}
if ( cp === LEFT_SQUARE_BRACKET &&
this . text . slice ( this . offset + 1 , this . offset + 7 ) === "CDATA[" ) {
this . offset += 6 ;
this . column += 6 ;
if ( this . namespace === NS . HTML ) {
this . reportParseError ( "cdata-in-html-content" ) ;
this . startToken ( "HTMLBogusComment" ) . value = "[CDATA[" ;
return "BOGUS_COMMENT" ;
}
this . startToken ( "HTMLCDataText" ) ;
return "CDATA_SECTION" ;
}
this . reportParseError ( "incorrectly-opened-comment" ) ;
this . startToken ( "HTMLBogusComment" ) ;
return this . reconsumeAs ( "BOGUS_COMMENT" ) ;
}
COMMENT_START ( cp ) {
if ( cp === HYPHEN_MINUS ) {
return "COMMENT_START_DASH" ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . reportParseError ( "abrupt-closing-of-empty-comment" ) ;
return "DATA" ;
}
return this . reconsumeAs ( "COMMENT" ) ;
}
COMMENT_START_DASH ( cp ) {
if ( cp === HYPHEN_MINUS ) {
return "COMMENT_END" ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . reportParseError ( "abrupt-closing-of-empty-comment" ) ;
return "DATA" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-comment" ) ;
return "DATA" ;
}
this . appendTokenValue ( HYPHEN_MINUS , "HTMLComment" ) ;
return this . reconsumeAs ( "COMMENT" ) ;
}
COMMENT ( cp ) {
while ( true ) {
if ( cp === LESS_THAN_SIGN ) {
this . appendTokenValue ( LESS_THAN_SIGN , "HTMLComment" ) ;
return "COMMENT_LESS_THAN_SIGN" ;
}
if ( cp === HYPHEN_MINUS ) {
return "COMMENT_END_DASH" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
cp = NULL_REPLACEMENT ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-comment" ) ;
return "DATA" ;
}
this . appendTokenValue ( cp , "HTMLComment" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
COMMENT_LESS_THAN_SIGN ( cp ) {
while ( true ) {
if ( cp === EXCLAMATION_MARK ) {
this . appendTokenValue ( cp , "HTMLComment" ) ;
return "COMMENT_LESS_THAN_SIGN_BANG" ;
}
if ( cp !== LESS_THAN_SIGN ) {
return this . reconsumeAs ( "COMMENT" ) ;
}
this . appendTokenValue ( cp , "HTMLComment" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
COMMENT_LESS_THAN_SIGN_BANG ( cp ) {
if ( cp === HYPHEN_MINUS ) {
return "COMMENT_LESS_THAN_SIGN_BANG_DASH" ;
}
return this . reconsumeAs ( "COMMENT" ) ;
}
COMMENT_LESS_THAN_SIGN_BANG_DASH ( cp ) {
if ( cp === HYPHEN_MINUS ) {
return "COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH" ;
}
return this . reconsumeAs ( "COMMENT_END_DASH" ) ;
}
COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH ( cp ) {
if ( cp !== GREATER_THAN_SIGN && cp !== EOF ) {
this . reportParseError ( "nested-comment" ) ;
}
return this . reconsumeAs ( "COMMENT_END" ) ;
}
COMMENT_END_DASH ( cp ) {
if ( cp === HYPHEN_MINUS ) {
return "COMMENT_END" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-comment" ) ;
return "DATA" ;
}
this . appendTokenValue ( HYPHEN_MINUS , "HTMLComment" ) ;
return this . reconsumeAs ( "COMMENT" ) ;
}
COMMENT_END ( cp ) {
while ( true ) {
if ( cp === GREATER_THAN_SIGN ) {
return "DATA" ;
}
if ( cp === EXCLAMATION_MARK ) {
return "COMMENT_END_BANG" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-comment" ) ;
return "DATA" ;
}
this . appendTokenValue ( HYPHEN_MINUS , "HTMLComment" ) ;
if ( cp !== HYPHEN_MINUS ) {
this . appendTokenValue ( HYPHEN_MINUS , "HTMLComment" ) ;
return this . reconsumeAs ( "COMMENT" ) ;
}
cp = this . consumeNextCodePoint ( ) ;
}
}
COMMENT_END_BANG ( cp ) {
if ( cp === HYPHEN_MINUS ) {
this . appendTokenValue ( HYPHEN_MINUS , "HTMLComment" ) ;
this . appendTokenValue ( EXCLAMATION_MARK , "HTMLComment" ) ;
return "COMMENT_END_DASH" ;
}
if ( cp === GREATER_THAN_SIGN ) {
this . reportParseError ( "incorrectly-closed-comment" ) ;
return "DATA" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-comment" ) ;
return "DATA" ;
}
this . appendTokenValue ( HYPHEN_MINUS , "HTMLComment" ) ;
this . appendTokenValue ( EXCLAMATION_MARK , "HTMLComment" ) ;
return this . reconsumeAs ( "COMMENT" ) ;
}
CDATA_SECTION ( cp ) {
while ( true ) {
if ( cp === RIGHT_SQUARE_BRACKET ) {
return "CDATA_SECTION_BRACKET" ;
}
if ( cp === EOF ) {
this . reportParseError ( "eof-in-cdata" ) ;
return "DATA" ;
}
this . appendTokenValue ( cp , "HTMLCDataText" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
CDATA_SECTION_BRACKET ( cp ) {
if ( cp === RIGHT_SQUARE_BRACKET ) {
return "CDATA_SECTION_END" ;
}
this . appendTokenValue ( RIGHT_SQUARE_BRACKET , "HTMLCDataText" ) ;
return this . reconsumeAs ( "CDATA_SECTION" ) ;
}
CDATA_SECTION_END ( cp ) {
while ( true ) {
if ( cp === GREATER_THAN_SIGN ) {
return "DATA" ;
}
if ( cp !== RIGHT_SQUARE_BRACKET ) {
this . appendTokenValue ( RIGHT_SQUARE_BRACKET , "HTMLCDataText" ) ;
this . appendTokenValue ( RIGHT_SQUARE_BRACKET , "HTMLCDataText" ) ;
return this . reconsumeAs ( "CDATA_SECTION" ) ;
}
this . appendTokenValue ( RIGHT_SQUARE_BRACKET , "HTMLCDataText" ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
CHARACTER_REFERENCE ( cp ) {
this . crStartOffset = this . offset - 1 ;
this . buffer = [ AMPERSAND ] ;
if ( isDigit ( cp ) || isLetter ( cp ) ) {
return this . reconsumeAs ( "NAMED_CHARACTER_REFERENCE" ) ;
}
if ( cp === NUMBER_SIGN ) {
this . buffer . push ( cp ) ;
return "NUMERIC_CHARACTER_REFERENCE" ;
}
return this . reconsumeAs ( "CHARACTER_REFERENCE_END" ) ;
}
NAMED_CHARACTER_REFERENCE ( cp ) {
for ( const entitySet of entitySets ) {
const length = entitySet . length ;
const entities = entitySet . entities ;
const text = this . text . slice ( this . offset , this . offset + length ) ;
const codepoints = entities [ text ] ;
if ( codepoints == null ) {
continue ;
}
const semi = text . endsWith ( ";" ) ;
const next = this . text . codePointAt ( this . offset + 1 ) ;
this . offset += length - 1 ;
this . column += length - 1 ;
if ( this . returnState . startsWith ( "ATTR" ) &&
! semi &&
next != null &&
( next === EQUALS_SIGN || isLetter ( next ) || isDigit ( next ) ) ) {
for ( const cp1 of text ) {
this . buffer . push ( cp1 . codePointAt ( 0 ) ) ;
}
}
else {
if ( ! semi ) {
this . reportParseError ( "missing-semicolon-after-character-reference" ) ;
}
this . buffer = codepoints ;
}
return "CHARACTER_REFERENCE_END" ;
}
for ( const cp0 of this . buffer ) {
this . appendTokenValue ( cp0 , null ) ;
}
this . appendTokenValue ( cp , null ) ;
return "AMBIGUOUS_AMPERSAND" ;
}
AMBIGUOUS_AMPERSAND ( cp ) {
while ( isDigit ( cp ) || isLetter ( cp ) ) {
this . appendTokenValue ( cp , null ) ;
cp = this . consumeNextCodePoint ( ) ;
}
if ( cp === SEMICOLON ) {
this . reportParseError ( "unknown-named-character-reference" ) ;
}
return this . reconsumeAs ( this . returnState ) ;
}
NUMERIC_CHARACTER_REFERENCE ( cp ) {
this . crCode = 0 ;
if ( cp === LATIN_SMALL_X || cp === LATIN_CAPITAL_X ) {
this . buffer . push ( cp ) ;
return "HEXADEMICAL_CHARACTER_REFERENCE_START" ;
}
return this . reconsumeAs ( "DECIMAL_CHARACTER_REFERENCE_START" ) ;
}
HEXADEMICAL_CHARACTER_REFERENCE_START ( cp ) {
if ( isHexDigit ( cp ) ) {
return this . reconsumeAs ( "HEXADEMICAL_CHARACTER_REFERENCE" ) ;
}
this . reportParseError ( "absence-of-digits-in-numeric-character-reference" ) ;
return this . reconsumeAs ( "CHARACTER_REFERENCE_END" ) ;
}
DECIMAL_CHARACTER_REFERENCE_START ( cp ) {
if ( isDigit ( cp ) ) {
return this . reconsumeAs ( "DECIMAL_CHARACTER_REFERENCE" ) ;
}
this . reportParseError ( "absence-of-digits-in-numeric-character-reference" ) ;
return this . reconsumeAs ( "CHARACTER_REFERENCE_END" ) ;
}
HEXADEMICAL_CHARACTER_REFERENCE ( cp ) {
while ( true ) {
if ( isDigit ( cp ) ) {
this . crCode = 16 * this . crCode + ( cp - 0x30 ) ;
}
else if ( isUpperHexDigit ( cp ) ) {
this . crCode = 16 * this . crCode + ( cp - 0x37 ) ;
}
else if ( isLowerHexDigit ( cp ) ) {
this . crCode = 16 * this . crCode + ( cp - 0x57 ) ;
}
else {
if ( cp === SEMICOLON ) {
return "NUMERIC_CHARACTER_REFERENCE_END" ;
}
this . reportParseError ( "missing-semicolon-after-character-reference" ) ;
return this . reconsumeAs ( "NUMERIC_CHARACTER_REFERENCE_END" ) ;
}
cp = this . consumeNextCodePoint ( ) ;
}
}
DECIMAL_CHARACTER_REFERENCE ( cp ) {
while ( true ) {
if ( isDigit ( cp ) ) {
this . crCode = 10 * this . crCode + ( cp - 0x30 ) ;
}
else {
if ( cp === SEMICOLON ) {
return "NUMERIC_CHARACTER_REFERENCE_END" ;
}
this . reportParseError ( "missing-semicolon-after-character-reference" ) ;
return this . reconsumeAs ( "NUMERIC_CHARACTER_REFERENCE_END" ) ;
}
cp = this . consumeNextCodePoint ( ) ;
}
}
NUMERIC_CHARACTER_REFERENCE_END ( _ cp ) {
let code = this . crCode ;
if ( code === 0 ) {
this . reportParseError ( "null-character-reference" ) ;
code = NULL_REPLACEMENT ;
}
else if ( code > 0x10ffff ) {
this . reportParseError ( "character-reference-outside-unicode-range" ) ;
code = NULL_REPLACEMENT ;
}
else if ( isSurrogate ( code ) ) {
this . reportParseError ( "surrogate-character-reference" ) ;
code = NULL_REPLACEMENT ;
}
else if ( isNonCharacter ( code ) ) {
this . reportParseError ( "noncharacter-character-reference" ) ;
}
else if ( code === 0x0d || ( isControl ( code ) && ! isWhitespace ( code ) ) ) {
this . reportParseError ( "control-character-reference" ) ;
code = alternativeCR . get ( code ) || code ;
}
this . buffer = [ code ] ;
return this . reconsumeAs ( "CHARACTER_REFERENCE_END" ) ;
}
CHARACTER_REFERENCE_END ( _ cp ) {
assert__default [ "default" ] ( this . currentToken != null ) ;
const token = this . currentToken ;
const len0 = token . value . length ;
for ( const cp1 of this . buffer ) {
this . appendTokenValue ( cp1 , null ) ;
}
const newLength = token . value . length - len0 ;
for ( let i = this . crStartOffset + newLength ; i < this . offset ; ++ i ) {
this . gaps . push ( i ) ;
}
return this . reconsumeAs ( this . returnState ) ;
}
V_EXPRESSION_START ( cp ) {
var _ a , _ b ;
if ( cp === LEFT_CURLY_BRACKET ) {
this . startToken ( "VExpressionStart" ) ;
this . appendTokenValue ( LEFT_CURLY_BRACKET , null ) ;
this . appendTokenValue ( LEFT_CURLY_BRACKET , null ) ;
if ( ! ( ( _ b = ( _ a = this . parserOptions . vueFeatures ) === null || _ a === void 0 ? void 0 : _ a . interpolationAsNonHTML ) !== null && _ b !== void 0 ? _ b : true ) ) {
return this . returnState ;
}
const closeIndex = this . text . indexOf ( "}}" , this . offset + 1 ) ;
if ( closeIndex === - 1 ) {
this . reportParseError ( "x-missing-interpolation-end" ) ;
return this . returnState ;
}
this . vExpressionScriptState = {
state : this . returnState ,
} ;
return "V_EXPRESSION_DATA" ;
}
this . appendTokenValue ( LEFT_CURLY_BRACKET , null ) ;
return this . reconsumeAs ( this . returnState ) ;
}
V_EXPRESSION_DATA ( cp ) {
this . clearStartTokenMark ( ) ;
const state = this . vExpressionScriptState . state ;
while ( true ) {
const type = isWhitespace ( cp )
? "HTMLWhitespace"
: state === "RCDATA"
? "HTMLRawText"
: state === "RAWTEXT"
? "HTMLRCDataText"
: "HTMLText" ;
if ( this . currentToken != null && this . currentToken . type !== type ) {
this . endToken ( ) ;
return this . reconsumeAs ( this . state ) ;
}
if ( this . currentToken == null ) {
this . startToken ( type ) ;
}
if ( cp === AMPERSAND && state !== "RAWTEXT" ) {
this . returnState = "V_EXPRESSION_DATA" ;
return "CHARACTER_REFERENCE" ;
}
if ( cp === RIGHT_CURLY_BRACKET ) {
this . setStartTokenMark ( ) ;
this . returnState = "V_EXPRESSION_DATA" ;
return "V_EXPRESSION_END" ;
}
if ( cp === EOF ) {
this . reportParseError ( "x-missing-interpolation-end" ) ;
return "DATA" ;
}
if ( cp === NULL ) {
this . reportParseError ( "unexpected-null-character" ) ;
}
this . appendTokenValue ( cp , type ) ;
cp = this . consumeNextCodePoint ( ) ;
}
}
V_EXPRESSION_END ( cp ) {
if ( cp === RIGHT_CURLY_BRACKET ) {
this . startToken ( "VExpressionEnd" ) ;
this . appendTokenValue ( RIGHT_CURLY_BRACKET , null ) ;
this . appendTokenValue ( RIGHT_CURLY_BRACKET , null ) ;
return this . vExpressionScriptState
? this . vExpressionScriptState . state
: this . returnState ;
}
this . appendTokenValue ( RIGHT_CURLY_BRACKET , null ) ;
return this . reconsumeAs ( this . returnState ) ;
}
}
function getPossibleTypes ( parsedSelector ) {
switch ( parsedSelector . type ) {
case "identifier" :
return [ parsedSelector . value ] ;
case "matches" : {
const typesForComponents = parsedSelector . selectors . map ( getPossibleTypes ) ;
if ( typesForComponents . every ( Boolean ) ) {
return union__default [ "default" ] ( ... typesForComponents ) ;
}
return null ;
}
case "compound" : {
const typesForComponents = parsedSelector . selectors . map ( getPossibleTypes ) . filter ( Boolean ) ;
if ( ! typesForComponents . length ) {
return null ;
}
return intersection__default [ "default" ] ( ... typesForComponents ) ;
}
case "child" :
case "descendant" :
case "sibling" :
case "adjacent" :
return getPossibleTypes ( parsedSelector . right ) ;
default :
return null ;
}
}
function countClassAttributes ( parsedSelector ) {
switch ( parsedSelector . type ) {
case "child" :
case "descendant" :
case "sibling" :
case "adjacent" :
return countClassAttributes ( parsedSelector . left ) + countClassAttributes ( parsedSelector . right ) ;
case "compound" :
case "not" :
case "matches" :
return parsedSelector . selectors . reduce ( ( sum , childSelector ) => sum + countClassAttributes ( childSelector ) , 0 ) ;
case "attribute" :
case "field" :
case "nth-child" :
case "nth-last-child" :
return 1 ;
default :
return 0 ;
}
}
function countIdentifiers ( parsedSelector ) {
switch ( parsedSelector . type ) {
case "child" :
case "descendant" :
case "sibling" :
case "adjacent" :
return countIdentifiers ( parsedSelector . left ) + countIdentifiers ( parsedSelector . right ) ;
case "compound" :
case "not" :
case "matches" :
return parsedSelector . selectors . reduce ( ( sum , childSelector ) => sum + countIdentifiers ( childSelector ) , 0 ) ;
case "identifier" :
return 1 ;
default :
return 0 ;
}
}
function compareSpecificity ( selectorA , selectorB ) {
return selectorA . attributeCount - selectorB . attributeCount ||
selectorA . identifierCount - selectorB . identifierCount ||
( selectorA . rawSelector <= selectorB . rawSelector ? - 1 : 1 ) ;
}
function tryParseSelector ( rawSelector ) {
try {
return esquery__default [ "default" ] . parse ( rawSelector . replace ( /:exit$/ , "" ) ) ;
}
catch ( err ) {
if ( typeof err . offset === "number" ) {
throw new Error ( ` Syntax error in selector " ${ rawSelector } " at position ${ err . offset } : ${ err . message } ` ) ;
}
throw err ;
}
}
const parseSelector = memoize__default [ "default" ] ( rawSelector => {
const parsedSelector = tryParseSelector ( rawSelector ) ;
return {
rawSelector ,
isExit : rawSelector . endsWith ( ":exit" ) ,
parsedSelector ,
listenerTypes : getPossibleTypes ( parsedSelector ) ,
attributeCount : countClassAttributes ( parsedSelector ) ,
identifierCount : countIdentifiers ( parsedSelector ) ,
} ;
} ) ;
class NodeEventGenerator {
constructor ( emitter , esqueryOptions ) {
this . emitter = emitter ;
this . esqueryOptions = esqueryOptions ;
this . currentAncestry = [ ] ;
this . enterSelectorsByNodeType = new Map ( ) ;
this . exitSelectorsByNodeType = new Map ( ) ;
this . anyTypeEnterSelectors = [ ] ;
this . anyTypeExitSelectors = [ ] ;
const eventNames = typeof emitter . eventNames === "function"
? emitter . eventNames ( )
: Object . keys ( emitter . _ events ) ;
for ( const rawSelector of eventNames ) {
if ( typeof rawSelector === "symbol" ) {
continue ;
}
const selector = parseSelector ( rawSelector ) ;
if ( selector . listenerTypes ) {
for ( const nodeType of selector . listenerTypes ) {
const typeMap = selector . isExit ? this . exitSelectorsByNodeType : this . enterSelectorsByNodeType ;
let selectors = typeMap . get ( nodeType ) ;
if ( selectors == null ) {
typeMap . set ( nodeType , ( selectors = [ ] ) ) ;
}
selectors . push ( selector ) ;
}
}
else {
( selector . isExit ? this . anyTypeExitSelectors : this . anyTypeEnterSelectors ) . push ( selector ) ;
}
}
this . anyTypeEnterSelectors . sort ( compareSpecificity ) ;
this . anyTypeExitSelectors . sort ( compareSpecificity ) ;
for ( const selectorList of this . enterSelectorsByNodeType . values ( ) ) {
selectorList . sort ( compareSpecificity ) ;
}
for ( const selectorList of this . exitSelectorsByNodeType . values ( ) ) {
selectorList . sort ( compareSpecificity ) ;
}
}
applySelector ( node , selector ) {
if ( esquery__default [ "default" ] . matches ( node , selector . parsedSelector , this . currentAncestry , this . esqueryOptions ) ) {
this . emitter . emit ( selector . rawSelector , node ) ;
}
}
applySelectors ( node , isExit ) {
const selectorsByNodeType = ( isExit ? this . exitSelectorsByNodeType : this . enterSelectorsByNodeType ) . get ( node . type ) || [ ] ;
const anyTypeSelectors = isExit ? this . anyTypeExitSelectors : this . anyTypeEnterSelectors ;
let selectorsByTypeIndex = 0 ;
let anyTypeSelectorsIndex = 0 ;
while ( selectorsByTypeIndex < selectorsByNodeType . length || anyTypeSelectorsIndex < anyTypeSelectors . length ) {
if ( selectorsByTypeIndex >= selectorsByNodeType . length ||
( anyTypeSelectorsIndex < anyTypeSelectors . length && compareSpecificity ( anyTypeSelectors [ anyTypeSelectorsIndex ] , selectorsByNodeType [ selectorsByTypeIndex ] ) < 0 ) ) {
this . applySelector ( node , anyTypeSelectors [ anyTypeSelectorsIndex ++ ] ) ;
}
else {
this . applySelector ( node , selectorsByNodeType [ selectorsByTypeIndex ++ ] ) ;
}
}
}
enterNode ( node ) {
if ( node . parent ) {
this . currentAncestry . unshift ( node . parent ) ;
}
this . applySelectors ( node , false ) ;
}
leaveNode ( node ) {
this . applySelectors ( node , true ) ;
this . currentAncestry . shift ( ) ;
}
}
function getStartLocation ( token ) {
return token . range [ 0 ] ;
}
function search ( tokens , location ) {
return sortedIndexBy__default [ "default" ] ( tokens , { range : [ location ] } , getStartLocation ) ;
}
function getFirstIndex ( tokens , indexMap , startLoc ) {
if ( startLoc in indexMap ) {
return indexMap [ startLoc ] ;
}
if ( ( startLoc - 1 ) in indexMap ) {
const index = indexMap [ startLoc - 1 ] ;
const token = ( index >= 0 && index < tokens . length ) ? tokens [ index ] : null ;
if ( token && token . range [ 0 ] >= startLoc ) {
return index ;
}
return index + 1 ;
}
return 0 ;
}
function getLastIndex ( tokens , indexMap , endLoc ) {
if ( endLoc in indexMap ) {
return indexMap [ endLoc ] - 1 ;
}
if ( ( endLoc - 1 ) in indexMap ) {
const index = indexMap [ endLoc - 1 ] ;
const token = ( index >= 0 && index < tokens . length ) ? tokens [ index ] : null ;
if ( token && token . range [ 1 ] > endLoc ) {
return index - 1 ;
}
return index ;
}
return tokens . length - 1 ;
}
class Cursor {
constructor ( ) {
this . current = null ;
}
getOneToken ( ) {
return this . moveNext ( ) ? this . current : null ;
}
getAllTokens ( ) {
const tokens = [ ] ;
while ( this . moveNext ( ) ) {
tokens . push ( this . current ) ;
}
return tokens ;
}
}
class BackwardTokenCommentCursor extends Cursor {
constructor ( tokens , comments , indexMap , startLoc , endLoc ) {
super ( ) ;
this . tokens = tokens ;
this . comments = comments ;
this . tokenIndex = getLastIndex ( tokens , indexMap , endLoc ) ;
this . commentIndex = search ( comments , endLoc ) - 1 ;
this . border = startLoc ;
}
moveNext ( ) {
const token = ( this . tokenIndex >= 0 ) ? this . tokens [ this . tokenIndex ] : null ;
const comment = ( this . commentIndex >= 0 ) ? this . comments [ this . commentIndex ] : null ;
if ( token && ( ! comment || token . range [ 1 ] > comment . range [ 1 ] ) ) {
this . current = token ;
this . tokenIndex -= 1 ;
}
else if ( comment ) {
this . current = comment ;
this . commentIndex -= 1 ;
}
else {
this . current = null ;
}
return this . current != null && ( this . border === - 1 || this . current . range [ 0 ] >= this . border ) ;
}
}
class BackwardTokenCursor extends Cursor {
constructor ( tokens , _ comments , indexMap , startLoc , endLoc ) {
super ( ) ;
this . tokens = tokens ;
this . index = getLastIndex ( tokens , indexMap , endLoc ) ;
this . indexEnd = getFirstIndex ( tokens , indexMap , startLoc ) ;
}
moveNext ( ) {
if ( this . index >= this . indexEnd ) {
this . current = this . tokens [ this . index ] ;
this . index -= 1 ;
return true ;
}
return false ;
}
getOneToken ( ) {
return ( this . index >= this . indexEnd ) ? this . tokens [ this . index ] : null ;
}
}
class DecorativeCursor extends Cursor {
constructor ( cursor ) {
super ( ) ;
this . cursor = cursor ;
}
moveNext ( ) {
const retv = this . cursor . moveNext ( ) ;
this . current = this . cursor . current ;
return retv ;
}
}
class FilterCursor extends DecorativeCursor {
constructor ( cursor , predicate ) {
super ( cursor ) ;
this . predicate = predicate ;
}
moveNext ( ) {
const predicate = this . predicate ;
while ( super . moveNext ( ) ) {
if ( predicate ( this . current ) ) {
return true ;
}
}
return false ;
}
}
class ForwardTokenCommentCursor extends Cursor {
constructor ( tokens , comments , indexMap , startLoc , endLoc ) {
super ( ) ;
this . tokens = tokens ;
this . comments = comments ;
this . tokenIndex = getFirstIndex ( tokens , indexMap , startLoc ) ;
this . commentIndex = search ( comments , startLoc ) ;
this . border = endLoc ;
}
moveNext ( ) {
const token = ( this . tokenIndex < this . tokens . length ) ? this . tokens [ this . tokenIndex ] : null ;
const comment = ( this . commentIndex < this . comments . length ) ? this . comments [ this . commentIndex ] : null ;
if ( token && ( ! comment || token . range [ 0 ] < comment . range [ 0 ] ) ) {
this . current = token ;
this . tokenIndex += 1 ;
}
else if ( comment ) {
this . current = comment ;
this . commentIndex += 1 ;
}
else {
this . current = null ;
}
return this . current != null && ( this . border === - 1 || this . current . range [ 1 ] <= this . border ) ;
}
}
class ForwardTokenCursor extends Cursor {
constructor ( tokens , _ comments , indexMap , startLoc , endLoc ) {
super ( ) ;
this . tokens = tokens ;
this . index = getFirstIndex ( tokens , indexMap , startLoc ) ;
this . indexEnd = getLastIndex ( tokens , indexMap , endLoc ) ;
}
moveNext ( ) {
if ( this . index <= this . indexEnd ) {
this . current = this . tokens [ this . index ] ;
this . index += 1 ;
return true ;
}
return false ;
}
getOneToken ( ) {
return ( this . index <= this . indexEnd ) ? this . tokens [ this . index ] : null ;
}
getAllTokens ( ) {
return this . tokens . slice ( this . index , this . indexEnd + 1 ) ;
}
}
class LimitCursor extends DecorativeCursor {
constructor ( cursor , count ) {
super ( cursor ) ;
this . count = count ;
}
moveNext ( ) {
if ( this . count > 0 ) {
this . count -= 1 ;
return super . moveNext ( ) ;
}
return false ;
}
}
class SkipCursor extends DecorativeCursor {
constructor ( cursor , count ) {
super ( cursor ) ;
this . count = count ;
}
moveNext ( ) {
while ( this . count > 0 ) {
this . count -= 1 ;
if ( ! super . moveNext ( ) ) {
return false ;
}
}
return super . moveNext ( ) ;
}
}
class CursorFactory {
constructor ( TokenCursor , TokenCommentCursor ) {
this . TokenCursor = TokenCursor ;
this . TokenCommentCursor = TokenCommentCursor ;
}
createBaseCursor ( tokens , comments , indexMap , startLoc , endLoc , includeComments ) {
const TokenCursor = includeComments ? this . TokenCommentCursor : this . TokenCursor ;
return new TokenCursor ( tokens , comments , indexMap , startLoc , endLoc ) ;
}
createCursor ( tokens , comments , indexMap , startLoc , endLoc , includeComments , filter , skip , count ) {
let cursor = this . createBaseCursor ( tokens , comments , indexMap , startLoc , endLoc , includeComments ) ;
if ( filter ) {
cursor = new FilterCursor ( cursor , filter ) ;
}
if ( skip >= 1 ) {
cursor = new SkipCursor ( cursor , skip ) ;
}
if ( count >= 0 ) {
cursor = new LimitCursor ( cursor , count ) ;
}
return cursor ;
}
}
const forward = new CursorFactory ( ForwardTokenCursor , ForwardTokenCommentCursor ) ;
const backward = new CursorFactory ( BackwardTokenCursor , BackwardTokenCommentCursor ) ;
class PaddedTokenCursor extends ForwardTokenCursor {
constructor ( tokens , comments , indexMap , startLoc , endLoc , beforeCount , afterCount ) {
super ( tokens , comments , indexMap , startLoc , endLoc ) ;
this . index = Math . max ( 0 , this . index - beforeCount ) ;
this . indexEnd = Math . min ( tokens . length - 1 , this . indexEnd + afterCount ) ;
}
}
function isCommentToken ( token ) {
return token . type === "Line" || token . type === "Block" || token . type === "Shebang" ;
}
function createIndexMap ( tokens , comments ) {
const map = Object . create ( null ) ;
let tokenIndex = 0 ;
let commentIndex = 0 ;
let nextStart = 0 ;
let range = null ;
while ( tokenIndex < tokens . length || commentIndex < comments . length ) {
nextStart = ( commentIndex < comments . length ) ? comments [ commentIndex ] . range [ 0 ] : Number . MAX_SAFE_INTEGER ;
while ( tokenIndex < tokens . length && ( range = tokens [ tokenIndex ] . range ) [ 0 ] < nextStart ) {
map [ range [ 0 ] ] = tokenIndex ;
map [ range [ 1 ] - 1 ] = tokenIndex ;
tokenIndex += 1 ;
}
nextStart = ( tokenIndex < tokens . length ) ? tokens [ tokenIndex ] . range [ 0 ] : Number . MAX_SAFE_INTEGER ;
while ( commentIndex < comments . length && ( range = comments [ commentIndex ] . range ) [ 0 ] < nextStart ) {
map [ range [ 0 ] ] = tokenIndex ;
map [ range [ 1 ] - 1 ] = tokenIndex ;
commentIndex += 1 ;
}
}
return map ;
}
function createCursorWithSkip ( factory , tokens , comments , indexMap , startLoc , endLoc , opts ) {
let includeComments = false ;
let skip = 0 ;
let filter = null ;
if ( typeof opts === "number" ) {
skip = opts | 0 ;
}
else if ( typeof opts === "function" ) {
filter = opts ;
}
else if ( opts ) {
includeComments = Boolean ( opts . includeComments ) ;
skip = opts . skip || 0 ;
filter = opts . filter || null ;
}
assert__default [ "default" ] ( skip >= 0 , "options.skip should be zero or a positive integer." ) ;
assert__default [ "default" ] ( ! filter || typeof filter === "function" , "options.filter should be a function." ) ;
return factory . createCursor ( tokens , comments , indexMap , startLoc , endLoc , includeComments , filter , skip , - 1 ) ;
}
function createCursorWithCount ( factory , tokens , comments , indexMap , startLoc , endLoc , opts ) {
let includeComments = false ;
let count = 0 ;
let countExists = false ;
let filter = null ;
if ( typeof opts === "number" ) {
count = opts | 0 ;
countExists = true ;
}
else if ( typeof opts === "function" ) {
filter = opts ;
}
else if ( opts ) {
includeComments = Boolean ( opts . includeComments ) ;
count = opts . count || 0 ;
countExists = typeof opts . count === "number" ;
filter = opts . filter || null ;
}
assert__default [ "default" ] ( count >= 0 , "options.count should be zero or a positive integer." ) ;
assert__default [ "default" ] ( ! filter || typeof filter === "function" , "options.filter should be a function." ) ;
return factory . createCursor ( tokens , comments , indexMap , startLoc , endLoc , includeComments , filter , 0 , countExists ? count : - 1 ) ;
}
function createCursorWithPadding ( tokens , comments , indexMap , startLoc , endLoc , beforeCount , afterCount ) {
if ( typeof beforeCount === "undefined" && typeof afterCount === "undefined" ) {
return new ForwardTokenCursor ( tokens , comments , indexMap , startLoc , endLoc ) ;
}
if ( typeof beforeCount === "number" || typeof beforeCount === "undefined" ) {
return new PaddedTokenCursor ( tokens , comments , indexMap , startLoc , endLoc , beforeCount || 0 , afterCount || 0 ) ;
}
return createCursorWithCount ( forward , tokens , comments , indexMap , startLoc , endLoc , beforeCount ) ;
}
function getAdjacentCommentTokensFromCursor ( cursor ) {
const tokens = [ ] ;
let currentToken = cursor . getOneToken ( ) ;
while ( currentToken && isCommentToken ( currentToken ) ) {
tokens . push ( currentToken ) ;
currentToken = cursor . getOneToken ( ) ;
}
return tokens ;
}
class TokenStore {
constructor ( tokens , comments ) {
this . _ tokens = tokens ;
this . _ comments = comments ;
this . _ indexMap = createIndexMap ( tokens , comments ) ;
}
getTokenByRangeStart ( offset , options ) {
const includeComments = Boolean ( options && options . includeComments ) ;
const token = forward . createBaseCursor ( this . _ tokens , this . _ comments , this . _ indexMap , offset , - 1 , includeComments ) . getOneToken ( ) ;
if ( token && token . range [ 0 ] === offset ) {
return token ;
}
return null ;
}
getFirstToken ( node , options ) {
return createCursorWithSkip ( forward , this . _ tokens , this . _ comments , this . _ indexMap , node . range [ 0 ] , node . range [ 1 ] , options ) . getOneToken ( ) ;
}
getLastToken ( node , options ) {
return createCursorWithSkip ( backward , this . _ tokens , this . _ comments , this . _ indexMap , node . range [ 0 ] , node . range [ 1 ] , options ) . getOneToken ( ) ;
}
getTokenBefore ( node , options ) {
return createCursorWithSkip ( backward , this . _ tokens , this . _ comments , this . _ indexMap , - 1 , node . range [ 0 ] , options ) . getOneToken ( ) ;
}
getTokenAfter ( node , options ) {
return createCursorWithSkip ( forward , this . _ tokens , this . _ comments , this . _ indexMap , node . range [ 1 ] , - 1 , options ) . getOneToken ( ) ;
}
getFirstTokenBetween ( left , right , options ) {
return createCursorWithSkip ( forward , this . _ tokens , this . _ comments , this . _ indexMap , left . range [ 1 ] , right . range [ 0 ] , options ) . getOneToken ( ) ;
}
getLastTokenBetween ( left , right , options ) {
return createCursorWithSkip ( backward , this . _ tokens , this . _ comments , this . _ indexMap , left . range [ 1 ] , right . range [ 0 ] , options ) . getOneToken ( ) ;
}
getTokenOrCommentBefore ( node , skip ) {
return this . getTokenBefore ( node , { includeComments : true , skip } ) ;
}
getTokenOrCommentAfter ( node , skip ) {
return this . getTokenAfter ( node , { includeComments : true , skip } ) ;
}
getFirstTokens ( node , options ) {
return createCursorWithCount ( forward , this . _ tokens , this . _ comments , this . _ indexMap , node . range [ 0 ] , node . range [ 1 ] , options ) . getAllTokens ( ) ;
}
getLastTokens ( node , options ) {
return createCursorWithCount ( backward , this . _ tokens , this . _ comments , this . _ indexMap , node . range [ 0 ] , node . range [ 1 ] , options ) . getAllTokens ( ) . reverse ( ) ;
}
getTokensBefore ( node , options ) {
return createCursorWithCount ( backward , this . _ tokens , this . _ comments , this . _ indexMap , - 1 , node . range [ 0 ] , options ) . getAllTokens ( ) . reverse ( ) ;
}
getTokensAfter ( node , options ) {
return createCursorWithCount ( forward , this . _ tokens , this . _ comments , this . _ indexMap , node . range [ 1 ] , - 1 , options ) . getAllTokens ( ) ;
}
getFirstTokensBetween ( left , right , options ) {
return createCursorWithCount ( forward , this . _ tokens , this . _ comments , this . _ indexMap , left . range [ 1 ] , right . range [ 0 ] , options ) . getAllTokens ( ) ;
}
getLastTokensBetween ( left , right , options ) {
return createCursorWithCount ( backward , this . _ tokens , this . _ comments , this . _ indexMap , left . range [ 1 ] , right . range [ 0 ] , options ) . getAllTokens ( ) . reverse ( ) ;
}
getTokens ( node , beforeCount , afterCount ) {
return createCursorWithPadding ( this . _ tokens , this . _ comments , this . _ indexMap , node . range [ 0 ] , node . range [ 1 ] , beforeCount , afterCount ) . getAllTokens ( ) ;
}
getTokensBetween ( left , right , padding ) {
return createCursorWithPadding ( this . _ tokens , this . _ comments , this . _ indexMap , left . range [ 1 ] , right . range [ 0 ] , padding , typeof padding === "number" ? padding : undefined ) . getAllTokens ( ) ;
}
commentsExistBetween ( left , right ) {
const index = search ( this . _ comments , left . range [ 1 ] ) ;
return ( index < this . _ comments . length &&
this . _ comments [ index ] . range [ 1 ] <= right . range [ 0 ] ) ;
}
getCommentsBefore ( nodeOrToken ) {
const cursor = createCursorWithCount ( backward , this . _ tokens , this . _ comments , this . _ indexMap , - 1 , nodeOrToken . range [ 0 ] , { includeComments : true } ) ;
return getAdjacentCommentTokensFromCursor ( cursor ) . reverse ( ) ;
}
getCommentsAfter ( nodeOrToken ) {
const cursor = createCursorWithCount ( forward , this . _ tokens , this . _ comments , this . _ indexMap , nodeOrToken . range [ 1 ] , - 1 , { includeComments : true } ) ;
return getAdjacentCommentTokensFromCursor ( cursor ) ;
}
getCommentsInside ( node ) {
return this . getTokens ( node , {
includeComments : true ,
filter : isCommentToken ,
} ) ;
}
}
function isVElement ( node ) {
return node . type === "VElement" ;
}
function getCustomBlocks ( document ) {
return document
? document . children
. filter ( isVElement )
. filter ( ( block ) => block . name !== "script" &&
block . name !== "template" &&
block . name !== "style" )
: [ ] ;
}
function parseCustomBlockElement ( node , parser , globalLocationCalculator , parserOptions ) {
const text = node . children [ 0 ] ;
const { code , range , loc } = text != null && text . type === "VText"
? {
code : text . value ,
range : text . range ,
loc : text . loc ,
}
: {
code : "" ,
range : [
node . startTag . range [ 1 ] ,
node . endTag . range [ 0 ] ,
] ,
loc : {
start : node . startTag . loc . end ,
end : node . endTag . loc . start ,
} ,
} ;
const locationCalculator = globalLocationCalculator . getSubCalculatorAfter ( range [ 0 ] ) ;
try {
return parseCustomBlockFragment ( code , parser , locationCalculator , parserOptions ) ;
}
catch ( e ) {
if ( ! ( e instanceof Error ) ) {
throw e ;
}
return {
error : e ,
ast : {
type : "Program" ,
sourceType : "module" ,
loc : {
start : Object . assign ( { } , loc . start ) ,
end : Object . assign ( { } , loc . end ) ,
} ,
range : [ ... range ] ,
body : [ ] ,
tokens : [ ] ,
comments : [ ] ,
} ,
} ;
}
}
function parseCustomBlockFragment ( code , parser , locationCalculator , parserOptions ) {
try {
const result = parseBlock ( code , parser , Object . assign ( { ecmaVersion : DEFAULT_ECMA_VERSION , loc : true , range : true , raw : true , tokens : true , comment : true , eslintVisitorKeys : true , eslintScopeManager : true } , parserOptions ) ) ;
fixLocations ( result , locationCalculator ) ;
return result ;
}
catch ( err ) {
const perr = ParseError . normalize ( err ) ;
if ( perr ) {
fixErrorLocation ( perr , locationCalculator ) ;
throw perr ;
}
throw err ;
}
}
function parseBlock ( code , parser , parserOptions ) {
const result = isEnhancedParserObject ( parser )
? parser . parseForESLint ( code , parserOptions )
: parser . parse ( code , parserOptions ) ;
if ( result . ast != null ) {
return result ;
}
return { ast : result } ;
}
function createCustomBlockSharedContext ( { text , customBlock , parsedResult , globalLocationCalculator , parserOptions , } ) {
let sourceCode ;
let currentNode ;
return {
serCurrentNode ( node ) {
currentNode = node ;
} ,
context : {
getAncestors : ( ) => getSourceCode ( ) . getAncestors ( currentNode ) ,
getDeclaredVariables : ( ... args ) => getSourceCode ( ) . getDeclaredVariables ( ... args ) ,
getScope : ( ) => getSourceCode ( ) . getScope ( currentNode ) ,
markVariableAsUsed : ( name ) => getSourceCode ( ) . markVariableAsUsed ( name , currentNode ) ,
get parserServices ( ) {
return getSourceCode ( ) . parserServices ;
} ,
getSourceCode ,
get sourceCode ( ) {
return getSourceCode ( ) ;
} ,
} ,
} ;
function getSourceCode ( ) {
if ( sourceCode ) {
return sourceCode ;
}
const scopeManager = getScopeManager ( ) ;
const originalSourceCode = new ( require ( "eslint" ) . SourceCode ) ( {
text ,
ast : parsedResult . ast ,
parserServices : Object . assign ( Object . assign ( { customBlock ,
parseCustomBlockElement ( parser , options ) {
return parseCustomBlockElement ( customBlock , parser , globalLocationCalculator , Object . assign ( Object . assign ( { } , parserOptions ) , options ) ) ;
} } , ( parsedResult . services || { } ) ) , ( parsedResult . error
? { parseError : parsedResult . error }
: { } ) ) ,
scopeManager ,
visitorKeys : parsedResult . visitorKeys ,
} ) ;
const polyfills = {
markVariableAsUsed : ( name , node ) => markVariableAsUsed ( scopeManager , node , parsedResult . ast , name ) ,
getScope : ( node ) => getScope ( scopeManager , node ) ,
getAncestors : ( node ) => getAncestors ( node ) ,
getDeclaredVariables : ( ... args ) => scopeManager . getDeclaredVariables ( ... args ) ,
} ;
return ( sourceCode = new Proxy ( originalSourceCode , {
get ( _ target , prop ) {
return originalSourceCode [ prop ] || polyfills [ prop ] ;
} ,
} ) ) ;
}
function getScopeManager ( ) {
if ( parsedResult . scopeManager ) {
return parsedResult . scopeManager ;
}
const ecmaVersion = getEcmaVersionIfUseEspree ( parserOptions ) || 2022 ;
const ecmaFeatures = parserOptions . ecmaFeatures || { } ;
const sourceType = parserOptions . sourceType || "script" ;
return getEslintScope ( ) . analyze ( parsedResult . ast , {
ignoreEval : true ,
nodejsScope : false ,
impliedStrict : ecmaFeatures . impliedStrict ,
ecmaVersion ,
sourceType ,
fallback : getFallbackKeys ,
} ) ;
}
}
function getAncestors ( node ) {
const ancestorsStartingAtParent = [ ] ;
for ( let ancestor = node . parent ; ancestor ; ancestor = ancestor . parent ) {
ancestorsStartingAtParent . push ( ancestor ) ;
}
return ancestorsStartingAtParent . reverse ( ) ;
}
function getScope ( scopeManager , currentNode ) {
const inner = currentNode . type !== "Program" ;
for ( let node = currentNode ; node ; node = node . parent || null ) {
const scope = scopeManager . acquire ( node , inner ) ;
if ( scope ) {
if ( scope . type === "function-expression-name" ) {
return scope . childScopes [ 0 ] ;
}
return scope ;
}
}
return scopeManager . scopes [ 0 ] ;
}
function markVariableAsUsed ( scopeManager , currentNode , program , name ) {
const currentScope = getScope ( scopeManager , currentNode ) ;
let initialScope = currentScope ;
if ( currentScope . type === "global" &&
currentScope . childScopes . length > 0 &&
currentScope . childScopes [ 0 ] . block === program ) {
initialScope = currentScope . childScopes [ 0 ] ;
}
for ( let scope = initialScope ; scope ; scope = scope . upper ) {
const variable = scope . variables . find ( ( scopeVar ) => scopeVar . name === name ) ;
if ( variable ) {
variable . eslintUsed = true ;
return true ;
}
}
return false ;
}
function define ( sourceText , rootAST , document , globalLocationCalculator , { parserOptions } ) {
const templateBodyEmitters = new Map ( ) ;
const stores = new WeakMap ( ) ;
const documentEmitters = new Map ( ) ;
const customBlocksEmitters = new Map ( ) ;
const isSFC = isSFCFile ( parserOptions ) ;
return {
defineTemplateBodyVisitor ( templateBodyVisitor , scriptVisitor , options ) {
var _ a ;
if ( scriptVisitor == null ) {
scriptVisitor = { } ;
}
if ( rootAST . templateBody == null ) {
return scriptVisitor ;
}
const templateBodyTriggerSelector = ( _ a = options === null || options === void 0 ? void 0 : options . templateBodyTriggerSelector ) !== null && _ a !== void 0 ? _ a : "Program:exit" ;
let emitter = templateBodyEmitters . get ( templateBodyTriggerSelector ) ;
if ( emitter == null ) {
emitter = new EventEmitter__default [ "default" ] ( ) ;
emitter . setMaxListeners ( 0 ) ;
templateBodyEmitters . set ( templateBodyTriggerSelector , emitter ) ;
const programExitHandler = scriptVisitor [ templateBodyTriggerSelector ] ;
scriptVisitor [ templateBodyTriggerSelector ] = ( node ) => {
try {
if ( typeof programExitHandler === "function" ) {
programExitHandler ( node ) ;
}
const generator = new NodeEventGenerator ( emitter , {
visitorKeys : KEYS ,
fallback : getFallbackKeys ,
} ) ;
traverseNodes ( rootAST . templateBody , generator ) ;
}
finally {
scriptVisitor [ templateBodyTriggerSelector ] =
programExitHandler ;
templateBodyEmitters . delete ( templateBodyTriggerSelector ) ;
}
} ;
}
for ( const selector of Object . keys ( templateBodyVisitor ) ) {
emitter . on ( selector , templateBodyVisitor [ selector ] ) ;
}
return scriptVisitor ;
} ,
defineDocumentVisitor ( documentVisitor , options ) {
var _ a ;
const scriptVisitor = { } ;
if ( ! document ) {
return scriptVisitor ;
}
const documentTriggerSelector = ( _ a = options === null || options === void 0 ? void 0 : options . triggerSelector ) !== null && _ a !== void 0 ? _ a : "Program:exit" ;
let emitter = documentEmitters . get ( documentTriggerSelector ) ;
if ( emitter == null ) {
emitter = new EventEmitter__default [ "default" ] ( ) ;
emitter . setMaxListeners ( 0 ) ;
documentEmitters . set ( documentTriggerSelector , emitter ) ;
const programExitHandler = scriptVisitor [ documentTriggerSelector ] ;
scriptVisitor [ documentTriggerSelector ] = ( node ) => {
try {
if ( typeof programExitHandler === "function" ) {
programExitHandler ( node ) ;
}
const generator = new NodeEventGenerator ( emitter , {
visitorKeys : KEYS ,
fallback : getFallbackKeys ,
} ) ;
traverseNodes ( document , generator ) ;
}
finally {
scriptVisitor [ documentTriggerSelector ] =
programExitHandler ;
documentEmitters . delete ( documentTriggerSelector ) ;
}
} ;
}
for ( const selector of Object . keys ( documentVisitor ) ) {
emitter . on ( selector , documentVisitor [ selector ] ) ;
}
return scriptVisitor ;
} ,
defineCustomBlocksVisitor ( context , parser , rule , scriptVisitor ) {
var _ a ;
if ( scriptVisitor == null ) {
scriptVisitor = { } ;
}
if ( ! isSFC ) {
return scriptVisitor ;
}
parserOptions = Object . assign ( { } , parserOptions ) ;
const customBlocks = getCustomBlocks ( document ) . filter ( ( block ) => block . endTag &&
! block . startTag . attributes . some ( ( attr ) => ! attr . directive && attr . key . name === "src" ) ) ;
if ( ! customBlocks . length || globalLocationCalculator == null ) {
return { } ;
}
const key = ( _ a = parser . parseForESLint ) !== null && _ a !== void 0 ? _ a : parser . parse ;
let factories = customBlocksEmitters . get ( key ) ;
if ( factories == null ) {
factories = [ ] ;
customBlocksEmitters . set ( key , factories ) ;
const visitorFactories = factories ;
const programExitHandler = scriptVisitor [ "Program:exit" ] ;
scriptVisitor [ "Program:exit" ] = ( node ) => {
try {
if ( typeof programExitHandler === "function" ) {
programExitHandler ( node ) ;
}
for ( const customBlock of customBlocks ) {
const lang = getLang ( customBlock ) ;
const activeVisitorFactories = visitorFactories . filter ( ( f ) => f . test ( lang , customBlock ) ) ;
if ( ! activeVisitorFactories . length ) {
continue ;
}
const parsedResult = parseCustomBlockElement ( customBlock , parser , globalLocationCalculator , parserOptions ) ;
const { serCurrentNode , context : customBlockContext , } = createCustomBlockSharedContext ( {
text : sourceText ,
customBlock ,
parsedResult ,
globalLocationCalculator ,
parserOptions ,
} ) ;
const emitter = new EventEmitter__default [ "default" ] ( ) ;
emitter . setMaxListeners ( 0 ) ;
for ( const factory of activeVisitorFactories ) {
const ctx = Object . assign ( { } , customBlockContext ) ;
ctx . __ proto__ = factory . context ;
const visitor = factory . create ( ctx ) ;
for ( const selector of Object . keys ( visitor || { } ) ) {
emitter . on ( selector , visitor [ selector ] ) ;
}
}
const generator = new NodeEventGenerator ( emitter , {
visitorKeys : parsedResult . visitorKeys ,
fallback : getFallbackKeys ,
} ) ;
traverseNodes ( parsedResult . ast , {
visitorKeys : parsedResult . visitorKeys ,
enterNode ( n ) {
serCurrentNode ( n ) ;
generator . enterNode ( n ) ;
} ,
leaveNode ( n ) {
serCurrentNode ( n ) ;
generator . leaveNode ( n ) ;
} ,
} ) ;
}
}
finally {
scriptVisitor [ "Program:exit" ] = programExitHandler ;
customBlocksEmitters . delete ( key ) ;
}
} ;
}
const target = rule . target ;
const test = typeof target === "function"
? target
: Array . isArray ( target )
? ( lang ) => Boolean ( lang && target . includes ( lang ) )
: ( lang ) => target === lang ;
factories . push ( {
context ,
test ,
create : rule . create ,
} ) ;
return scriptVisitor ;
} ,
getTemplateBodyTokenStore ( ) {
const key = document || stores ;
let store = stores . get ( key ) ;
if ( ! store ) {
store =
document != null
? new TokenStore ( document . tokens , document . comments )
: new TokenStore ( [ ] , [ ] ) ;
stores . set ( key , store ) ;
}
return store ;
} ,
getDocumentFragment ( ) {
return document ;
} ,
} ;
}
class CodeBlocks {
constructor ( ) {
this . remapBlocks = [ ] ;
this . splitPunctuators = [ ] ;
this . code = "" ;
}
get length ( ) {
return this . code . length ;
}
append ( codeLet , originalOffset ) {
const rangeStart = this . code . length ;
this . code += codeLet . trimEnd ( ) ;
this . remapBlocks . push ( {
range : [ rangeStart , this . code . length ] ,
offset : originalOffset - rangeStart ,
} ) ;
}
appendSplitPunctuators ( punctuator ) {
this . splitPunctuators . push ( this . code . length , this . code . length + 1 ) ;
this . code += ` \n ${ punctuator } \n ` ;
}
appendCodeBlocks ( codeBlocks ) {
const start = this . code . length ;
this . code += codeBlocks . code ;
this . remapBlocks . push ( ... codeBlocks . remapBlocks . map ( ( b ) => ( {
range : [ b . range [ 0 ] + start , b . range [ 1 ] + start ] ,
offset : b . offset - start ,
} ) ) ) ;
this . splitPunctuators . push ( ... codeBlocks . splitPunctuators . map ( ( s ) => s + start ) ) ;
}
}
class RestoreASTCallbacks {
constructor ( ) {
this . callbacks = [ ] ;
}
addCallback ( originalOffsetStart , range , callback ) {
this . callbacks . push ( {
range : [
originalOffsetStart + range [ 0 ] ,
originalOffsetStart + range [ 1 ] ,
] ,
callback ,
} ) ;
}
restore ( program , scriptSetupStatements , linesAndColumns ) {
if ( this . callbacks . length === 0 ) {
return ;
}
const callbacks = new Set ( this . callbacks ) ;
for ( const statement of scriptSetupStatements ) {
for ( const cb of callbacks ) {
if ( cb . range [ 0 ] <= statement . range [ 0 ] &&
statement . range [ 1 ] <= cb . range [ 1 ] ) {
const restored = cb . callback ( statement ) ;
if ( restored ) {
const removeIndex = program . body . indexOf ( statement ) ;
if ( removeIndex >= 0 ) {
program . body . splice ( removeIndex , 1 ) ;
program . body . push ( restored . statement ) ;
program . tokens . push ( ... restored . tokens ) ;
restored . statement . parent = program ;
callbacks . delete ( cb ) ;
break ;
}
}
}
}
}
if ( callbacks . size ) {
const [ cb ] = callbacks ;
const loc = linesAndColumns . getLocFromIndex ( cb . range [ 0 ] ) ;
throw new ParseError ( "Could not parse <script setup>. Failed to restore ExportNamedDeclaration." , undefined , cb . range [ 0 ] , loc . line , loc . column ) ;
}
}
}
function parseScript ( code , parserOptions , locationCalculatorForError ) {
try {
return parseScript$1 ( code , parserOptions ) ;
}
catch ( err ) {
const perr = ParseError . normalize ( err ) ;
if ( perr ) {
fixErrorLocation ( perr , locationCalculatorForError ) ;
throw perr ;
}
throw err ;
}
}
function parseScriptSetupElements ( scriptSetupElement , scriptElement , sfcCode , linesAndColumns , originalParserOptions ) {
const parserOptions = getScriptSetupParserOptions ( originalParserOptions ) ;
const scriptSetupModuleCodeBlocks = getScriptSetupModuleCodeBlocks ( scriptSetupElement , scriptElement , sfcCode , linesAndColumns , parserOptions ) ;
if ( ! scriptSetupModuleCodeBlocks ) {
return parseScriptFragment ( "" , linesAndColumns . createOffsetLocationCalculator ( scriptSetupElement . startTag . range [ 1 ] ) , parserOptions ) ;
}
const locationCalculator = {
getFixOffset ( offset , kind ) {
const test = kind === "start"
? ( block ) => block . range [ 0 ] <= offset && offset < block . range [ 1 ]
: ( block ) => block . range [ 0 ] < offset && offset <= block . range [ 1 ] ;
for ( const block of scriptSetupModuleCodeBlocks . codeBlocks
. remapBlocks ) {
if ( test ( block ) ) {
return block . offset ;
}
}
return offset ;
} ,
getLocFromIndex : linesAndColumns . getLocFromIndex . bind ( linesAndColumns ) ,
} ;
const result = parseScript ( scriptSetupModuleCodeBlocks . codeBlocks . code , parserOptions , locationCalculator ) ;
if ( scriptSetupModuleCodeBlocks . postprocess ) {
scriptSetupModuleCodeBlocks . postprocess ( result , {
scriptSetupBlockRange : scriptSetupModuleCodeBlocks . scriptSetupBlockRange ,
} ) ;
}
const scriptSetupStatements = remapAST ( result , scriptSetupModuleCodeBlocks ) ;
remapLocationAndTokens ( result , scriptSetupModuleCodeBlocks , locationCalculator ) ;
if ( scriptSetupModuleCodeBlocks . restoreASTCallbacks ) {
scriptSetupModuleCodeBlocks . restoreASTCallbacks . restore ( result . ast , scriptSetupStatements , linesAndColumns ) ;
}
if ( result . ast . tokens != null ) {
for ( const node of [ scriptSetupElement , scriptElement ] ) {
const startTag = node . startTag ;
const endTag = node . endTag ;
result . ast . tokens . unshift ( {
type : "Punctuator" ,
range : startTag . range ,
loc : startTag . loc ,
value : "<script>" ,
} ) ;
if ( endTag != null ) {
result . ast . tokens . push ( {
type : "Punctuator" ,
range : endTag . range ,
loc : endTag . loc ,
value : "</script>" ,
} ) ;
}
}
result . ast . tokens . sort ( ( a , b ) => a . range [ 0 ] - b . range [ 0 ] ) ;
}
result . ast . body . sort ( ( a , b ) => a . range [ 0 ] - b . range [ 0 ] ) ;
const programStartOffset = result . ast . body . reduce ( ( start , node ) => Math . min ( start , node . range [ 0 ] ) , result . ast . range [ 0 ] ) ;
result . ast . range [ 0 ] = programStartOffset ;
result . ast . loc . start =
locationCalculator . getLocFromIndex ( programStartOffset ) ;
if ( result . ast . start != null ) {
result . ast . start = [ scriptSetupElement , scriptElement ] . reduce ( ( start , node ) => {
const textNode = node . children [ 0 ] ;
return Math . min ( start , textNode != null && textNode . type === "VText"
? textNode . range [ 0 ]
: node . startTag . range [ 1 ] ) ;
} , result . ast . start ) ;
}
const programEndOffset = result . ast . body . reduce ( ( end , node ) => Math . max ( end , node . range [ 1 ] ) , 0 ) ;
result . ast . range [ 1 ] = programEndOffset ;
result . ast . loc . end = locationCalculator . getLocFromIndex ( programEndOffset ) ;
if ( result . ast . end != null ) {
result . ast . end = [ scriptSetupElement , scriptElement ] . reduce ( ( end , node ) => {
var _ a , _ b ;
const textNode = node . children [ 0 ] ;
return Math . max ( end , textNode != null && textNode . type === "VText"
? textNode . range [ 1 ]
: ( _ b = ( _ a = node . endTag ) === null || _ a === void 0 ? void 0 : _ a . range [ 0 ] ) !== null && _ b !== void 0 ? _ b : node . range [ 1 ] ) ;
} , 0 ) ;
}
return result ;
}
function getScriptSetupModuleCodeBlocks ( scriptSetupElement , scriptElement , sfcCode , linesAndColumns , parserOptions ) {
const scriptSetupCodeBlocks = getScriptSetupCodeBlocks ( scriptSetupElement , sfcCode , linesAndColumns , parserOptions ) ;
const textNode = scriptElement . children [ 0 ] ;
if ( textNode == null || textNode . type !== "VText" ) {
return scriptSetupCodeBlocks ;
}
const [ scriptStartOffset , scriptEndOffset ] = textNode . range ;
const codeBlocks = new CodeBlocks ( ) ;
codeBlocks . append ( sfcCode . slice ( scriptStartOffset , scriptEndOffset ) , scriptStartOffset ) ;
if ( scriptSetupCodeBlocks == null ) {
return { codeBlocks } ;
}
codeBlocks . appendSplitPunctuators ( ";" ) ;
const scriptSetupOffset = codeBlocks . length ;
codeBlocks . appendCodeBlocks ( scriptSetupCodeBlocks . codeBlocks ) ;
return {
codeBlocks ,
scriptSetupBlockRange : [
scriptSetupCodeBlocks . scriptSetupBlockRange [ 0 ] + scriptSetupOffset ,
scriptSetupCodeBlocks . scriptSetupBlockRange [ 1 ] + scriptSetupOffset ,
] ,
postprocess : scriptSetupCodeBlocks . postprocess ,
restoreASTCallbacks : scriptSetupCodeBlocks . restoreASTCallbacks ,
} ;
}
function getScriptSetupCodeBlocks ( node , sfcCode , linesAndColumns , parserOptions ) {
const textNode = node . children [ 0 ] ;
if ( textNode == null || textNode . type !== "VText" ) {
return null ;
}
const [ scriptSetupStartOffset , scriptSetupEndOffset ] = textNode . range ;
const scriptCode = sfcCode . slice ( scriptSetupStartOffset , scriptSetupEndOffset ) ;
const offsetLocationCalculator = linesAndColumns . createOffsetLocationCalculator ( scriptSetupStartOffset ) ;
const result = parseScript ( scriptCode , parserOptions , offsetLocationCalculator ) ;
const { ast } = result ;
const importCodeBlocks = new CodeBlocks ( ) ;
const statementCodeBlocks = new CodeBlocks ( ) ;
const exportDefaultCodeBlocks = new CodeBlocks ( ) ;
const restoreASTCallbacks = new RestoreASTCallbacks ( ) ;
let usedOffset = 0 ;
function append ( codeBlocks , start , end ) {
if ( start < end ) {
codeBlocks . append ( scriptCode . slice ( start , end ) , scriptSetupStartOffset + start ) ;
usedOffset = end ;
return true ;
}
return false ;
}
function appendRangeAsStatement ( codeBlocks , start , end ) {
if ( append ( codeBlocks , start , end ) ) {
codeBlocks . appendSplitPunctuators ( ";" ) ;
}
}
function transformExportNamed ( body ) {
const [ start , end ] = getNodeFullRange ( body ) ;
appendRangeAsStatement ( statementCodeBlocks , usedOffset , start ) ;
const tokens = ast . tokens ;
const exportTokenIndex = tokens . findIndex ( ( t ) => t . range [ 0 ] === body . range [ 0 ] ) ;
const exportToken = tokens [ exportTokenIndex ] ;
if ( exportToken && exportToken . value === "export" ) {
append ( statementCodeBlocks , usedOffset , exportToken . range [ 0 ] ) ;
if ( body . declaration ) {
appendRangeAsStatement ( statementCodeBlocks , exportToken . range [ 1 ] , end ) ;
restoreASTCallbacks . addCallback ( scriptSetupStartOffset , [ start , end ] , ( statement ) => {
if ( statement . type !== body . declaration . type ) {
return null ;
}
fixNodeLocations ( body , result . visitorKeys , offsetLocationCalculator ) ;
fixLocation ( exportToken , offsetLocationCalculator ) ;
body . declaration = statement ;
statement . parent = body ;
return {
statement : body ,
tokens : [ exportToken ] ,
} ;
} ) ;
}
else {
statementCodeBlocks . appendSplitPunctuators ( "(" ) ;
const restoreTokens = [ exportToken ] ;
let startOffset = exportToken . range [ 1 ] ;
for ( const spec of body . specifiers ) {
if ( spec . local . range [ 0 ] < spec . exported . range [ 0 ] ) {
const localTokenIndex = tokens . findIndex ( ( t ) => t . range [ 0 ] === spec . local . range [ 0 ] , exportTokenIndex ) ;
checkToken ( tokens [ localTokenIndex ] , spec . local . name ) ;
const asToken = tokens [ localTokenIndex + 1 ] ;
checkToken ( asToken , "as" ) ;
restoreTokens . push ( asToken ) ;
const exportedToken = tokens [ localTokenIndex + 2 ] ;
checkToken ( exportedToken , spec . exported . type === "Identifier"
? spec . exported . name
: spec . exported . raw ) ;
restoreTokens . push ( exportedToken ) ;
append ( statementCodeBlocks , startOffset , asToken . range [ 0 ] ) ;
append ( statementCodeBlocks , asToken . range [ 1 ] , exportedToken . range [ 0 ] ) ;
startOffset = exportedToken . range [ 1 ] ;
}
}
append ( statementCodeBlocks , startOffset , end ) ;
statementCodeBlocks . appendSplitPunctuators ( ")" ) ;
statementCodeBlocks . appendSplitPunctuators ( ";" ) ;
restoreASTCallbacks . addCallback ( scriptSetupStartOffset , [ start , end ] , ( statement ) => {
if ( statement . type !== "ExpressionStatement" ||
statement . expression . type !== "ObjectExpression" ) {
return null ;
}
const locals = [ ] ;
for ( const prop of statement . expression . properties ) {
if ( prop . type !== "Property" ||
prop . value . type !== "Identifier" ) {
return null ;
}
locals . push ( prop . value ) ;
}
if ( body . specifiers . length !== locals . length ) {
return null ;
}
const map = new Map ( ) ;
for ( let index = 0 ; index < body . specifiers . length ; index ++ ) {
const spec = body . specifiers [ index ] ;
const local = locals [ index ] ;
map . set ( spec , local ) ;
}
fixNodeLocations ( body , result . visitorKeys , offsetLocationCalculator ) ;
for ( const token of restoreTokens ) {
fixLocation ( token , offsetLocationCalculator ) ;
}
for ( const [ spec , local ] of map ) {
spec . local = local ;
local . parent = spec ;
}
return {
statement : body ,
tokens : restoreTokens ,
} ;
} ) ;
}
}
else {
appendRangeAsStatement ( statementCodeBlocks , usedOffset , end ) ;
}
}
for ( const body of ast . body ) {
if ( body . type === "ImportDeclaration" ||
body . type === "ExportAllDeclaration" ||
( body . type === "ExportNamedDeclaration" && body . source != null ) ) {
const [ start , end ] = getNodeFullRange ( body ) ;
appendRangeAsStatement ( statementCodeBlocks , usedOffset , start ) ;
appendRangeAsStatement ( importCodeBlocks , start , end ) ;
}
else if ( body . type === "ExportDefaultDeclaration" ) {
const [ start , end ] = getNodeFullRange ( body ) ;
appendRangeAsStatement ( statementCodeBlocks , usedOffset , start ) ;
appendRangeAsStatement ( exportDefaultCodeBlocks , start , end ) ;
}
else if ( body . type === "ExportNamedDeclaration" ) {
transformExportNamed ( body ) ;
}
}
appendRangeAsStatement ( statementCodeBlocks , usedOffset , scriptSetupEndOffset ) ;
const codeBlocks = new CodeBlocks ( ) ;
let postprocess = ( ) => {
} ;
codeBlocks . appendCodeBlocks ( importCodeBlocks ) ;
const scriptSetupBlockRangeStart = codeBlocks . length ;
codeBlocks . appendSplitPunctuators ( "{" ) ;
const generic = extractGeneric ( node ) ;
if ( generic ) {
const defineGenericTypeRangeStart = codeBlocks . length ;
for ( const defineType of generic . defineTypes ) {
codeBlocks . append ( defineType . define , defineType . node . range [ 0 ] ) ;
codeBlocks . appendSplitPunctuators ( ";" ) ;
}
const defineGenericTypeRangeEnd = codeBlocks . length ;
postprocess = ( eslintResult , context ) => {
const diffOffset = context . scriptSetupBlockRange [ 0 ] - scriptSetupBlockRangeStart ;
const defineGenericTypeRange = [
defineGenericTypeRangeStart + diffOffset ,
defineGenericTypeRangeEnd + diffOffset ,
] ;
function isTypeBlock ( block ) {
return ( block . type === "BlockStatement" &&
context . scriptSetupBlockRange [ 0 ] <= block . range [ 0 ] &&
block . range [ 1 ] <= context . scriptSetupBlockRange [ 1 ] ) ;
}
generic . postprocess ( {
result : eslintResult ,
getTypeBlock : ( program ) => program . body . find ( isTypeBlock ) ,
isRemoveTarget ( nodeOrToken ) {
return ( defineGenericTypeRange [ 0 ] <= nodeOrToken . range [ 0 ] &&
nodeOrToken . range [ 1 ] <= defineGenericTypeRange [ 1 ] ) ;
} ,
getTypeDefScope ( scopeManager ) {
var _ a ;
const moduleScope = ( _ a = scopeManager . globalScope . childScopes . find ( ( s ) => s . type === "module" ) ) !== null && _ a !== void 0 ? _ a : scopeManager . globalScope ;
return moduleScope . childScopes . find ( ( scope ) => isTypeBlock ( scope . block ) ) ;
} ,
} ) ;
} ;
}
codeBlocks . appendCodeBlocks ( statementCodeBlocks ) ;
codeBlocks . appendSplitPunctuators ( "}" ) ;
const scriptSetupBlockRangeEnd = codeBlocks . length ;
codeBlocks . appendCodeBlocks ( exportDefaultCodeBlocks ) ;
return {
codeBlocks ,
scriptSetupBlockRange : [
scriptSetupBlockRangeStart ,
scriptSetupBlockRangeEnd ,
] ,
postprocess ,
restoreASTCallbacks ,
} ;
function getNodeFullRange ( n ) {
let start = n . range [ 0 ] ;
let end = n . range [ 1 ] ;
traverseNodes ( n , {
visitorKeys : result . visitorKeys ,
enterNode ( c ) {
start = Math . min ( start , c . range [ 0 ] ) ;
end = Math . max ( end , c . range [ 1 ] ) ;
} ,
leaveNode ( ) {
} ,
} ) ;
return [ start , end ] ;
}
function checkToken ( token , value ) {
if ( token . value === value ) {
return ;
}
const perr = new ParseError ( ` Could not parse <script setup>. Expected " ${ value } ", but it was " ${ token . value } ". ` , undefined , token . range [ 0 ] , token . loc . start . line , token . loc . start . column ) ;
fixErrorLocation ( perr , offsetLocationCalculator ) ;
throw perr ;
}
}
function remapAST ( result , { scriptSetupBlockRange , codeBlocks } ) {
if ( ! scriptSetupBlockRange ) {
return [ ] ;
}
let scriptSetupBlock = null ;
const scriptSetupStatements = [ ] ;
for ( let index = result . ast . body . length - 1 ; index >= 0 ; index -- ) {
const body = result . ast . body [ index ] ;
if ( body . type === "BlockStatement" ) {
if ( scriptSetupBlockRange [ 0 ] <= body . range [ 0 ] &&
body . range [ 1 ] <= scriptSetupBlockRange [ 1 ] ) {
if ( scriptSetupBlock ) {
throw new Error ( ` Unexpected state error: An unexpected block statement was found. ${ JSON . stringify ( body . loc ) } ` ) ;
}
scriptSetupBlock = body ;
scriptSetupStatements . push ( ... body . body . filter ( ( b ) => ! isSplitPunctuatorsEmptyStatement ( b ) ) ) ;
result . ast . body . splice ( index , 1 , ... scriptSetupStatements ) ;
}
}
else if ( body . type === "EmptyStatement" ) {
if ( isSplitPunctuatorsEmptyStatement ( body ) ) {
result . ast . body . splice ( index , 1 ) ;
}
}
}
if ( result . scopeManager && scriptSetupBlock ) {
const blockScope = result . scopeManager . acquire ( scriptSetupBlock , true ) ;
remapScope ( result . scopeManager , blockScope ) ;
}
return scriptSetupStatements ;
function isSplitPunctuatorsEmptyStatement ( body ) {
return ( body . type === "EmptyStatement" &&
codeBlocks . splitPunctuators . includes ( body . range [ 1 ] - 1 ) ) ;
}
function remapScope ( scopeManager , blockScope ) {
const moduleScope = blockScope . upper ;
for ( const reference of blockScope . references ) {
reference . from = moduleScope ;
moduleScope . references . push ( reference ) ;
}
for ( const variable of blockScope . variables ) {
variable . scope = moduleScope ;
const alreadyVariable = moduleScope . variables . find ( ( v ) => v . name === variable . name ) ;
if ( alreadyVariable ) {
alreadyVariable . defs . push ( ... variable . defs ) ;
alreadyVariable . identifiers . push ( ... variable . identifiers ) ;
alreadyVariable . references . push ( ... variable . references ) ;
for ( const reference of variable . references ) {
reference . resolved = alreadyVariable ;
}
}
else {
moduleScope . variables . push ( variable ) ;
moduleScope . set . set ( variable . name , variable ) ;
}
}
const upper = blockScope . upper ;
if ( upper ) {
const index = upper . childScopes . indexOf ( blockScope ) ;
if ( index >= 0 ) {
upper . childScopes . splice ( index , 1 ) ;
}
}
const index = scopeManager . scopes . indexOf ( blockScope ) ;
if ( index >= 0 ) {
scopeManager . scopes . splice ( index , 1 ) ;
}
}
}
function remapLocationAndTokens ( result , { codeBlocks } , locationCalculator ) {
const tokens = result . ast . tokens || [ ] ;
const endMap = new Map ( ) ;
const buffer = [ ] ;
for ( let index = tokens . length - 1 ; index >= 0 ; index -- ) {
const token = tokens [ index ] ;
if ( token . range [ 0 ] + 1 === token . range [ 1 ] &&
codeBlocks . splitPunctuators . includes ( token . range [ 0 ] ) ) {
tokens . splice ( index , 1 ) ;
buffer . push ( token . range [ 1 ] ) ;
continue ;
}
else {
for ( const end of buffer ) {
endMap . set ( end , token . range [ 1 ] ) ;
}
buffer . length = 0 ;
}
}
traverseNodes ( result . ast , {
visitorKeys : result . visitorKeys ,
enterNode ( node ) {
const rangeEnd = endMap . get ( node . range [ 1 ] ) ;
if ( rangeEnd != null ) {
node . range [ 1 ] = rangeEnd ;
}
if ( node . end ) {
const end = endMap . get ( node . end ) ;
if ( end != null ) {
node . end = rangeEnd ;
}
}
} ,
leaveNode ( ) {
} ,
} ) ;
fixLocations ( result , locationCalculator ) ;
}
class CSSTokenizer {
constructor ( text , startOffset , options ) {
var _ a ;
debug ( "[css] the source code length: %d" , text . length ) ;
this . text = text ;
this . options = {
inlineComment : ( _ a = options === null || options === void 0 ? void 0 : options . inlineComment ) !== null && _ a !== void 0 ? _ a : false ,
} ;
this . cp = NULL ;
this . offset = startOffset - 1 ;
this . nextOffset = startOffset ;
this . reconsuming = false ;
}
nextToken ( ) {
let cp ;
if ( this . reconsuming ) {
cp = this . cp ;
this . reconsuming = false ;
}
else {
cp = this . consumeNextCodePoint ( ) ;
}
while ( isWhitespace ( cp ) ) {
cp = this . consumeNextCodePoint ( ) ;
}
if ( cp === EOF ) {
return null ;
}
const start = this . offset ;
return this . consumeNextToken ( cp , start ) ;
}
nextCodePoint ( ) {
if ( this . nextOffset >= this . text . length ) {
return EOF ;
}
return this . text . codePointAt ( this . nextOffset ) ;
}
consumeNextCodePoint ( ) {
if ( this . offset >= this . text . length ) {
this . cp = EOF ;
return EOF ;
}
this . offset = this . nextOffset ;
if ( this . offset >= this . text . length ) {
this . cp = EOF ;
return EOF ;
}
let cp = this . text . codePointAt ( this . offset ) ;
if ( cp === CARRIAGE_RETURN ) {
this . nextOffset = this . offset + 1 ;
if ( this . text . codePointAt ( this . nextOffset ) === LINE_FEED ) {
this . nextOffset ++ ;
}
cp = LINE_FEED ;
}
else {
this . nextOffset = this . offset + ( cp >= 0x10000 ? 2 : 1 ) ;
}
this . cp = cp ;
return cp ;
}
consumeNextToken ( cp , start ) {
if ( cp === SOLIDUS ) {
const nextCp = this . nextCodePoint ( ) ;
if ( nextCp === ASTERISK ) {
return this . consumeComment ( start ) ;
}
if ( nextCp === SOLIDUS && this . options . inlineComment ) {
return this . consumeInlineComment ( start ) ;
}
}
if ( isQuote ( cp ) ) {
return this . consumeString ( start , cp ) ;
}
if ( isPunctuator ( cp ) ) {
return {
type : "Punctuator" ,
range : [ start , start + 1 ] ,
value : String . fromCodePoint ( cp ) ,
} ;
}
return this . consumeWord ( start ) ;
}
consumeWord ( start ) {
let cp = this . consumeNextCodePoint ( ) ;
while ( ! isWhitespace ( cp ) && ! isPunctuator ( cp ) && ! isQuote ( cp ) ) {
cp = this . consumeNextCodePoint ( ) ;
}
this . reconsuming = true ;
const range = [ start , this . offset ] ;
const text = this . text ;
let value ;
return {
type : "Word" ,
range ,
get value ( ) {
return ( value !== null && value !== void 0 ? value : ( value = text . slice ( ... range ) ) ) ;
} ,
} ;
}
consumeString ( start , quote ) {
let valueEndOffset = null ;
let cp = this . consumeNextCodePoint ( ) ;
while ( cp !== EOF ) {
if ( cp === quote ) {
valueEndOffset = this . offset ;
break ;
}
if ( cp === REVERSE_SOLIDUS ) {
this . consumeNextCodePoint ( ) ;
}
cp = this . consumeNextCodePoint ( ) ;
}
const text = this . text ;
let value ;
const valueRange = [
start + 1 ,
valueEndOffset !== null && valueEndOffset !== void 0 ? valueEndOffset : this . nextOffset ,
] ;
return {
type : "Quoted" ,
range : [ start , this . nextOffset ] ,
valueRange ,
get value ( ) {
return ( value !== null && value !== void 0 ? value : ( value = text . slice ( ... valueRange ) ) ) ;
} ,
quote : String . fromCodePoint ( quote ) ,
} ;
}
consumeComment ( start ) {
this . consumeNextCodePoint ( ) ;
let valueEndOffset = null ;
let cp = this . consumeNextCodePoint ( ) ;
while ( cp !== EOF ) {
if ( cp === ASTERISK ) {
cp = this . consumeNextCodePoint ( ) ;
if ( cp === SOLIDUS ) {
valueEndOffset = this . offset - 1 ;
break ;
}
}
cp = this . consumeNextCodePoint ( ) ;
}
const valueRange = [
start + 2 ,
valueEndOffset !== null && valueEndOffset !== void 0 ? valueEndOffset : this . nextOffset ,
] ;
const text = this . text ;
let value ;
return {
type : "Block" ,
range : [ start , this . nextOffset ] ,
valueRange ,
get value ( ) {
return ( value !== null && value !== void 0 ? value : ( value = text . slice ( ... valueRange ) ) ) ;
} ,
} ;
}
consumeInlineComment ( start ) {
this . consumeNextCodePoint ( ) ;
let valueEndOffset = null ;
let cp = this . consumeNextCodePoint ( ) ;
while ( cp !== EOF ) {
if ( cp === LINE_FEED ) {
valueEndOffset = this . offset - 1 ;
break ;
}
cp = this . consumeNextCodePoint ( ) ;
}
const valueRange = [
start + 2 ,
valueEndOffset !== null && valueEndOffset !== void 0 ? valueEndOffset : this . nextOffset ,
] ;
const text = this . text ;
let value ;
return {
type : "Line" ,
range : [ start , this . nextOffset ] ,
valueRange ,
get value ( ) {
return ( value !== null && value !== void 0 ? value : ( value = text . slice ( ... valueRange ) ) ) ;
} ,
} ;
}
}
function isPunctuator ( cp ) {
return ( cp === COLON ||
cp === SEMICOLON ||
cp === LEFT_PARENTHESIS ||
cp === RIGHT_PARENTHESIS ||
cp === LEFT_CURLY_BRACKET ||
cp === RIGHT_CURLY_BRACKET ||
cp === LEFT_SQUARE_BRACKET ||
cp === RIGHT_SQUARE_BRACKET ||
cp === SOLIDUS ||
cp === ASTERISK ) ;
}
function isQuote ( cp ) {
return cp === APOSTROPHE || cp === QUOTATION_MARK ;
}
class CSSTokenScanner {
constructor ( text , options ) {
this . reconsuming = [ ] ;
this . tokenizer = new CSSTokenizer ( text , 0 , options ) ;
}
nextToken ( ) {
return this . reconsuming . shift ( ) || this . tokenizer . nextToken ( ) ;
}
reconsume ( ... tokens ) {
this . reconsuming . push ( ... tokens ) ;
}
}
function parseStyleElements ( elements , globalLocationCalculator , originalParserOptions ) {
const parserOptions = Object . assign ( Object . assign ( { } , originalParserOptions ) , { ecmaVersion : originalParserOptions . ecmaVersion || DEFAULT_ECMA_VERSION } ) ;
for ( const style of elements ) {
style . style = true ;
parseStyleElement ( style , globalLocationCalculator , parserOptions , {
inlineComment : ( getLang ( style ) || "css" ) !== "css" ,
} ) ;
}
}
function parseStyleElement ( style , globalLocationCalculator , parserOptions , cssOptions ) {
if ( style . children . length !== 1 ) {
return ;
}
const textNode = style . children [ 0 ] ;
if ( textNode . type !== "VText" ) {
return ;
}
const code = textNode . value ;
if ( ! /v-bind\s*(?:\(|\/)/u . test ( code ) ) {
return ;
}
const locationCalculator = globalLocationCalculator . getSubCalculatorAfter ( textNode . range [ 0 ] ) ;
const document = getOwnerDocument ( style ) ;
parseStyle ( document , style , code , locationCalculator , parserOptions , cssOptions ) ;
}
function parseStyle ( document , style , code , locationCalculator , parserOptions , cssOptions ) {
let textStart = 0 ;
for ( const { range , exprRange , quote , openingParenOffset , comments , } of iterateVBind ( code , cssOptions ) ) {
insertComments ( document , comments . map ( ( c ) => createSimpleToken ( c . type , locationCalculator . getOffsetWithGap ( c . range [ 0 ] ) , locationCalculator . getOffsetWithGap ( c . range [ 1 ] ) , c . value , locationCalculator ) ) ) ;
const container = {
type : "VExpressionContainer" ,
range : [
locationCalculator . getOffsetWithGap ( range [ 0 ] ) ,
locationCalculator . getOffsetWithGap ( range [ 1 ] ) ,
] ,
loc : {
start : locationCalculator . getLocation ( range [ 0 ] ) ,
end : locationCalculator . getLocation ( range [ 1 ] ) ,
} ,
parent : style ,
expression : null ,
references : [ ] ,
} ;
const openingParenStart = locationCalculator . getOffsetWithGap ( openingParenOffset ) ;
const beforeTokens = [
createSimpleToken ( "HTMLRawText" , container . range [ 0 ] , container . range [ 0 ] + 6 , "v-bind" , locationCalculator ) ,
createSimpleToken ( "Punctuator" , openingParenStart , openingParenStart + 1 , "(" , locationCalculator ) ,
] ;
const afterTokens = [
createSimpleToken ( "Punctuator" , container . range [ 1 ] - 1 , container . range [ 1 ] , ")" , locationCalculator ) ,
] ;
if ( quote ) {
const openStart = locationCalculator . getOffsetWithGap ( exprRange [ 0 ] - 1 ) ;
beforeTokens . push ( createSimpleToken ( "Punctuator" , openStart , openStart + 1 , quote , locationCalculator ) ) ;
const closeStart = locationCalculator . getOffsetWithGap ( exprRange [ 1 ] ) ;
afterTokens . unshift ( createSimpleToken ( "Punctuator" , closeStart , closeStart + 1 , quote , locationCalculator ) ) ;
}
const beforeLast = beforeTokens [ beforeTokens . length - 1 ] ;
replaceAndSplitTokens ( document , {
range : [ container . range [ 0 ] , beforeLast . range [ 1 ] ] ,
loc : { start : container . loc . start , end : beforeLast . loc . end } ,
} , beforeTokens ) ;
const afterFirst = afterTokens [ 0 ] ;
replaceAndSplitTokens ( document , {
range : [ afterFirst . range [ 0 ] , container . range [ 1 ] ] ,
loc : { start : afterFirst . loc . start , end : container . loc . end } ,
} , afterTokens ) ;
const lastChild = style . children [ style . children . length - 1 ] ;
style . children . push ( container ) ;
if ( lastChild . type === "VText" ) {
const newTextNode = {
type : "VText" ,
range : [ container . range [ 1 ] , lastChild . range [ 1 ] ] ,
loc : {
start : Object . assign ( { } , container . loc . end ) ,
end : Object . assign ( { } , lastChild . loc . end ) ,
} ,
parent : style ,
value : code . slice ( range [ 1 ] ) ,
} ;
style . children . push ( newTextNode ) ;
lastChild . range [ 1 ] = container . range [ 0 ] ;
lastChild . loc . end = Object . assign ( { } , container . loc . start ) ;
lastChild . value = code . slice ( textStart , range [ 0 ] ) ;
textStart = range [ 1 ] ;
}
try {
const ret = parseExpression ( code . slice ( ... exprRange ) , locationCalculator . getSubCalculatorShift ( exprRange [ 0 ] ) , parserOptions , { allowEmpty : false , allowFilters : false } ) ;
if ( ret . expression ) {
ret . expression . parent = container ;
container . expression = ret . expression ;
container . references = ret . references ;
}
replaceAndSplitTokens ( document , {
range : [ beforeLast . range [ 1 ] , afterFirst . range [ 0 ] ] ,
loc : {
start : beforeLast . loc . end ,
end : afterFirst . loc . start ,
} ,
} , ret . tokens ) ;
insertComments ( document , ret . comments ) ;
for ( const variable of ret . variables ) {
style . variables . push ( variable ) ;
}
resolveReferences ( container ) ;
}
catch ( err ) {
debug ( "[style] Parse error: %s" , err ) ;
if ( ParseError . isParseError ( err ) ) {
insertError ( document , err ) ;
}
else {
throw err ;
}
}
}
}
function * iterateVBind ( code , cssOptions ) {
const tokenizer = new CSSTokenScanner ( code , cssOptions ) ;
let token ;
while ( ( token = tokenizer . nextToken ( ) ) ) {
if ( token . type !== "Word" || token . value !== "v-bind" ) {
continue ;
}
const openingParen = findVBindOpeningParen ( tokenizer ) ;
if ( ! openingParen ) {
continue ;
}
const arg = parseVBindArg ( tokenizer ) ;
if ( ! arg ) {
continue ;
}
yield {
range : [ token . range [ 0 ] , arg . closingParen . range [ 1 ] ] ,
exprRange : arg . exprRange ,
quote : arg . quote ,
openingParenOffset : openingParen . openingParen . range [ 0 ] ,
comments : [ ... openingParen . comments , ... arg . comments ] ,
} ;
}
}
function findVBindOpeningParen ( tokenizer ) {
const comments = [ ] ;
let token ;
while ( ( token = tokenizer . nextToken ( ) ) ) {
if ( token . type === "Punctuator" && token . value === "(" ) {
return {
openingParen : token ,
comments ,
} ;
}
else if ( isComment ( token ) ) {
comments . push ( token ) ;
continue ;
}
tokenizer . reconsume ( ... comments , token ) ;
return null ;
}
return null ;
}
function parseVBindArg ( tokenizer ) {
const tokensBuffer = [ ] ;
const comments = [ ] ;
const tokens = [ ] ;
const closeTokenStack = [ ] ;
let token ;
while ( ( token = tokenizer . nextToken ( ) ) ) {
if ( token . type === "Punctuator" ) {
if ( token . value === ")" && ! closeTokenStack . length ) {
if ( tokens . length === 1 &&
tokens [ 0 ] . type === "Quoted" ) {
const quotedToken = tokens [ 0 ] ;
return {
exprRange : quotedToken . valueRange ,
quote : quotedToken . quote ,
closingParen : token ,
comments ,
} ;
}
const startToken = tokensBuffer [ 0 ] || token ;
return {
exprRange : [ startToken . range [ 0 ] , token . range [ 0 ] ] ,
quote : null ,
closingParen : token ,
comments : [ ] ,
} ;
}
if ( token . value === closeTokenStack [ 0 ] ) {
closeTokenStack . shift ( ) ;
}
else if ( token . value === "(" ) {
closeTokenStack . unshift ( ")" ) ;
}
}
tokensBuffer . push ( token ) ;
if ( isComment ( token ) ) {
comments . push ( token ) ;
}
else {
tokens . push ( token ) ;
}
}
tokenizer . reconsume ( ... tokensBuffer ) ;
return null ;
}
function isComment ( token ) {
return token . type === "Block" || token . type === "Line" ;
}
const BUILTIN_COMPONENTS = new Set ( [
"template" ,
"slot" ,
"component" ,
"Component" ,
"transition" ,
"Transition" ,
"transition-group" ,
"TransitionGroup" ,
"keep-alive" ,
"KeepAlive" ,
"teleport" ,
"Teleport" ,
"suspense" ,
"Suspense" ,
] ) ;
const BUILTIN_DIRECTIVES = new Set ( [
"bind" ,
"on" ,
"text" ,
"html" ,
"show" ,
"if" ,
"else" ,
"else-if" ,
"for" ,
"model" ,
"slot" ,
"pre" ,
"cloak" ,
"once" ,
"memo" ,
"is" ,
] ) ;
const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer," +
"header,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," +
"feDistanceLight,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 NATIVE_TAGS = new Set ( [ ... HTML_TAGS . split ( "," ) , ... SVG_TAGS . split ( "," ) ] ) ;
const COMPILER_MACROS_AT_ROOT = new Set ( [
"defineProps" ,
"defineEmits" ,
"defineExpose" ,
"withDefaults" ,
"defineOptions" ,
"defineSlots" ,
] ) ;
function camelize ( str ) {
return str . replace ( /-(\w)/gu , ( _ , c ) => ( c ? c . toUpperCase ( ) : "" ) ) ;
}
function capitalize ( str ) {
return str [ 0 ] . toUpperCase ( ) + str . slice ( 1 ) ;
}
function analyzeScriptSetupScope ( scopeManager , templateBody , df , parserOptions ) {
analyzeUsedInTemplateVariables ( scopeManager , templateBody , df ) ;
analyzeScriptSetupVariables ( scopeManager , df , parserOptions ) ;
}
function extractVariables ( scopeManager ) {
const scriptVariables = new Map ( ) ;
const globalScope = scopeManager . globalScope ;
if ( ! globalScope ) {
return scriptVariables ;
}
for ( const variable of globalScope . variables ) {
scriptVariables . set ( variable . name , variable ) ;
}
const moduleScope = globalScope . childScopes . find ( ( scope ) => scope . type === "module" ) ;
for ( const variable of ( moduleScope && moduleScope . variables ) || [ ] ) {
scriptVariables . set ( variable . name , variable ) ;
}
return scriptVariables ;
}
function analyzeUsedInTemplateVariables ( scopeManager , templateBody , df ) {
const scriptVariables = extractVariables ( scopeManager ) ;
const markedVariables = new Set ( ) ;
function markSetupReferenceVariableAsUsed ( name ) {
if ( scriptVariables . has ( name ) ) {
markVariableAsUsed ( name ) ;
return true ;
}
const camelName = camelize ( name ) ;
if ( scriptVariables . has ( camelName ) ) {
markVariableAsUsed ( camelName ) ;
return true ;
}
const pascalName = capitalize ( camelName ) ;
if ( scriptVariables . has ( pascalName ) ) {
markVariableAsUsed ( pascalName ) ;
return true ;
}
return false ;
}
function markVariableAsUsed ( nameOrRef ) {
let name ;
let isValueReference ;
let isTypeReference ;
if ( typeof nameOrRef === "string" ) {
name = nameOrRef ;
}
else {
name = nameOrRef . id . name ;
isValueReference = nameOrRef . isValueReference ;
isTypeReference = nameOrRef . isTypeReference ;
}
const variable = scriptVariables . get ( name ) ;
if ( ! variable || variable . identifiers . length === 0 ) {
return ;
}
if ( markedVariables . has ( name ) ) {
return ;
}
markedVariables . add ( name ) ;
const reference = new ( getEslintScope ( ) . Reference ) ( ) ;
reference . vueUsedInTemplate = true ;
reference . from = variable . scope ;
reference . identifier = variable . identifiers [ 0 ] ;
reference . isWrite = ( ) => false ;
reference . isWriteOnly = ( ) => false ;
reference . isRead = ( ) => true ;
reference . isReadOnly = ( ) => true ;
reference . isReadWrite = ( ) => false ;
reference . isValueReference = isValueReference ;
reference . isTypeReference = isTypeReference ;
variable . references . push ( reference ) ;
reference . resolved = variable ;
if ( reference . isTypeReference ) {
variable . eslintUsed = true ;
}
}
function processVExpressionContainer ( node ) {
for ( const reference of node . references . filter ( ( ref ) => ref . variable == null ) ) {
markVariableAsUsed ( reference ) ;
}
}
function processVElement ( node ) {
if ( ( node . rawName === node . name && NATIVE_TAGS . has ( node . rawName ) ) ||
BUILTIN_COMPONENTS . has ( node . rawName ) ) {
return ;
}
if ( ! markSetupReferenceVariableAsUsed ( node . rawName ) ) {
const dotIndex = node . rawName . indexOf ( "." ) ;
if ( dotIndex > 0 ) {
markSetupReferenceVariableAsUsed ( node . rawName . slice ( 0 , dotIndex ) ) ;
}
}
}
function processVAttribute ( node ) {
if ( node . directive ) {
if ( BUILTIN_DIRECTIVES . has ( node . key . name . name ) ) {
return ;
}
markSetupReferenceVariableAsUsed ( ` v- ${ node . key . name . rawName } ` ) ;
}
else if ( node . key . name === "ref" && node . value ) {
markVariableAsUsed ( node . value . value ) ;
}
}
if ( templateBody ) {
traverseNodes ( templateBody , {
enterNode ( node ) {
if ( node . type === "VExpressionContainer" ) {
processVExpressionContainer ( node ) ;
}
else if ( node . type === "VElement" ) {
processVElement ( node ) ;
}
else if ( node . type === "VAttribute" ) {
processVAttribute ( node ) ;
}
} ,
leaveNode ( ) {
} ,
} ) ;
}
for ( const child of df . children ) {
if ( child . type === "VElement" ) {
if ( isScriptSetupElement ( child ) ) {
const generic = findGenericDirective ( child ) ;
if ( generic ) {
processVExpressionContainer ( generic . value ) ;
}
}
else if ( child . name === "style" ) {
for ( const node of child . children ) {
if ( node . type === "VExpressionContainer" ) {
processVExpressionContainer ( node ) ;
}
}
}
}
}
}
function analyzeScriptSetupVariables ( scopeManager , df , parserOptions ) {
var _ a ;
const globalScope = scopeManager . globalScope ;
if ( ! globalScope ) {
return ;
}
const customMacros = new Set ( ( ( _ a = parserOptions . vueFeatures ) === null || _ a === void 0 ? void 0 : _ a . customMacros ) &&
Array . isArray ( parserOptions . vueFeatures . customMacros )
? parserOptions . vueFeatures . customMacros
: [ ] ) ;
const genericDefineNames = new Set ( ) ;
const scriptElements = df . children . filter ( isScriptElement ) ;
const scriptSetupElement = scriptElements . find ( isScriptSetupElement ) ;
if ( scriptSetupElement && findGenericDirective ( scriptSetupElement ) ) {
for ( const variable of scriptSetupElement . variables ) {
if ( variable . kind === "generic" ) {
genericDefineNames . add ( variable . id . name ) ;
}
}
}
const newThrough = [ ] ;
for ( const reference of globalScope . through ) {
if ( COMPILER_MACROS_AT_ROOT . has ( reference . identifier . name ) ||
customMacros . has ( reference . identifier . name ) ) {
if ( reference . from . type === "global" ||
reference . from . type === "module" ) {
addCompilerMacroVariable ( reference ) ;
continue ;
}
}
if ( genericDefineNames . has ( reference . identifier . name ) ) {
addGenericVariable ( reference ) ;
continue ;
}
newThrough . push ( reference ) ;
}
globalScope . through = newThrough ;
function addCompilerMacroVariable ( reference ) {
addVariable ( globalScope , reference ) ;
}
function addGenericVariable ( reference ) {
addVariable ( globalScope , reference ) ;
}
}
function addVariable ( scope , reference ) {
const name = reference . identifier . name ;
let variable = scope . set . get ( name ) ;
if ( ! variable ) {
variable = new ( getEslintScope ( ) . Variable ) ( ) ;
variable . name = name ;
variable . scope = scope ;
scope . variables . push ( variable ) ;
scope . set . set ( name , variable ) ;
}
reference . resolved = variable ;
variable . references . push ( reference ) ;
}
const STARTS_WITH_LT = /^\s*</u ;
function isVueFile ( code , options ) {
const filePath = options . filePath || "unknown.js" ;
return path__namespace . extname ( filePath ) === ".vue" || STARTS_WITH_LT . test ( code ) ;
}
function parseForESLint ( code , parserOptions ) {
const options = Object . assign ( {
comment : true ,
loc : true ,
range : true ,
tokens : true ,
} , parserOptions || { } ) ;
let result ;
let document ;
let locationCalculator ;
if ( ! isVueFile ( code , options ) ) {
result = parseAsScript ( code , options ) ;
document = null ;
locationCalculator = null ;
}
else {
( { result , document , locationCalculator } = parseAsSFC ( code , options ) ) ;
}
result . services = Object . assign ( result . services || { } , define ( code , result . ast , document , locationCalculator , {
parserOptions : options ,
} ) ) ;
return result ;
}
function parse ( code , options ) {
return parseForESLint ( code , options ) . ast ;
}
function parseAsSFC ( code , options ) {
var _ a , _ b , _ c ;
const optionsForTemplate = Object . assign ( Object . assign ( { } , options ) , { ecmaVersion : options . ecmaVersion || DEFAULT_ECMA_VERSION } ) ;
const skipParsingScript = options . parser === false ;
const tokenizer = new Tokenizer ( code , optionsForTemplate ) ;
const rootAST = new Parser ( tokenizer , optionsForTemplate ) . parse ( ) ;
const locationCalculator = new LocationCalculatorForHtml ( tokenizer . gaps , tokenizer . lineTerminators ) ;
const scripts = rootAST . children . filter ( isScriptElement ) ;
const template = rootAST . children . find ( isTemplateElement ) ;
const templateLang = getLang ( template ) || "html" ;
const hasTemplateTokenizer = ( _ a = options === null || options === void 0 ? void 0 : options . templateTokenizer ) === null || _ a === void 0 ? void 0 : _ a [ templateLang ] ;
const concreteInfo = {
tokens : rootAST . tokens ,
comments : rootAST . comments ,
errors : rootAST . errors ,
} ;
const templateBody = template != null && ( templateLang === "html" || hasTemplateTokenizer )
? Object . assign ( template , concreteInfo )
: undefined ;
const scriptParser = getScriptParser ( options . parser , ( ) => getParserLangFromSFC ( rootAST ) ) ;
let result ;
let scriptSetup ;
if ( skipParsingScript || ! scripts . length ) {
result = parseScript$1 ( "" , Object . assign ( Object . assign ( { } , options ) , { ecmaVersion : options . ecmaVersion || DEFAULT_ECMA_VERSION , parser : scriptParser } ) ) ;
}
else if ( scripts . length === 2 &&
( scriptSetup = scripts . find ( isScriptSetupElement ) ) ) {
result = parseScriptSetupElements ( scriptSetup , scripts . find ( ( e ) => e !== scriptSetup ) , code , new LinesAndColumns ( tokenizer . lineTerminators ) , Object . assign ( Object . assign ( { } , options ) , { parser : scriptParser } ) ) ;
}
else {
result = parseScriptElement ( scripts [ 0 ] , code , new LinesAndColumns ( tokenizer . lineTerminators ) , Object . assign ( Object . assign ( { } , options ) , { parser : scriptParser } ) ) ;
}
if ( ( _ c = ( _ b = options . vueFeatures ) === null || _ b === void 0 ? void 0 : _ b . styleCSSVariableInjection ) !== null && _ c !== void 0 ? _ c : true ) {
const styles = rootAST . children . filter ( isStyleElement ) ;
parseStyleElements ( styles , locationCalculator , Object . assign ( Object . assign ( { } , options ) , { parser : getScriptParser ( options . parser , function * ( ) {
yield "<template>" ;
yield getParserLangFromSFC ( rootAST ) ;
} ) } ) ) ;
}
result . ast . templateBody = templateBody ;
if ( options . eslintScopeManager ) {
if ( scripts . some ( isScriptSetupElement ) ) {
if ( ! result . scopeManager ) {
result . scopeManager = analyzeScope ( result . ast , options ) ;
}
analyzeScriptSetupScope ( result . scopeManager , templateBody , rootAST , options ) ;
}
}
return {
result ,
locationCalculator ,
document : rootAST ,
} ;
}
function parseAsScript ( code , options ) {
return parseScript$1 ( code , Object . assign ( Object . assign ( { } , options ) , { ecmaVersion : options . ecmaVersion || DEFAULT_ECMA_VERSION , parser : getScriptParser ( options . parser , ( ) => {
const ext = ( path__namespace . extname ( options . filePath || "unknown.js" ) . toLowerCase ( ) ||
"" )
. slice ( 1 ) ;
if ( /^[jt]sx$/u . test ( ext ) ) {
return [ ext , ext . slice ( 0 , - 1 ) ] ;
}
return ext ;
} ) } ) ) ;
}
const meta = {
name : "vue-eslint-parser" ,
version : "9.3.2" ,
} ;
exports . AST = index ;
exports . meta = meta ;
exports . parse = parse ;
exports . parseForESLint = parseForESLint ;
//# sourceMappingURL=index.js.map
