Index: frontend/node_modules/@babel/eslint-parser/LICENSE =================================================================== --- frontend/node_modules/@babel/eslint-parser/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2014-present Sebastian McKenzie and other contributors + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Index: frontend/node_modules/@babel/eslint-parser/README.md =================================================================== --- frontend/node_modules/@babel/eslint-parser/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,19 @@ +# @babel/eslint-parser + +> allows you to lint all valid Babel code with the fantastic ESLint + +See our website [@babel/eslint-parser](https://babeljs.io/docs/babel-eslint-parser) for more information or the [issues](https://github.com/babel/babel/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22area%3A%20eslint%22) associated with this package. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/eslint-parser +``` + +or using yarn: + +```sh +yarn add @babel/eslint-parser --dev +``` Index: frontend/node_modules/@babel/eslint-parser/lib/analyze-scope.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/analyze-scope.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/analyze-scope.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,325 @@ +"use strict"; + +function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); } +function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); } +function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); } +function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; } +function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); } +const { + Definition, + PatternVisitor: OriginalPatternVisitor, + Referencer: OriginalReferencer, + Scope, + ScopeManager +} = require("@nicolo-ribaudo/eslint-scope-5-internals"); +const { + getKeys: fallback +} = require("eslint-visitor-keys"); +let visitorKeysMap; +function getVisitorValues(nodeType, client) { + if (visitorKeysMap) return visitorKeysMap[nodeType]; + const { + FLOW_FLIPPED_ALIAS_KEYS, + VISITOR_KEYS + } = client.getTypesInfo(); + const flowFlippedAliasKeys = new Set(FLOW_FLIPPED_ALIAS_KEYS.concat(["ArrayPattern", "ClassDeclaration", "ClassExpression", "FunctionDeclaration", "FunctionExpression", "Identifier", "ObjectPattern", "RestElement"])); + visitorKeysMap = (Object.entries || (o => Object.keys(o).map(k => [k, o[k]])))(VISITOR_KEYS).reduce((acc, [key, value]) => { + if (!flowFlippedAliasKeys.has(value)) { + acc[key] = value; + } + return acc; + }, {}); + return visitorKeysMap[nodeType]; +} +const propertyTypes = { + callProperties: { + type: "loop", + values: ["value"] + }, + indexers: { + type: "loop", + values: ["key", "value"] + }, + properties: { + type: "loop", + values: ["argument", "value"] + }, + types: { + type: "loop" + }, + params: { + type: "loop" + }, + argument: { + type: "single" + }, + elementType: { + type: "single" + }, + qualification: { + type: "single" + }, + rest: { + type: "single" + }, + returnType: { + type: "single" + }, + typeAnnotation: { + type: "typeAnnotation" + }, + typeParameters: { + type: "typeParameters" + }, + id: { + type: "id" + } +}; +class PatternVisitor extends OriginalPatternVisitor { + ArrayPattern(node) { + node.elements.forEach(this.visit, this); + } + ObjectPattern(node) { + node.properties.forEach(this.visit, this); + } +} +var _client = new WeakMap(); +class Referencer extends OriginalReferencer { + constructor(options, scopeManager, client) { + super(options, scopeManager); + _classPrivateFieldInitSpec(this, _client, void 0); + _classPrivateFieldSet(_client, this, client); + } + visitPattern(node, options, callback) { + if (!node) { + return; + } + this._checkIdentifierOrVisit(node.typeAnnotation); + if (node.type === "AssignmentPattern") { + this._checkIdentifierOrVisit(node.left.typeAnnotation); + } + if (typeof options === "function") { + callback = options; + options = { + processRightHandNodes: false + }; + } + const visitor = new PatternVisitor(this.options, node, callback); + visitor.visit(node); + if (options.processRightHandNodes) { + visitor.rightHandNodes.forEach(this.visit, this); + } + } + visitClass(node) { + var _ref; + this._visitArray(node.decorators); + const typeParamScope = this._nestTypeParamScope(node); + this._visitTypeAnnotation(node.implements); + this._visitTypeAnnotation((_ref = node.superTypeParameters) == null ? void 0 : _ref.params); + super.visitClass(node); + if (typeParamScope) { + this.close(node); + } + } + visitFunction(node) { + const typeParamScope = this._nestTypeParamScope(node); + this._checkIdentifierOrVisit(node.returnType); + super.visitFunction(node); + if (typeParamScope) { + this.close(node); + } + } + visitProperty(node) { + var _node$value; + if (((_node$value = node.value) == null ? void 0 : _node$value.type) === "TypeCastExpression") { + this._visitTypeAnnotation(node.value); + } + this._visitArray(node.decorators); + super.visitProperty(node); + } + InterfaceDeclaration(node) { + this._createScopeVariable(node, node.id); + const typeParamScope = this._nestTypeParamScope(node); + this._visitArray(node.extends); + this.visit(node.body); + if (typeParamScope) { + this.close(node); + } + } + TypeAlias(node) { + this._createScopeVariable(node, node.id); + const typeParamScope = this._nestTypeParamScope(node); + this.visit(node.right); + if (typeParamScope) { + this.close(node); + } + } + ClassProperty(node) { + this._visitClassProperty(node); + } + ClassPrivateProperty(node) { + this._visitClassProperty(node); + } + AccessorProperty(node) { + this._visitClassProperty(node); + } + ClassAccessorProperty(node) { + this._visitClassProperty(node); + } + PropertyDefinition(node) { + this._visitClassProperty(node); + } + ClassPrivateMethod(node) { + super.MethodDefinition(node); + } + DeclareModule(node) { + this._visitDeclareX(node); + } + DeclareFunction(node) { + this._visitDeclareX(node); + } + DeclareVariable(node) { + this._visitDeclareX(node); + } + DeclareClass(node) { + this._visitDeclareX(node); + } + OptionalMemberExpression(node) { + super.MemberExpression(node); + } + _visitClassProperty(node) { + const { + computed, + key, + typeAnnotation, + decorators, + value + } = node; + this._visitArray(decorators); + if (computed) this.visit(key); + this._visitTypeAnnotation(typeAnnotation); + if (value) { + if (this.scopeManager.__nestClassFieldInitializerScope) { + this.scopeManager.__nestClassFieldInitializerScope(value); + } else { + this.scopeManager.__nestScope(new Scope(this.scopeManager, "function", this.scopeManager.__currentScope, value, true)); + } + this.visit(value); + this.close(value); + } + } + _visitDeclareX(node) { + if (node.id) { + this._createScopeVariable(node, node.id); + } + const typeParamScope = this._nestTypeParamScope(node); + if (typeParamScope) { + this.close(node); + } + } + _createScopeVariable(node, name) { + this.currentScope().variableScope.__define(name, new Definition("Variable", name, node, null, null, null)); + } + _nestTypeParamScope(node) { + if (!node.typeParameters) { + return null; + } + const parentScope = this.scopeManager.__currentScope; + const scope = new Scope(this.scopeManager, "type-parameters", parentScope, node, false); + this.scopeManager.__nestScope(scope); + for (let j = 0; j < node.typeParameters.params.length; j++) { + const name = node.typeParameters.params[j]; + scope.__define(name, new Definition("TypeParameter", name, name)); + if (name.typeAnnotation) { + this._checkIdentifierOrVisit(name); + } + } + scope.__define = parentScope.__define.bind(parentScope); + return scope; + } + _visitTypeAnnotation(node) { + if (!node) { + return; + } + if (Array.isArray(node)) { + node.forEach(this._visitTypeAnnotation, this); + return; + } + const visitorValues = getVisitorValues(node.type, _classPrivateFieldGet(_client, this)); + if (!visitorValues) { + return; + } + for (let i = 0; i < visitorValues.length; i++) { + const visitorValue = visitorValues[i]; + const propertyType = propertyTypes[visitorValue]; + const nodeProperty = node[visitorValue]; + if (propertyType == null || nodeProperty == null) { + continue; + } + if (propertyType.type === "loop") { + for (let j = 0; j < nodeProperty.length; j++) { + if (Array.isArray(propertyType.values)) { + for (let k = 0; k < propertyType.values.length; k++) { + const loopPropertyNode = nodeProperty[j][propertyType.values[k]]; + if (loopPropertyNode) { + this._checkIdentifierOrVisit(loopPropertyNode); + } + } + } else { + this._checkIdentifierOrVisit(nodeProperty[j]); + } + } + } else if (propertyType.type === "single") { + this._checkIdentifierOrVisit(nodeProperty); + } else if (propertyType.type === "typeAnnotation") { + this._visitTypeAnnotation(node.typeAnnotation); + } else if (propertyType.type === "typeParameters") { + for (let l = 0; l < node.typeParameters.params.length; l++) { + this._checkIdentifierOrVisit(node.typeParameters.params[l]); + } + } else if (propertyType.type === "id") { + if (node.id.type === "Identifier") { + this._checkIdentifierOrVisit(node.id); + } else { + this._visitTypeAnnotation(node.id); + } + } + } + } + _checkIdentifierOrVisit(node) { + if (node != null && node.typeAnnotation) { + this._visitTypeAnnotation(node.typeAnnotation); + } else if ((node == null ? void 0 : node.type) === "Identifier") { + this.visit(node); + } else { + this._visitTypeAnnotation(node); + } + } + _visitArray(nodeList) { + if (nodeList) { + for (const node of nodeList) { + this.visit(node); + } + } + } +} +module.exports = function analyzeScope(ast, parserOptions, client) { + var _parserOptions$ecmaFe; + const options = { + ignoreEval: true, + optimistic: false, + directive: false, + nodejsScope: ast.sourceType === "script" && ((_parserOptions$ecmaFe = parserOptions.ecmaFeatures) == null ? void 0 : _parserOptions$ecmaFe.globalReturn) === true, + impliedStrict: false, + sourceType: ast.sourceType, + ecmaVersion: parserOptions.ecmaVersion, + fallback, + childVisitorKeys: client.getVisitorKeys() + }; + const scopeManager = new ScopeManager(options); + const referencer = new Referencer(options, scopeManager, client); + referencer.visit(ast); + return scopeManager; +}; + +//# sourceMappingURL=analyze-scope.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/analyze-scope.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/analyze-scope.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/analyze-scope.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["Definition","PatternVisitor","OriginalPatternVisitor","Referencer","OriginalReferencer","Scope","ScopeManager","require","getKeys","fallback","visitorKeysMap","getVisitorValues","nodeType","client","FLOW_FLIPPED_ALIAS_KEYS","VISITOR_KEYS","getTypesInfo","flowFlippedAliasKeys","Set","concat","Object","entries","o","keys","map","k","reduce","acc","key","value","has","propertyTypes","callProperties","type","values","indexers","properties","types","params","argument","elementType","qualification","rest","returnType","typeAnnotation","typeParameters","id","ArrayPattern","node","elements","forEach","visit","ObjectPattern","_client","WeakMap","constructor","options","scopeManager","_classPrivateFieldInitSpec","_classPrivateFieldSet","visitPattern","callback","_checkIdentifierOrVisit","left","processRightHandNodes","visitor","rightHandNodes","visitClass","_ref","_visitArray","decorators","typeParamScope","_nestTypeParamScope","_visitTypeAnnotation","implements","superTypeParameters","close","visitFunction","visitProperty","_node$value","InterfaceDeclaration","_createScopeVariable","extends","body","TypeAlias","right","ClassProperty","_visitClassProperty","ClassPrivateProperty","AccessorProperty","ClassAccessorProperty","PropertyDefinition","ClassPrivateMethod","MethodDefinition","DeclareModule","_visitDeclareX","DeclareFunction","DeclareVariable","DeclareClass","OptionalMemberExpression","MemberExpression","computed","__nestClassFieldInitializerScope","__nestScope","__currentScope","name","currentScope","variableScope","__define","parentScope","scope","j","length","bind","Array","isArray","visitorValues","_classPrivateFieldGet","i","visitorValue","propertyType","nodeProperty","loopPropertyNode","l","nodeList","module","exports","analyzeScope","ast","parserOptions","_parserOptions$ecmaFe","ignoreEval","optimistic","directive","nodejsScope","sourceType","ecmaFeatures","globalReturn","impliedStrict","ecmaVersion","childVisitorKeys","getVisitorKeys","referencer"],"sources":["../src/analyze-scope.cts"],"sourcesContent":["import type { Client } from \"./client.cts\";\n\nconst {\n Definition,\n PatternVisitor: OriginalPatternVisitor,\n Referencer: OriginalReferencer,\n Scope,\n ScopeManager,\n} = (\n process.env.BABEL_8_BREAKING\n ? require(\"eslint-scope\")\n : require(\"@nicolo-ribaudo/eslint-scope-5-internals\")\n) as import(\"./types.cts\").Scope;\nconst { getKeys: fallback } = require(\"eslint-visitor-keys\");\n\nlet visitorKeysMap: Record;\nfunction getVisitorValues(nodeType: string, client: Client) {\n if (visitorKeysMap) return visitorKeysMap[nodeType];\n\n const { FLOW_FLIPPED_ALIAS_KEYS, VISITOR_KEYS } = client.getTypesInfo();\n\n const flowFlippedAliasKeys = new Set(\n FLOW_FLIPPED_ALIAS_KEYS.concat([\n \"ArrayPattern\",\n \"ClassDeclaration\",\n \"ClassExpression\",\n \"FunctionDeclaration\",\n \"FunctionExpression\",\n \"Identifier\",\n \"ObjectPattern\",\n \"RestElement\",\n ]),\n );\n\n visitorKeysMap = Object.entries(VISITOR_KEYS).reduce((acc, [key, value]) => {\n if (!flowFlippedAliasKeys.has(value)) {\n // @ts-expect-error FIXME: value is not assignable to type string[]\n acc[key] = value;\n }\n return acc;\n }, {});\n\n return visitorKeysMap[nodeType];\n}\n\nconst propertyTypes = {\n // loops\n callProperties: { type: \"loop\", values: [\"value\"] },\n indexers: { type: \"loop\", values: [\"key\", \"value\"] },\n properties: { type: \"loop\", values: [\"argument\", \"value\"] },\n types: { type: \"loop\" },\n params: { type: \"loop\" },\n // single property\n argument: { type: \"single\" },\n elementType: { type: \"single\" },\n qualification: { type: \"single\" },\n rest: { type: \"single\" },\n returnType: { type: \"single\" },\n // others\n typeAnnotation: { type: \"typeAnnotation\" },\n typeParameters: { type: \"typeParameters\" },\n id: { type: \"id\" },\n};\n\nclass PatternVisitor extends OriginalPatternVisitor {\n ArrayPattern(node: any) {\n node.elements.forEach(this.visit, this);\n }\n\n ObjectPattern(node: any) {\n node.properties.forEach(this.visit, this);\n }\n}\n\nclass Referencer extends OriginalReferencer {\n #client;\n\n constructor(options: any, scopeManager: any, client: Client) {\n super(options, scopeManager);\n this.#client = client;\n }\n\n // inherits.\n visitPattern(node: any, options: any, callback: any) {\n if (!node) {\n return;\n }\n\n // Visit type annotations.\n this._checkIdentifierOrVisit(node.typeAnnotation);\n if (node.type === \"AssignmentPattern\") {\n this._checkIdentifierOrVisit(node.left.typeAnnotation);\n }\n\n // Overwrite `super.visitPattern(node, options, callback)` in order to not visit `ArrayPattern#typeAnnotation` and `ObjectPattern#typeAnnotation`.\n if (typeof options === \"function\") {\n callback = options;\n options = { processRightHandNodes: false };\n }\n\n const visitor = new PatternVisitor(this.options, node, callback);\n visitor.visit(node);\n\n // Process the right hand nodes recursively.\n if (options.processRightHandNodes) {\n visitor.rightHandNodes.forEach(this.visit, this);\n }\n }\n\n // inherits.\n visitClass(node: any) {\n // Decorators.\n this._visitArray(node.decorators);\n\n // Flow type parameters.\n const typeParamScope = this._nestTypeParamScope(node);\n\n // Flow super types.\n this._visitTypeAnnotation(node.implements);\n this._visitTypeAnnotation(\n (process.env.BABEL_8_BREAKING\n ? // @ts-ignore(Babel 7 vs Babel 8) Renamed\n node.superTypeArguments\n : // @ts-ignore(Babel 7 vs Babel 8) Renamed\n node.superTypeParameters\n )?.params,\n );\n\n // Basic.\n super.visitClass(node);\n\n // Close the type parameter scope.\n if (typeParamScope) {\n this.close(node);\n }\n }\n\n // inherits.\n visitFunction(node: any) {\n const typeParamScope = this._nestTypeParamScope(node);\n\n // Flow return types.\n this._checkIdentifierOrVisit(node.returnType);\n\n // Basic.\n super.visitFunction(node);\n\n // Close the type parameter scope.\n if (typeParamScope) {\n this.close(node);\n }\n }\n\n // inherits.\n visitProperty(node: any) {\n if (node.value?.type === \"TypeCastExpression\") {\n this._visitTypeAnnotation(node.value);\n }\n this._visitArray(node.decorators);\n super.visitProperty(node);\n }\n\n InterfaceDeclaration(node: any) {\n this._createScopeVariable(node, node.id);\n\n const typeParamScope = this._nestTypeParamScope(node);\n\n // TODO: Handle mixins\n this._visitArray(node.extends);\n this.visit(node.body);\n\n if (typeParamScope) {\n this.close(node);\n }\n }\n\n TypeAlias(node: any) {\n this._createScopeVariable(node, node.id);\n\n const typeParamScope = this._nestTypeParamScope(node);\n\n this.visit(node.right);\n\n if (typeParamScope) {\n this.close(node);\n }\n }\n\n ClassProperty(node: any) {\n this._visitClassProperty(node);\n }\n\n ClassPrivateProperty(node: any) {\n this._visitClassProperty(node);\n }\n\n AccessorProperty(node: any) {\n this._visitClassProperty(node);\n }\n\n ClassAccessorProperty(node: any) {\n this._visitClassProperty(node);\n }\n\n PropertyDefinition(node: any) {\n this._visitClassProperty(node);\n }\n\n // TODO: Update to visit type annotations when TypeScript/Flow support this syntax.\n ClassPrivateMethod(node: any) {\n super.MethodDefinition(node);\n }\n\n DeclareModule(node: any) {\n this._visitDeclareX(node);\n }\n\n DeclareFunction(node: any) {\n this._visitDeclareX(node);\n }\n\n DeclareVariable(node: any) {\n this._visitDeclareX(node);\n }\n\n DeclareClass(node: any) {\n this._visitDeclareX(node);\n }\n\n // visit OptionalMemberExpression as a MemberExpression.\n OptionalMemberExpression(node: any) {\n super.MemberExpression(node);\n }\n\n _visitClassProperty(node: any) {\n const { computed, key, typeAnnotation, decorators, value } = node;\n\n this._visitArray(decorators);\n if (computed) this.visit(key);\n this._visitTypeAnnotation(typeAnnotation);\n\n if (value) {\n if (this.scopeManager.__nestClassFieldInitializerScope) {\n this.scopeManager.__nestClassFieldInitializerScope(value);\n } else {\n // Given that ESLint 7 didn't have a \"class field initializer\" scope,\n // we create a plain method scope. Semantics are the same.\n this.scopeManager.__nestScope(\n new Scope(\n this.scopeManager,\n \"function\",\n this.scopeManager.__currentScope,\n value,\n true,\n ),\n );\n }\n this.visit(value);\n this.close(value);\n }\n }\n\n _visitDeclareX(node: any) {\n if (node.id) {\n this._createScopeVariable(node, node.id);\n }\n\n const typeParamScope = this._nestTypeParamScope(node);\n if (typeParamScope) {\n this.close(node);\n }\n }\n\n _createScopeVariable(node: any, name: any) {\n this.currentScope().variableScope.__define(\n name,\n new Definition(\"Variable\", name, node, null, null, null),\n );\n }\n\n _nestTypeParamScope(node: any) {\n if (!node.typeParameters) {\n return null;\n }\n\n const parentScope = this.scopeManager.__currentScope;\n const scope = new Scope(\n this.scopeManager,\n \"type-parameters\",\n parentScope,\n node,\n false,\n );\n\n this.scopeManager.__nestScope(scope);\n for (let j = 0; j < node.typeParameters.params.length; j++) {\n const name = node.typeParameters.params[j];\n scope.__define(name, new Definition(\"TypeParameter\", name, name));\n if (name.typeAnnotation) {\n this._checkIdentifierOrVisit(name);\n }\n }\n scope.__define = parentScope.__define.bind(parentScope);\n\n return scope;\n }\n\n _visitTypeAnnotation(node: any) {\n if (!node) {\n return;\n }\n if (Array.isArray(node)) {\n node.forEach(this._visitTypeAnnotation, this);\n return;\n }\n\n // get property to check (params, id, etc...)\n const visitorValues = getVisitorValues(node.type, this.#client);\n if (!visitorValues) {\n return;\n }\n\n // can have multiple properties\n for (let i = 0; i < visitorValues.length; i++) {\n const visitorValue = visitorValues[i];\n const propertyType = (propertyTypes as Record)[visitorValue];\n const nodeProperty = node[visitorValue];\n // check if property or type is defined\n if (propertyType == null || nodeProperty == null) {\n continue;\n }\n if (propertyType.type === \"loop\") {\n for (let j = 0; j < nodeProperty.length; j++) {\n if (Array.isArray(propertyType.values)) {\n for (let k = 0; k < propertyType.values.length; k++) {\n const loopPropertyNode = nodeProperty[j][propertyType.values[k]];\n if (loopPropertyNode) {\n this._checkIdentifierOrVisit(loopPropertyNode);\n }\n }\n } else {\n this._checkIdentifierOrVisit(nodeProperty[j]);\n }\n }\n } else if (propertyType.type === \"single\") {\n this._checkIdentifierOrVisit(nodeProperty);\n } else if (propertyType.type === \"typeAnnotation\") {\n this._visitTypeAnnotation(node.typeAnnotation);\n } else if (propertyType.type === \"typeParameters\") {\n for (let l = 0; l < node.typeParameters.params.length; l++) {\n this._checkIdentifierOrVisit(node.typeParameters.params[l]);\n }\n } else if (propertyType.type === \"id\") {\n if (node.id.type === \"Identifier\") {\n this._checkIdentifierOrVisit(node.id);\n } else {\n this._visitTypeAnnotation(node.id);\n }\n }\n }\n }\n\n _checkIdentifierOrVisit(node: any) {\n if (node?.typeAnnotation) {\n this._visitTypeAnnotation(node.typeAnnotation);\n } else if (node?.type === \"Identifier\") {\n this.visit(node);\n } else {\n this._visitTypeAnnotation(node);\n }\n }\n\n _visitArray(nodeList: any[]) {\n if (nodeList) {\n for (const node of nodeList) {\n this.visit(node);\n }\n }\n }\n}\n\nexport = function analyzeScope(ast: any, parserOptions: any, client: Client) {\n const options = {\n ignoreEval: true,\n optimistic: false,\n directive: false,\n nodejsScope:\n ast.sourceType === \"script\" &&\n parserOptions.ecmaFeatures?.globalReturn === true,\n impliedStrict: false,\n sourceType: ast.sourceType,\n ecmaVersion: parserOptions.ecmaVersion,\n fallback,\n childVisitorKeys: client.getVisitorKeys(),\n };\n\n const scopeManager = new ScopeManager(options);\n const referencer = new Referencer(options, scopeManager, client);\n\n referencer.visit(ast);\n\n return scopeManager as any;\n};\n"],"mappings":"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","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/client.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/client.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/client.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,104 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.WorkerClient = exports.Client = exports.ACTIONS = void 0; +var _LocalClient, _handleMessage; +function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); } +function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); } +function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); } +function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; } +function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); } +const path = require("path"); +const ACTIONS = exports.ACTIONS = { + GET_VERSION: "GET_VERSION", + GET_TYPES_INFO: "GET_TYPES_INFO", + GET_VISITOR_KEYS: "GET_VISITOR_KEYS", + GET_TOKEN_LABELS: "GET_TOKEN_LABELS", + MAYBE_PARSE: "MAYBE_PARSE", + MAYBE_PARSE_SYNC: "MAYBE_PARSE_SYNC" +}; +var _send = new WeakMap(); +var _vCache = new WeakMap(); +var _tiCache = new WeakMap(); +var _vkCache = new WeakMap(); +var _tlCache = new WeakMap(); +class Client { + constructor(send) { + _classPrivateFieldInitSpec(this, _send, void 0); + _classPrivateFieldInitSpec(this, _vCache, void 0); + _classPrivateFieldInitSpec(this, _tiCache, void 0); + _classPrivateFieldInitSpec(this, _vkCache, void 0); + _classPrivateFieldInitSpec(this, _tlCache, void 0); + _classPrivateFieldSet(_send, this, send); + } + getVersion() { + var _classPrivateFieldGet2; + return (_classPrivateFieldGet2 = _classPrivateFieldGet(_vCache, this)) != null ? _classPrivateFieldGet2 : _classPrivateFieldSet(_vCache, this, _classPrivateFieldGet(_send, this).call(this, ACTIONS.GET_VERSION, undefined)); + } + getTypesInfo() { + var _classPrivateFieldGet3; + return (_classPrivateFieldGet3 = _classPrivateFieldGet(_tiCache, this)) != null ? _classPrivateFieldGet3 : _classPrivateFieldSet(_tiCache, this, _classPrivateFieldGet(_send, this).call(this, ACTIONS.GET_TYPES_INFO, undefined)); + } + getVisitorKeys() { + var _classPrivateFieldGet4; + return (_classPrivateFieldGet4 = _classPrivateFieldGet(_vkCache, this)) != null ? _classPrivateFieldGet4 : _classPrivateFieldSet(_vkCache, this, _classPrivateFieldGet(_send, this).call(this, ACTIONS.GET_VISITOR_KEYS, undefined)); + } + getTokLabels() { + var _classPrivateFieldGet5; + return (_classPrivateFieldGet5 = _classPrivateFieldGet(_tlCache, this)) != null ? _classPrivateFieldGet5 : _classPrivateFieldSet(_tlCache, this, _classPrivateFieldGet(_send, this).call(this, ACTIONS.GET_TOKEN_LABELS, undefined)); + } + maybeParse(code, options) { + return _classPrivateFieldGet(_send, this).call(this, ACTIONS.MAYBE_PARSE, { + code, + options + }); + } +} +exports.Client = Client; +var _worker = new WeakMap(); +class WorkerClient extends Client { + constructor() { + super((action, payload) => { + const signal = new Int32Array(new SharedArrayBuffer(8)); + const subChannel = new (_get_worker_threads(WorkerClient).MessageChannel)(); + _classPrivateFieldGet(_worker, this).postMessage({ + signal, + port: subChannel.port1, + action, + payload + }, [subChannel.port1]); + Atomics.wait(signal, 0, 0); + const { + message + } = _get_worker_threads(WorkerClient).receiveMessageOnPort(subChannel.port2); + if (message.error) throw Object.assign(message.error, message.errorData);else return message.result; + }); + _classPrivateFieldInitSpec(this, _worker, new (_get_worker_threads(WorkerClient).Worker)(path.resolve(__dirname, "../lib/worker/index.cjs"), { + env: _get_worker_threads(WorkerClient).SHARE_ENV + })); + _classPrivateFieldGet(_worker, this).unref(); + } +} +exports.WorkerClient = WorkerClient; +function _get_worker_threads(_this) { + var _worker_threads_cache2; + return (_worker_threads_cache2 = _worker_threads_cache._) != null ? _worker_threads_cache2 : _worker_threads_cache._ = require("worker_threads"); +} +var _worker_threads_cache = { + _: void 0 +}; +exports.LocalClient = (_LocalClient = class LocalClient extends Client { + constructor() { + var _assertClassBrand$_; + (_assertClassBrand$_ = _assertClassBrand(_LocalClient, LocalClient, _handleMessage)._) != null ? _assertClassBrand$_ : _handleMessage._ = _assertClassBrand(_LocalClient, LocalClient, require("./worker/handle-message.cjs")); + super((action, payload) => { + return _assertClassBrand(_LocalClient, LocalClient, _handleMessage)._.call(LocalClient, action === ACTIONS.MAYBE_PARSE ? ACTIONS.MAYBE_PARSE_SYNC : action, payload); + }); + } +}, _handleMessage = { + _: void 0 +}, _LocalClient); + +//# sourceMappingURL=client.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/client.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/client.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/client.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["path","require","ACTIONS","exports","GET_VERSION","GET_TYPES_INFO","GET_VISITOR_KEYS","GET_TOKEN_LABELS","MAYBE_PARSE","MAYBE_PARSE_SYNC","_send","WeakMap","_vCache","_tiCache","_vkCache","_tlCache","Client","constructor","send","_classPrivateFieldInitSpec","_classPrivateFieldSet","getVersion","_classPrivateFieldGet2","_classPrivateFieldGet","call","undefined","getTypesInfo","_classPrivateFieldGet3","getVisitorKeys","_classPrivateFieldGet4","getTokLabels","_classPrivateFieldGet5","maybeParse","code","options","_worker","WorkerClient","action","payload","signal","Int32Array","SharedArrayBuffer","subChannel","_get_worker_threads","MessageChannel","postMessage","port","port1","Atomics","wait","message","receiveMessageOnPort","port2","error","Object","assign","errorData","result","Worker","resolve","__dirname","env","SHARE_ENV","unref","_this","_worker_threads_cache2","_worker_threads_cache","_","LocalClient","_LocalClient","_assertClassBrand$_","_assertClassBrand","_handleMessage"],"sources":["../src/client.cts"],"sourcesContent":["import type { Options } from \"./types.cts\";\n\nimport path = require(\"path\");\n\nexport const enum ACTIONS {\n GET_VERSION = \"GET_VERSION\",\n GET_TYPES_INFO = \"GET_TYPES_INFO\",\n GET_VISITOR_KEYS = \"GET_VISITOR_KEYS\",\n GET_TOKEN_LABELS = \"GET_TOKEN_LABELS\",\n MAYBE_PARSE = \"MAYBE_PARSE\",\n MAYBE_PARSE_SYNC = \"MAYBE_PARSE_SYNC\",\n}\n\nexport class Client {\n #send;\n\n constructor(send: Function) {\n this.#send = send;\n }\n\n #vCache: string;\n getVersion() {\n return (this.#vCache ??= this.#send(ACTIONS.GET_VERSION, undefined));\n }\n\n #tiCache: any;\n getTypesInfo() {\n return (this.#tiCache ??= this.#send(ACTIONS.GET_TYPES_INFO, undefined));\n }\n\n #vkCache: any;\n getVisitorKeys() {\n return (this.#vkCache ??= this.#send(ACTIONS.GET_VISITOR_KEYS, undefined));\n }\n\n #tlCache: any;\n getTokLabels() {\n return (this.#tlCache ??= this.#send(ACTIONS.GET_TOKEN_LABELS, undefined));\n }\n\n maybeParse(code: string, options: Options) {\n return this.#send(ACTIONS.MAYBE_PARSE, { code, options });\n }\n}\n\n// We need to run Babel in a worker for two reasons:\n// 1. ESLint workers must be CJS files, and this is a problem\n// since Babel 8+ uses native ESM\n// 2. ESLint parsers must run synchronously, but many steps\n// of Babel's config loading (which is done for each file)\n// can be asynchronous\n// If ESLint starts supporting async parsers, we can move\n// everything back to the main thread.\nexport class WorkerClient extends Client {\n static #worker_threads_cache: typeof import(\"worker_threads\");\n static get #worker_threads() {\n return (WorkerClient.#worker_threads_cache ??= require(\"node:worker_threads\"));\n }\n\n #worker = new WorkerClient.#worker_threads.Worker(\n path.resolve(__dirname, \"../lib/worker/index.cjs\"),\n { env: WorkerClient.#worker_threads.SHARE_ENV },\n );\n\n constructor() {\n super((action: ACTIONS, payload: any) => {\n // We create a new SharedArrayBuffer every time rather than reusing\n // the same one, otherwise sometimes its contents get corrupted and\n // Atomics.wait wakes up too early.\n // https://github.com/babel/babel/pull/14541\n const signal = new Int32Array(new SharedArrayBuffer(8));\n\n const subChannel = new WorkerClient.#worker_threads.MessageChannel();\n\n this.#worker.postMessage(\n { signal, port: subChannel.port1, action, payload },\n [subChannel.port1],\n );\n\n Atomics.wait(signal, 0, 0);\n const { message } = WorkerClient.#worker_threads.receiveMessageOnPort(\n subChannel.port2,\n );\n\n if (message.error) throw Object.assign(message.error, message.errorData);\n else return message.result;\n });\n\n // The worker will never exit by itself. Prevent it from keeping\n // the main process alive.\n this.#worker.unref();\n }\n}\n\nif (!USE_ESM) {\n exports.LocalClient = class LocalClient extends Client {\n static #handleMessage: Function;\n\n constructor() {\n LocalClient.#handleMessage ??= require(\"./worker/handle-message.cjs\");\n\n super((action: ACTIONS, payload: any) => {\n return LocalClient.#handleMessage(\n action === ACTIONS.MAYBE_PARSE ? ACTIONS.MAYBE_PARSE_SYNC : action,\n payload,\n );\n });\n }\n };\n}\n"],"mappings":"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","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/configuration.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/configuration.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/configuration.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,23 @@ +"use strict"; + +const _excluded = ["babelOptions", "ecmaVersion", "sourceType", "requireConfigFile"]; +function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; } +module.exports = function normalizeESLintConfig(options) { + const { + babelOptions = {}, + ecmaVersion = "latest", + sourceType = "module", + requireConfigFile = true + } = options, + otherOptions = _objectWithoutPropertiesLoose(options, _excluded); + return Object.assign({ + babelOptions: Object.assign({ + cwd: process.cwd() + }, babelOptions), + ecmaVersion: ecmaVersion === "latest" ? 1e8 : ecmaVersion, + sourceType, + requireConfigFile + }, otherOptions); +}; + +//# sourceMappingURL=configuration.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/configuration.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/configuration.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/configuration.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["normalizeESLintConfig","options","babelOptions","ecmaVersion","sourceType","requireConfigFile","otherOptions","_objectWithoutPropertiesLoose","_excluded","Object","assign","cwd","process"],"sources":["../src/configuration.cts"],"sourcesContent":["import type { Options } from \"./types.cts\";\n\nexport = function normalizeESLintConfig(options: any) {\n const {\n babelOptions = {},\n // ESLint sets ecmaVersion: undefined when ecmaVersion is not set in the config.\n ecmaVersion = \"latest\",\n sourceType = \"module\",\n requireConfigFile = true,\n ...otherOptions\n } = options;\n\n return {\n babelOptions: { cwd: process.cwd(), ...babelOptions },\n ecmaVersion: ecmaVersion === \"latest\" ? 1e8 : ecmaVersion,\n sourceType,\n requireConfigFile,\n ...otherOptions,\n } as Options;\n};\n"],"mappings":";;;;iBAES,SAASA,qBAAqBA,CAACC,OAAY,EAAE;EACpD,MAAM;MACJC,YAAY,GAAG,CAAC,CAAC;MAEjBC,WAAW,GAAG,QAAQ;MACtBC,UAAU,GAAG,QAAQ;MACrBC,iBAAiB,GAAG;IAEtB,CAAC,GAAGJ,OAAO;IADNK,YAAY,GAAAC,6BAAA,CACbN,OAAO,EAAAO,SAAA;EAEX,OAAAC,MAAA,CAAAC,MAAA;IACER,YAAY,EAAAO,MAAA,CAAAC,MAAA;MAAIC,GAAG,EAAEC,OAAO,CAACD,GAAG,CAAC;IAAC,GAAKT,YAAY,CAAE;IACrDC,WAAW,EAAEA,WAAW,KAAK,QAAQ,GAAG,GAAG,GAAGA,WAAW;IACzDC,UAAU;IACVC;EAAiB,GACdC,YAAY;AAEnB,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/convert/convertAST.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/convertAST.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/convertAST.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,134 @@ +"use strict"; + +const ESLINT_VERSION = require("../utils/eslint-version.cjs"); +function* it(children) { + if (Array.isArray(children)) yield* children;else yield children; +} +function traverse(node, visitorKeys, visitor) { + const { + type + } = node; + if (!type) return; + const keys = visitorKeys[type]; + if (!keys) return; + for (const key of keys) { + for (const child of it(node[key])) { + if (child && typeof child === "object") { + visitor.enter(child); + traverse(child, visitorKeys, visitor); + visitor.exit(child); + } + } + } +} +const convertNodesVisitor = { + enter(node) { + if (node.innerComments) { + delete node.innerComments; + } + if (node.trailingComments) { + delete node.trailingComments; + } + if (node.leadingComments) { + delete node.leadingComments; + } + }, + exit(node) { + if (node.extra) { + delete node.extra; + } + if (node.loc.identifierName) { + delete node.loc.identifierName; + } + if (node.type === "TypeParameter") { + node.type = "Identifier"; + node.typeAnnotation = node.bound; + delete node.bound; + } + if (node.type === "QualifiedTypeIdentifier") { + delete node.id; + } + if (node.type === "ObjectTypeProperty") { + delete node.key; + } + if (node.type === "ObjectTypeIndexer") { + delete node.id; + } + if (node.type === "FunctionTypeParam") { + delete node.name; + } + if (node.type === "ImportDeclaration") { + delete node.isType; + } + if (node.type === "TemplateLiteral" || node.type === "TSTemplateLiteralType") { + for (let i = 0; i < node.quasis.length; i++) { + const q = node.quasis[i]; + q.range[0] -= 1; + if (q.tail) { + q.range[1] += 1; + } else { + q.range[1] += 2; + } + q.loc.start.column -= 1; + if (q.tail) { + q.loc.end.column += 1; + } else { + q.loc.end.column += 2; + } + if (ESLINT_VERSION >= 8) { + q.start -= 1; + if (q.tail) { + q.end += 1; + } else { + q.end += 2; + } + } + } + } + } +}; +function convertNodes(ast, visitorKeys) { + traverse(ast, visitorKeys, convertNodesVisitor); +} +function convertProgramNode(ast) { + const body = ast.program.body; + Object.assign(ast, { + type: "Program", + sourceType: ast.program.sourceType, + body + }); + delete ast.program; + delete ast.errors; + if (ast.comments.length) { + const lastComment = ast.comments[ast.comments.length - 1]; + if (ast.tokens.length) { + const lastToken = ast.tokens[ast.tokens.length - 1]; + if (lastComment.end > lastToken.end) { + ast.range[1] = lastToken.end; + ast.loc.end.line = lastToken.loc.end.line; + ast.loc.end.column = lastToken.loc.end.column; + if (ESLINT_VERSION >= 8) { + ast.end = lastToken.end; + } + } + } + } else { + if (!ast.tokens.length) { + ast.loc.start.line = 1; + ast.loc.end.line = 1; + } + } + if (body != null && body.length) { + ast.loc.start.line = body[0].loc.start.line; + ast.range[0] = body[0].start; + if (ESLINT_VERSION >= 8) { + ast.start = body[0].start; + } + } +} +module.exports = function convertAST(ast, visitorKeys) { + convertNodes(ast, visitorKeys); + convertProgramNode(ast); +}; + +//# sourceMappingURL=convertAST.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/convert/convertAST.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/convertAST.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/convertAST.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["ESLINT_VERSION","require","it","children","Array","isArray","traverse","node","visitorKeys","visitor","type","keys","key","child","enter","exit","convertNodesVisitor","innerComments","trailingComments","leadingComments","extra","loc","identifierName","typeAnnotation","bound","id","name","isType","i","quasis","length","q","range","tail","start","column","end","convertNodes","ast","convertProgramNode","body","program","Object","assign","sourceType","errors","comments","lastComment","tokens","lastToken","line","module","exports","convertAST"],"sources":["../../src/convert/convertAST.cts"],"sourcesContent":["import type * as t from \"@babel/types\";\nimport ESLINT_VERSION = require(\"../utils/eslint-version.cts\");\nimport type { ParseResult } from \"../types.d.cts\";\n\nfunction* it(children: T | T[]) {\n if (Array.isArray(children)) yield* children;\n else yield children;\n}\n\nfunction traverse(\n node: t.Node,\n visitorKeys: Record,\n visitor: typeof convertNodesVisitor,\n) {\n const { type } = node;\n if (!type) return;\n const keys = visitorKeys[type];\n if (!keys) return;\n\n for (const key of keys) {\n for (const child of it(\n node[key as keyof t.Node] as unknown as t.Node | t.Node[],\n )) {\n if (child && typeof child === \"object\") {\n visitor.enter(child);\n traverse(child, visitorKeys, visitor);\n visitor.exit(child);\n }\n }\n }\n}\n\nconst convertNodesVisitor = {\n enter(node: t.Node) {\n if (node.innerComments) {\n delete node.innerComments;\n }\n\n if (node.trailingComments) {\n delete node.trailingComments;\n }\n\n if (node.leadingComments) {\n delete node.leadingComments;\n }\n },\n exit(node: t.Node) {\n // Used internally by @babel/parser.\n if (node.extra) {\n delete node.extra;\n }\n\n if (process.env.IS_PUBLISH) {\n if (node.loc.identifierName) {\n delete node.loc.identifierName;\n }\n } else {\n // To minimize the jest-diff noise comparing Babel AST and third-party AST,\n // here we generate a deep copy of loc without identifierName and index\n if (node.loc) {\n node.loc = {\n end: {\n column: node.loc.end.column,\n line: node.loc.end.line,\n },\n start: {\n column: node.loc.start.column,\n line: node.loc.start.line,\n },\n } as any;\n }\n }\n\n if (node.type === \"TypeParameter\") {\n // @ts-expect-error eslint\n node.type = \"Identifier\";\n // @ts-expect-error eslint\n node.typeAnnotation = node.bound;\n delete node.bound;\n }\n\n // flow: prevent \"no-undef\"\n // for \"Component\" in: \"let x: React.Component\"\n if (node.type === \"QualifiedTypeIdentifier\") {\n delete node.id;\n }\n // for \"b\" in: \"var a: { b: Foo }\"\n if (node.type === \"ObjectTypeProperty\") {\n delete node.key;\n }\n // for \"indexer\" in: \"var a: {[indexer: string]: number}\"\n if (node.type === \"ObjectTypeIndexer\") {\n delete node.id;\n }\n // for \"param\" in: \"var a: { func(param: Foo): Bar };\"\n if (node.type === \"FunctionTypeParam\") {\n delete node.name;\n }\n\n // modules\n if (node.type === \"ImportDeclaration\") {\n // @ts-expect-error legacy?\n delete node.isType;\n }\n\n // template string range fixes\n if (\n node.type === \"TemplateLiteral\" ||\n node.type === \"TSTemplateLiteralType\"\n ) {\n for (let i = 0; i < node.quasis.length; i++) {\n const q = node.quasis[i];\n q.range[0] -= 1;\n if (q.tail) {\n q.range[1] += 1;\n } else {\n q.range[1] += 2;\n }\n q.loc.start.column -= 1;\n if (q.tail) {\n q.loc.end.column += 1;\n } else {\n q.loc.end.column += 2;\n }\n\n if (ESLINT_VERSION >= 8) {\n q.start -= 1;\n if (q.tail) {\n q.end += 1;\n } else {\n q.end += 2;\n }\n }\n }\n }\n },\n};\n\nfunction convertNodes(ast: ParseResult, visitorKeys: Record) {\n traverse(ast as unknown as t.Program, visitorKeys, convertNodesVisitor);\n}\n\nfunction convertProgramNode(ast: ParseResult) {\n const body = ast.program.body;\n Object.assign(ast, {\n type: \"Program\",\n sourceType: ast.program.sourceType,\n body,\n });\n delete ast.program;\n delete ast.errors;\n\n if (ast.comments.length) {\n const lastComment = ast.comments[ast.comments.length - 1];\n\n if (ast.tokens.length) {\n const lastToken = ast.tokens[ast.tokens.length - 1];\n\n if (lastComment.end > lastToken.end) {\n // If there is a comment after the last token, the program ends at the\n // last token and not the comment\n ast.range[1] = lastToken.end;\n ast.loc.end.line = lastToken.loc.end.line;\n ast.loc.end.column = lastToken.loc.end.column;\n\n if (ESLINT_VERSION >= 8) {\n ast.end = lastToken.end;\n }\n }\n }\n } else {\n if (!ast.tokens.length) {\n ast.loc.start.line = 1;\n ast.loc.end.line = 1;\n }\n }\n\n if (body?.length) {\n ast.loc.start.line = body[0].loc.start.line;\n ast.range[0] = body[0].start;\n\n if (ESLINT_VERSION >= 8) {\n ast.start = body[0].start;\n }\n }\n}\n\nexport = function convertAST(\n ast: ParseResult,\n visitorKeys: Record,\n) {\n convertNodes(ast, visitorKeys);\n convertProgramNode(ast);\n};\n"],"mappings":"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","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,10 @@ +"use strict"; + +module.exports = function convertComments(comments) { + for (const comment of comments) { + comment.type = comment.type === "CommentBlock" ? "Block" : "Line"; + comment.range || (comment.range = [comment.start, comment.end]); + } +}; + +//# sourceMappingURL=convertComments.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/convertComments.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["convertComments","comments","comment","type","range","start","end"],"sources":["../../src/convert/convertComments.cts"],"sourcesContent":["import type { Comment } from \"@babel/types\";\n\nexport = function convertComments(comments: Comment[]) {\n for (const comment of comments) {\n // @ts-expect-error eslint\n comment.type = comment.type === \"CommentBlock\" ? \"Block\" : \"Line\";\n\n // sometimes comments don't get ranges computed,\n // even with options.ranges === true\n\n // @ts-expect-error eslint\n comment.range ||= [comment.start, comment.end];\n }\n};\n"],"mappings":";;iBAES,SAASA,eAAeA,CAACC,QAAmB,EAAE;EACrD,KAAK,MAAMC,OAAO,IAAID,QAAQ,EAAE;IAE9BC,OAAO,CAACC,IAAI,GAAGD,OAAO,CAACC,IAAI,KAAK,cAAc,GAAG,OAAO,GAAG,MAAM;IAMjED,OAAO,CAACE,KAAK,KAAbF,OAAO,CAACE,KAAK,GAAK,CAACF,OAAO,CAACG,KAAK,EAAEH,OAAO,CAACI,GAAG,CAAC;EAChD;AACF,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/convert/convertTokens.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/convertTokens.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/convertTokens.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,158 @@ +"use strict"; + +const ESLINT_VERSION = require("../utils/eslint-version.cjs"); +function convertTemplateType(tokens, tl) { + let curlyBrace = null; + let templateTokens = []; + const result = []; + function addTemplateType() { + const start = templateTokens[0]; + const end = templateTokens[templateTokens.length - 1]; + const value = templateTokens.reduce((result, token) => { + if (token.value) { + result += token.value; + } else if (token.type.label !== tl.template) { + result += token.type.label; + } + return result; + }, ""); + result.push({ + type: "Template", + value: value, + start: start.start, + end: end.end, + loc: { + start: start.loc.start, + end: end.loc.end + } + }); + templateTokens = []; + } + tokens.forEach(token => { + switch (token.type.label) { + case tl.backQuote: + if (curlyBrace) { + result.push(curlyBrace); + curlyBrace = null; + } + templateTokens.push(token); + if (templateTokens.length > 1) { + addTemplateType(); + } + break; + case tl.dollarBraceL: + templateTokens.push(token); + addTemplateType(); + break; + case tl.braceR: + if (curlyBrace) { + result.push(curlyBrace); + } + curlyBrace = token; + break; + case tl.template: + if (curlyBrace) { + templateTokens.push(curlyBrace); + curlyBrace = null; + } + templateTokens.push(token); + break; + default: + if (curlyBrace) { + result.push(curlyBrace); + curlyBrace = null; + } + result.push(token); + } + }); + return result; +} +function convertToken(token, source, tl) { + const { + type + } = token; + const { + label + } = type; + const newToken = token; + newToken.range = [token.start, token.end]; + if (label === tl.name) { + const tokenValue = token.value; + if (tokenValue === "let" || tokenValue === "static" || tokenValue === "yield") { + newToken.type = "Keyword"; + } else { + newToken.type = "Identifier"; + } + } else if (label === tl.semi || label === tl.comma || label === tl.parenL || label === tl.parenR || label === tl.braceL || label === tl.braceR || label === tl.slash || label === tl.dot || label === tl.bracketL || label === tl.bracketR || label === tl.ellipsis || label === tl.arrow || label === tl.pipeline || label === tl.star || label === tl.incDec || label === tl.colon || label === tl.question || label === tl.template || label === tl.backQuote || label === tl.dollarBraceL || label === tl.at || label === tl.logicalOR || label === tl.logicalAND || label === tl.nullishCoalescing || label === tl.bitwiseOR || label === tl.bitwiseXOR || label === tl.bitwiseAND || label === tl.equality || label === tl.relational || label === tl.bitShift || label === tl.plusMin || label === tl.modulo || label === tl.exponent || label === tl.bang || label === tl.tilde || label === tl.doubleColon || label === tl.hash || label === tl.questionDot || label === tl.braceHashL || label === tl.braceBarL || label === tl.braceBarR || label === tl.bracketHashL || label === tl.bracketBarL || label === tl.bracketBarR || label === tl.doubleCaret || label === tl.doubleAt || type.isAssign) { + var _newToken$value; + newToken.type = "Punctuator"; + (_newToken$value = newToken.value) != null ? _newToken$value : newToken.value = label; + } else if (label === tl.jsxTagStart) { + newToken.type = "Punctuator"; + newToken.value = "<"; + } else if (label === tl.jsxTagEnd) { + newToken.type = "Punctuator"; + newToken.value = ">"; + } else if (label === tl.jsxName) { + newToken.type = "JSXIdentifier"; + } else if (label === tl.jsxText) { + newToken.type = "JSXText"; + } else if (type.keyword === "null") { + newToken.type = "Null"; + } else if (type.keyword === "false" || type.keyword === "true") { + newToken.type = "Boolean"; + } else if (type.keyword) { + newToken.type = "Keyword"; + } else if (label === tl.num) { + newToken.type = "Numeric"; + newToken.value = source.slice(token.start, token.end); + } else if (label === tl.string) { + newToken.type = "String"; + newToken.value = source.slice(token.start, token.end); + } else if (label === tl.regexp) { + newToken.type = "RegularExpression"; + const value = token.value; + newToken.regex = { + pattern: value.pattern, + flags: value.flags + }; + newToken.value = `/${value.pattern}/${value.flags}`; + } else if (label === tl.bigint) { + newToken.type = "Numeric"; + newToken.value = `${token.value}n`; + } else if (label === tl.privateName) { + newToken.type = "PrivateIdentifier"; + } else if (label === tl.templateNonTail || label === tl.templateTail || label === tl.Template) { + newToken.type = "Template"; + } + return newToken; +} +module.exports = function convertTokens(tokens, code, tokLabels) { + const result = []; + const templateTypeMergedTokens = convertTemplateType(tokens, tokLabels); + for (let i = 0, { + length + } = templateTypeMergedTokens; i < length - 1; i++) { + const token = templateTypeMergedTokens[i]; + const tokenType = token.type; + if (tokenType === "CommentLine" || tokenType === "CommentBlock") { + continue; + } + if (ESLINT_VERSION >= 8 && i + 1 < length && tokenType.label === tokLabels.hash) { + const nextToken = templateTypeMergedTokens[i + 1]; + if (nextToken.type.label === tokLabels.name && token.end === nextToken.start) { + i++; + nextToken.type = "PrivateIdentifier"; + nextToken.start -= 1; + nextToken.loc.start.column -= 1; + nextToken.range = [nextToken.start, nextToken.end]; + result.push(nextToken); + continue; + } + } + result.push(convertToken(token, code, tokLabels)); + } + return result; +}; + +//# sourceMappingURL=convertTokens.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/convert/convertTokens.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/convertTokens.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/convertTokens.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["ESLINT_VERSION","require","convertTemplateType","tokens","tl","curlyBrace","templateTokens","result","addTemplateType","start","end","length","value","reduce","token","type","label","template","push","loc","forEach","backQuote","dollarBraceL","braceR","convertToken","source","newToken","range","name","tokenValue","semi","comma","parenL","parenR","braceL","slash","dot","bracketL","bracketR","ellipsis","arrow","pipeline","star","incDec","colon","question","at","logicalOR","logicalAND","nullishCoalescing","bitwiseOR","bitwiseXOR","bitwiseAND","equality","relational","bitShift","plusMin","modulo","exponent","bang","tilde","doubleColon","hash","questionDot","braceHashL","braceBarL","braceBarR","bracketHashL","bracketBarL","bracketBarR","doubleCaret","doubleAt","isAssign","_newToken$value","jsxTagStart","jsxTagEnd","jsxName","jsxText","keyword","num","slice","string","regexp","regex","pattern","flags","bigint","privateName","templateNonTail","templateTail","Template","module","exports","convertTokens","code","tokLabels","templateTypeMergedTokens","i","tokenType","nextToken","column"],"sources":["../../src/convert/convertTokens.cts"],"sourcesContent":["import type { BabelToken } from \"../types.cts\";\nimport type * as t from \"@babel/types\";\nimport ESLINT_VERSION = require(\"../utils/eslint-version.cjs\");\n\nfunction convertTemplateType(tokens: BabelToken[], tl: Record) {\n let curlyBrace: BabelToken = null;\n let templateTokens: BabelToken[] = [];\n const result: any[] = [];\n\n function addTemplateType() {\n const start = templateTokens[0];\n const end = templateTokens[templateTokens.length - 1];\n\n const value = templateTokens.reduce((result, token) => {\n if (token.value) {\n result += token.value;\n } else if (token.type.label !== tl.template) {\n result += token.type.label;\n }\n\n return result;\n }, \"\");\n\n result.push({\n type: \"Template\",\n value: value,\n start: start.start,\n end: end.end,\n loc: {\n start: start.loc.start,\n end: end.loc.end,\n },\n });\n\n templateTokens = [];\n }\n\n tokens.forEach(token => {\n switch (token.type.label) {\n case tl.backQuote:\n if (curlyBrace) {\n result.push(curlyBrace);\n curlyBrace = null;\n }\n\n templateTokens.push(token);\n\n if (templateTokens.length > 1) {\n addTemplateType();\n }\n\n break;\n\n case tl.dollarBraceL:\n templateTokens.push(token);\n addTemplateType();\n break;\n\n case tl.braceR:\n if (curlyBrace) {\n result.push(curlyBrace);\n }\n\n curlyBrace = token;\n break;\n\n case tl.template:\n if (curlyBrace) {\n templateTokens.push(curlyBrace);\n curlyBrace = null;\n }\n\n templateTokens.push(token);\n break;\n\n default:\n if (curlyBrace) {\n result.push(curlyBrace);\n curlyBrace = null;\n }\n\n result.push(token);\n }\n });\n\n return result;\n}\n\nfunction convertToken(\n token: BabelToken,\n source: string,\n tl: Record,\n) {\n const { type } = token;\n const { label } = type;\n\n const newToken: {\n type: string;\n range?: [number, number];\n value?: string;\n regex?: {\n pattern: string;\n flags: string;\n };\n loc?: t.SourceLocation | null;\n } = token as any;\n newToken.range = [token.start, token.end];\n\n if (label === tl.name) {\n const tokenValue = token.value;\n if (\n tokenValue === \"let\" ||\n tokenValue === \"static\" ||\n tokenValue === \"yield\"\n ) {\n newToken.type = \"Keyword\";\n } else {\n newToken.type = \"Identifier\";\n }\n } else if (\n label === tl.semi ||\n label === tl.comma ||\n label === tl.parenL ||\n label === tl.parenR ||\n label === tl.braceL ||\n label === tl.braceR ||\n label === tl.slash ||\n label === tl.dot ||\n label === tl.bracketL ||\n label === tl.bracketR ||\n label === tl.ellipsis ||\n label === tl.arrow ||\n label === tl.pipeline ||\n label === tl.star ||\n label === tl.incDec ||\n label === tl.colon ||\n label === tl.question ||\n label === tl.template ||\n label === tl.backQuote ||\n label === tl.dollarBraceL ||\n label === tl.at ||\n label === tl.logicalOR ||\n label === tl.logicalAND ||\n label === tl.nullishCoalescing ||\n label === tl.bitwiseOR ||\n label === tl.bitwiseXOR ||\n label === tl.bitwiseAND ||\n label === tl.equality ||\n label === tl.relational ||\n label === tl.bitShift ||\n label === tl.plusMin ||\n label === tl.modulo ||\n label === tl.exponent ||\n label === tl.bang ||\n label === tl.tilde ||\n label === tl.doubleColon ||\n label === tl.hash ||\n label === tl.questionDot ||\n label === tl.braceHashL ||\n label === tl.braceBarL ||\n label === tl.braceBarR ||\n label === tl.bracketHashL ||\n label === tl.bracketBarL ||\n label === tl.bracketBarR ||\n label === tl.doubleCaret ||\n label === tl.doubleAt ||\n type.isAssign\n ) {\n newToken.type = \"Punctuator\";\n newToken.value ??= label;\n } else if (label === tl.jsxTagStart) {\n newToken.type = \"Punctuator\";\n newToken.value = \"<\";\n } else if (label === tl.jsxTagEnd) {\n newToken.type = \"Punctuator\";\n newToken.value = \">\";\n } else if (label === tl.jsxName) {\n newToken.type = \"JSXIdentifier\";\n } else if (label === tl.jsxText) {\n newToken.type = \"JSXText\";\n } else if (type.keyword === \"null\") {\n newToken.type = \"Null\";\n } else if (type.keyword === \"false\" || type.keyword === \"true\") {\n newToken.type = \"Boolean\";\n } else if (type.keyword) {\n newToken.type = \"Keyword\";\n } else if (label === tl.num) {\n newToken.type = \"Numeric\";\n newToken.value = source.slice(token.start, token.end);\n } else if (label === tl.string) {\n newToken.type = \"String\";\n newToken.value = source.slice(token.start, token.end);\n } else if (label === tl.regexp) {\n newToken.type = \"RegularExpression\";\n const value = token.value;\n newToken.regex = {\n pattern: value.pattern,\n flags: value.flags,\n };\n newToken.value = `/${value.pattern}/${value.flags}`;\n } else if (label === tl.bigint) {\n newToken.type = \"Numeric\";\n newToken.value = `${token.value}n`;\n } else if (label === tl.privateName) {\n newToken.type = \"PrivateIdentifier\";\n } else if (\n label === tl.templateNonTail ||\n label === tl.templateTail ||\n label === tl.Template\n ) {\n newToken.type = \"Template\";\n }\n if (!process.env.IS_PUBLISH) {\n // To minimize the jest-diff noise comparing Babel AST and third-party AST,\n // here we generate a deep copy of loc without identifierName and index\n newToken.loc = {\n end: {\n column: newToken.loc.end.column,\n line: newToken.loc.end.line,\n },\n start: {\n column: newToken.loc.start.column,\n line: newToken.loc.start.line,\n },\n } as any;\n }\n return newToken;\n}\n\nexport = function convertTokens(\n tokens: BabelToken[],\n code: string,\n tokLabels: Record,\n) {\n const result = [];\n const templateTypeMergedTokens = process.env.BABEL_8_BREAKING\n ? tokens\n : convertTemplateType(tokens, tokLabels);\n // The last token is always tt.eof and should be skipped\n for (let i = 0, { length } = templateTypeMergedTokens; i < length - 1; i++) {\n const token = templateTypeMergedTokens[i];\n const tokenType = token.type;\n if (tokenType === \"CommentLine\" || tokenType === \"CommentBlock\") {\n continue;\n }\n\n if (!process.env.BABEL_8_BREAKING) {\n // Babel 8 already produces a single token\n\n if (\n ESLINT_VERSION >= 8 &&\n i + 1 < length &&\n tokenType.label === tokLabels.hash\n ) {\n const nextToken = templateTypeMergedTokens[i + 1];\n\n // We must disambiguate private identifier from the hack pipes topic token\n if (\n nextToken.type.label === tokLabels.name &&\n token.end === nextToken.start\n ) {\n i++;\n\n nextToken.type = \"PrivateIdentifier\";\n nextToken.start -= 1;\n nextToken.loc.start.column -= 1;\n nextToken.range = [nextToken.start, nextToken.end];\n\n result.push(nextToken);\n continue;\n }\n }\n }\n\n result.push(convertToken(token, code, tokLabels));\n }\n\n return result;\n};\n"],"mappings":"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","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/convert/index.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/index.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/index.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,25 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.convertError = convertError; +exports.convertFile = convertFile; +const convertTokens = require("./convertTokens.cjs"); +const convertComments = require("./convertComments.cjs"); +const convertAST = require("./convertAST.cjs"); +function convertFile(ast, code, tokLabels, visitorKeys) { + ast.tokens = convertTokens(ast.tokens, code, tokLabels); + convertComments(ast.comments); + convertAST(ast, visitorKeys); + return ast; +} +function convertError(err) { + if (err instanceof SyntaxError) { + err.lineNumber = err.loc.line; + err.column = err.loc.column; + } + return err; +} + +//# sourceMappingURL=index.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/convert/index.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/convert/index.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/convert/index.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["convertTokens","require","convertComments","convertAST","convertFile","ast","code","tokLabels","visitorKeys","tokens","comments","convertError","err","SyntaxError","lineNumber","loc","line","column"],"sources":["../../src/convert/index.cts"],"sourcesContent":["import convertTokens = require(\"./convertTokens.cts\");\nimport convertComments = require(\"./convertComments.cts\");\nimport convertAST = require(\"./convertAST.cts\");\nimport type { AST, ParseResult } from \"../types.cts\";\n\nexport function convertFile(\n ast: ParseResult,\n code: string,\n tokLabels: Record,\n visitorKeys: Record,\n) {\n ast.tokens = convertTokens(ast.tokens as any, code, tokLabels);\n convertComments(ast.comments);\n convertAST(ast, visitorKeys);\n return ast as unknown as AST.Program;\n}\n\nexport function convertError(err: Error) {\n if (err instanceof SyntaxError) {\n // @ts-expect-error eslint\n err.lineNumber = err.loc.line;\n // @ts-expect-error eslint\n err.column = err.loc.column;\n }\n return err;\n}\n"],"mappings":";;;;;;;MAAOA,aAAa,GAAAC,OAAA,CAAW,qBAAqB;AAAA,MAC7CC,eAAe,GAAAD,OAAA,CAAW,uBAAuB;AAAA,MACjDE,UAAU,GAAAF,OAAA,CAAW,kBAAkB;AAGvC,SAASG,WAAWA,CACzBC,GAAgB,EAChBC,IAAY,EACZC,SAA8B,EAC9BC,WAAqC,EACrC;EACAH,GAAG,CAACI,MAAM,GAAGT,aAAa,CAACK,GAAG,CAACI,MAAM,EAASH,IAAI,EAAEC,SAAS,CAAC;EAC9DL,eAAe,CAACG,GAAG,CAACK,QAAQ,CAAC;EAC7BP,UAAU,CAACE,GAAG,EAAEG,WAAW,CAAC;EAC5B,OAAOH,GAAG;AACZ;AAEO,SAASM,YAAYA,CAACC,GAAU,EAAE;EACvC,IAAIA,GAAG,YAAYC,WAAW,EAAE;IAE9BD,GAAG,CAACE,UAAU,GAAGF,GAAG,CAACG,GAAG,CAACC,IAAI;IAE7BJ,GAAG,CAACK,MAAM,GAAGL,GAAG,CAACG,GAAG,CAACE,MAAM;EAC7B;EACA,OAAOL,GAAG;AACZ","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/experimental-worker.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/experimental-worker.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/experimental-worker.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,32 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.meta = void 0; +exports.parseForESLint = parseForESLint; +const [major, minor] = process.versions.node.split(".").map(Number); +if (major < 12 || major === 12 && minor < 3) { + throw new Error("@babel/eslint-parser/experimental-worker requires Node.js >= 12.3.0"); +} +const normalizeESLintConfig = require("./configuration.cjs"); +const analyzeScope = require("./analyze-scope.cjs"); +const baseParse = require("./parse.cjs"); +const Clients = require("./client.cjs"); +const client = new Clients.WorkerClient(); +const meta = exports.meta = { + name: "@babel/eslint-parser/experimental-worker", + version: "7.28.6" +}; +function parseForESLint(code, options = {}) { + const normalizedOptions = normalizeESLintConfig(options); + const ast = baseParse(code, normalizedOptions, client); + const scopeManager = analyzeScope(ast, normalizedOptions, client); + return { + ast, + scopeManager, + visitorKeys: client.getVisitorKeys() + }; +} + +//# sourceMappingURL=experimental-worker.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/experimental-worker.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/experimental-worker.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/experimental-worker.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["major","minor","process","versions","node","split","map","Number","Error","normalizeESLintConfig","require","analyzeScope","baseParse","Clients","client","WorkerClient","meta","exports","name","version","parseForESLint","code","options","normalizedOptions","ast","scopeManager","visitorKeys","getVisitorKeys"],"sources":["../src/experimental-worker.cts"],"sourcesContent":["const [major, minor] = process.versions.node.split(\".\").map(Number);\n\nif (major < 12 || (major === 12 && minor < 3)) {\n throw new Error(\n \"@babel/eslint-parser/experimental-worker requires Node.js >= 12.3.0\",\n );\n}\n\nimport normalizeESLintConfig = require(\"./configuration.cts\");\nimport analyzeScope = require(\"./analyze-scope.cts\");\nimport baseParse = require(\"./parse.cts\");\n\nimport Clients = require(\"./client.cts\");\n\nconst client = new Clients.WorkerClient();\n\nexport const meta = {\n name: \"@babel/eslint-parser/experimental-worker\",\n version: PACKAGE_JSON.version,\n};\n\nexport function parseForESLint(code: string, options = {}) {\n const normalizedOptions = normalizeESLintConfig(options);\n const ast = baseParse(code, normalizedOptions, client);\n const scopeManager = analyzeScope(ast, normalizedOptions, client);\n\n return { ast, scopeManager, visitorKeys: client.getVisitorKeys() };\n}\n"],"mappings":";;;;;;;AAAA,MAAM,CAACA,KAAK,EAAEC,KAAK,CAAC,GAAGC,OAAO,CAACC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,GAAG,CAAC,CAACC,GAAG,CAACC,MAAM,CAAC;AAEnE,IAAIP,KAAK,GAAG,EAAE,IAAKA,KAAK,KAAK,EAAE,IAAIC,KAAK,GAAG,CAAE,EAAE;EAC7C,MAAM,IAAIO,KAAK,CACb,qEACF,CAAC;AACH;AAAC,MAEMC,qBAAqB,GAAAC,OAAA,CAAW,qBAAqB;AAAA,MACrDC,YAAY,GAAAD,OAAA,CAAW,qBAAqB;AAAA,MAC5CE,SAAS,GAAAF,OAAA,CAAW,aAAa;AAAA,MAEjCG,OAAO,GAAAH,OAAA,CAAW,cAAc;AAEvC,MAAMI,MAAM,GAAG,IAAID,OAAO,CAACE,YAAY,CAAC,CAAC;AAElC,MAAMC,IAAI,GAAAC,OAAA,CAAAD,IAAA,GAAG;EAClBE,IAAI,EAAE,0CAA0C;EAChDC,OAAO;AACT,CAAC;AAEM,SAASC,cAAcA,CAACC,IAAY,EAAEC,OAAO,GAAG,CAAC,CAAC,EAAE;EACzD,MAAMC,iBAAiB,GAAGd,qBAAqB,CAACa,OAAO,CAAC;EACxD,MAAME,GAAG,GAAGZ,SAAS,CAACS,IAAI,EAAEE,iBAAiB,EAAET,MAAM,CAAC;EACtD,MAAMW,YAAY,GAAGd,YAAY,CAACa,GAAG,EAAED,iBAAiB,EAAET,MAAM,CAAC;EAEjE,OAAO;IAAEU,GAAG;IAAEC,YAAY;IAAEC,WAAW,EAAEZ,MAAM,CAACa,cAAc,CAAC;EAAE,CAAC;AACpE","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/index.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/index.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/index.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,32 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.meta = void 0; +exports.parse = parse; +exports.parseForESLint = parseForESLint; +var _client = require("./client.cjs"); +const normalizeESLintConfig = require("./configuration.cjs"); +const analyzeScope = require("./analyze-scope.cjs"); +const baseParse = require("./parse.cjs"); +const client = new _client.LocalClient(); +const meta = exports.meta = { + name: "@babel/eslint-parser", + version: "7.28.6" +}; +function parse(code, options = {}) { + return baseParse(code, normalizeESLintConfig(options), client); +} +function parseForESLint(code, options = {}) { + const normalizedOptions = normalizeESLintConfig(options); + const ast = baseParse(code, normalizedOptions, client); + const scopeManager = analyzeScope(ast, normalizedOptions, client); + return { + ast, + scopeManager, + visitorKeys: client.getVisitorKeys() + }; +} + +//# sourceMappingURL=index.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/index.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/index.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/index.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["_client","require","normalizeESLintConfig","analyzeScope","baseParse","client","LocalClient","meta","exports","name","version","parse","code","options","parseForESLint","normalizedOptions","ast","scopeManager","visitorKeys","getVisitorKeys"],"sources":["../src/index.cts"],"sourcesContent":["import normalizeESLintConfig = require(\"./configuration.cts\");\nimport analyzeScope = require(\"./analyze-scope.cts\");\nimport baseParse = require(\"./parse.cts\");\n\n// @ts-expect-error LocalClient only exists in the cjs build\nimport { LocalClient, WorkerClient } from \"./client.cts\";\nconst client = new (USE_ESM ? WorkerClient : LocalClient)();\n\nexport const meta = {\n name: PACKAGE_JSON.name,\n version: PACKAGE_JSON.version,\n};\n\nexport function parse(code: string, options = {}) {\n return baseParse(code, normalizeESLintConfig(options), client);\n}\n\nexport function parseForESLint(code: string, options = {}) {\n const normalizedOptions = normalizeESLintConfig(options);\n const ast = baseParse(code, normalizedOptions, client);\n const scopeManager = analyzeScope(ast, normalizedOptions, client);\n\n return { ast, scopeManager, visitorKeys: client.getVisitorKeys() };\n}\n"],"mappings":";;;;;;;;AAKA,IAAAA,OAAA,GAAAC,OAAA;AAAyD,MALlDC,qBAAqB,GAAAD,OAAA,CAAW,qBAAqB;AAAA,MACrDE,YAAY,GAAAF,OAAA,CAAW,qBAAqB;AAAA,MAC5CG,SAAS,GAAAH,OAAA,CAAW,aAAa;AAIxC,MAAMI,MAAM,GAAG,IAA8BC,mBAAW,CAAE,CAAC;AAEpD,MAAMC,IAAI,GAAAC,OAAA,CAAAD,IAAA,GAAG;EAClBE,IAAI,wBAAmB;EACvBC,OAAO;AACT,CAAC;AAEM,SAASC,KAAKA,CAACC,IAAY,EAAEC,OAAO,GAAG,CAAC,CAAC,EAAE;EAChD,OAAOT,SAAS,CAACQ,IAAI,EAAEV,qBAAqB,CAACW,OAAO,CAAC,EAAER,MAAM,CAAC;AAChE;AAEO,SAASS,cAAcA,CAACF,IAAY,EAAEC,OAAO,GAAG,CAAC,CAAC,EAAE;EACzD,MAAME,iBAAiB,GAAGb,qBAAqB,CAACW,OAAO,CAAC;EACxD,MAAMG,GAAG,GAAGZ,SAAS,CAACQ,IAAI,EAAEG,iBAAiB,EAAEV,MAAM,CAAC;EACtD,MAAMY,YAAY,GAAGd,YAAY,CAACa,GAAG,EAAED,iBAAiB,EAAEV,MAAM,CAAC;EAEjE,OAAO;IAAEW,GAAG;IAAEC,YAAY;IAAEC,WAAW,EAAEb,MAAM,CAACc,cAAc,CAAC;EAAE,CAAC;AACpE","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/parse.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/parse.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/parse.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,37 @@ +"use strict"; + +const semver = require("semver"); +const convert = require("./convert/index.cjs"); +const babelParser = require((((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, { + paths: [b] +}, M = require("module")) => { + let f = M._findPath(r, M._nodeModulePaths(b).concat(b)); + if (f) return f; + f = new Error(`Cannot resolve module '${r}'`); + f.code = "MODULE_NOT_FOUND"; + throw f; +})("@babel/parser", { + paths: [require.resolve("@babel/core/package.json")] +})); +let isRunningMinSupportedCoreVersion = null; +module.exports = function parse(code, options, client) { + const minSupportedCoreVersion = ">=7.2.0"; + if (typeof isRunningMinSupportedCoreVersion !== "boolean") { + isRunningMinSupportedCoreVersion = semver.satisfies(client.getVersion(), minSupportedCoreVersion); + } + if (!isRunningMinSupportedCoreVersion) { + throw new Error(`@babel/eslint-parser@${"7.28.6"} does not support @babel/core@${client.getVersion()}. Please upgrade to @babel/core@${minSupportedCoreVersion}.`); + } + const { + ast, + parserOptions + } = client.maybeParse(code, options); + if (ast) return ast; + try { + return convert.convertFile(babelParser.parse(code, parserOptions), code, client.getTokLabels(), client.getVisitorKeys()); + } catch (err) { + throw convert.convertError(err); + } +}; + +//# sourceMappingURL=parse.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/parse.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/parse.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/parse.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["semver","require","convert","babelParser","v","w","split","process","versions","node","resolve","r","paths","b","M","f","_findPath","_nodeModulePaths","concat","Error","code","isRunningMinSupportedCoreVersion","module","exports","parse","options","client","minSupportedCoreVersion","satisfies","getVersion","ast","parserOptions","maybeParse","convertFile","getTokLabels","getVisitorKeys","err","convertError"],"sources":["../src/parse.cts"],"sourcesContent":["\"use strict\";\n\nimport semver = require(\"semver\");\nimport convert = require(\"./convert/index.cts\");\nimport type { Options } from \"./types.cts\";\nimport type { Client } from \"./client.cts\";\n\nconst babelParser = require(\n require.resolve(\"@babel/parser\", {\n paths: [require.resolve(\"@babel/core/package.json\")],\n }),\n);\n\nlet isRunningMinSupportedCoreVersion: boolean = null;\n\nexport = function parse(code: string, options: Options, client: Client) {\n // Ensure we're using a version of `@babel/core` that includes `parse()` and `tokTypes`.\n const minSupportedCoreVersion = REQUIRED_VERSION(\">=7.2.0\");\n\n if (typeof isRunningMinSupportedCoreVersion !== \"boolean\") {\n isRunningMinSupportedCoreVersion = semver.satisfies(\n client.getVersion(),\n minSupportedCoreVersion,\n );\n }\n\n if (!isRunningMinSupportedCoreVersion) {\n throw new Error(\n `@babel/eslint-parser@${\n PACKAGE_JSON.version\n } does not support @babel/core@${client.getVersion()}. Please upgrade to @babel/core@${minSupportedCoreVersion}.`,\n );\n }\n\n const { ast, parserOptions } = client.maybeParse(code, options);\n\n if (ast) return ast;\n\n try {\n return convert.convertFile(\n babelParser.parse(code, parserOptions),\n code,\n client.getTokLabels(),\n client.getVisitorKeys(),\n );\n } catch (err) {\n throw convert.convertError(err);\n }\n};\n"],"mappings":"AAAA,YAAY;;AAAC,MAENA,MAAM,GAAAC,OAAA,CAAW,QAAQ;AAAA,MACzBC,OAAO,GAAAD,OAAA,CAAW,qBAAqB;AAI9C,MAAME,WAAW,GAAGF,OAAO,CACzB,GAAAG,CAAA,EAAAC,CAAA,MAAAD,CAAA,GAAAA,CAAA,CAAAE,KAAA,OAAAD,CAAA,GAAAA,CAAA,CAAAC,KAAA,QAAAF,CAAA,OAAAC,CAAA,OAAAD,CAAA,OAAAC,CAAA,QAAAD,CAAA,QAAAC,CAAA,MAAAE,OAAA,CAAAC,QAAA,CAAAC,IAAA,WAAAR,OAAA,CAAAS,OAAA,IAAAC,CAAA;EAAAC,KAAA,GAAAC,CAAA;AAAA,GAAAC,CAAA,GAAAb,OAAA;EAAA,IAAAc,CAAA,GAAAD,CAAA,CAAAE,SAAA,CAAAL,CAAA,EAAAG,CAAA,CAAAG,gBAAA,CAAAJ,CAAA,EAAAK,MAAA,CAAAL,CAAA;EAAA,IAAAE,CAAA,SAAAA,CAAA;EAAAA,CAAA,OAAAI,KAAA,2BAAAR,CAAA;EAAAI,CAAA,CAAAK,IAAA;EAAA,MAAAL,CAAA;AAAA,GAAgB,eAAe,EAAE;EAC/BH,KAAK,EAAE,CAACX,OAAO,CAACS,OAAO,CAAC,0BAA0B,CAAC;AACrD,CAAC,CACH,CAAC;AAED,IAAIW,gCAAyC,GAAG,IAAI;AAACC,MAAA,CAAAC,OAAA,GAE5C,SAASC,KAAKA,CAACJ,IAAY,EAAEK,OAAgB,EAAEC,MAAc,EAAE;EAEtE,MAAMC,uBAAuB,GAAoB,SAAU;EAE3D,IAAI,OAAON,gCAAgC,KAAK,SAAS,EAAE;IACzDA,gCAAgC,GAAGrB,MAAM,CAAC4B,SAAS,CACjDF,MAAM,CAACG,UAAU,CAAC,CAAC,EACnBF,uBACF,CAAC;EACH;EAEA,IAAI,CAACN,gCAAgC,EAAE;IACrC,MAAM,IAAIF,KAAK,CACb,iEAEiCO,MAAM,CAACG,UAAU,CAAC,CAAC,mCAAmCF,uBAAuB,GAChH,CAAC;EACH;EAEA,MAAM;IAAEG,GAAG;IAAEC;EAAc,CAAC,GAAGL,MAAM,CAACM,UAAU,CAACZ,IAAI,EAAEK,OAAO,CAAC;EAE/D,IAAIK,GAAG,EAAE,OAAOA,GAAG;EAEnB,IAAI;IACF,OAAO5B,OAAO,CAAC+B,WAAW,CACxB9B,WAAW,CAACqB,KAAK,CAACJ,IAAI,EAAEW,aAAa,CAAC,EACtCX,IAAI,EACJM,MAAM,CAACQ,YAAY,CAAC,CAAC,EACrBR,MAAM,CAACS,cAAc,CAAC,CACxB,CAAC;EACH,CAAC,CAAC,OAAOC,GAAG,EAAE;IACZ,MAAMlC,OAAO,CAACmC,YAAY,CAACD,GAAG,CAAC;EACjC;AACF,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,5 @@ +"use strict"; + +module.exports = parseInt(require("eslint/package.json").version, 10); + +//# sourceMappingURL=eslint-version.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/utils/eslint-version.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["parseInt","require","version"],"sources":["../../src/utils/eslint-version.cts"],"sourcesContent":["export = parseInt(require(\"eslint/package.json\").version, 10);\n"],"mappings":";;iBAASA,QAAQ,CAACC,OAAO,CAAC,qBAAqB,CAAC,CAACC,OAAO,EAAE,EAAE,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,38 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getTokLabels = getTokLabels; +exports.getVisitorKeys = getVisitorKeys; +const _ESLINT_VISITOR_KEYS = require("eslint-visitor-keys"); +const babel = require("./babel-core.cjs"); +const ESLINT_VISITOR_KEYS = _ESLINT_VISITOR_KEYS.KEYS; +let visitorKeys; +function getVisitorKeys() { + if (!visitorKeys) { + const newTypes = { + ChainExpression: ESLINT_VISITOR_KEYS.ChainExpression, + ImportExpression: ESLINT_VISITOR_KEYS.ImportExpression, + Literal: ESLINT_VISITOR_KEYS.Literal, + MethodDefinition: ["decorators"].concat(ESLINT_VISITOR_KEYS.MethodDefinition), + Property: ["decorators"].concat(ESLINT_VISITOR_KEYS.Property), + PropertyDefinition: ["decorators", "typeAnnotation"].concat(ESLINT_VISITOR_KEYS.PropertyDefinition) + }; + const conflictTypes = { + ExportAllDeclaration: ESLINT_VISITOR_KEYS.ExportAllDeclaration + }; + visitorKeys = Object.assign({}, newTypes, babel.types.VISITOR_KEYS, conflictTypes, { + ClassPrivateMethod: ["decorators"].concat(ESLINT_VISITOR_KEYS.MethodDefinition) + }); + } + return visitorKeys; +} +let tokLabels; +function getTokLabels() { + return tokLabels || (tokLabels = (p => p.reduce((o, [k, v]) => Object.assign({}, o, { + [k]: v + }), {}))((Object.entries || (o => Object.keys(o).map(k => [k, o[k]])))(babel.tokTypes).map(([key, tok]) => [key, tok.label]))); +} + +//# sourceMappingURL=ast-info.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/ast-info.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["_ESLINT_VISITOR_KEYS","require","babel","ESLINT_VISITOR_KEYS","KEYS","visitorKeys","getVisitorKeys","newTypes","ChainExpression","ImportExpression","Literal","MethodDefinition","concat","Property","PropertyDefinition","conflictTypes","ExportAllDeclaration","Object","assign","types","VISITOR_KEYS","ClassPrivateMethod","tokLabels","getTokLabels","p","reduce","o","k","v","entries","keys","map","tokTypes","key","tok","label"],"sources":["../../src/worker/ast-info.cts"],"sourcesContent":["// @ts-expect-error no types\nimport _ESLINT_VISITOR_KEYS = require(\"eslint-visitor-keys\");\nimport babel = require(\"./babel-core.cts\");\n\nconst ESLINT_VISITOR_KEYS = _ESLINT_VISITOR_KEYS.KEYS;\n\nlet visitorKeys: Record;\nexport function getVisitorKeys() {\n if (!visitorKeys) {\n // AST Types that are not presented in Babel AST\n const newTypes = {\n ChainExpression: ESLINT_VISITOR_KEYS.ChainExpression,\n ImportExpression: ESLINT_VISITOR_KEYS.ImportExpression,\n Literal: ESLINT_VISITOR_KEYS.Literal,\n MethodDefinition: [\"decorators\"].concat(\n ESLINT_VISITOR_KEYS.MethodDefinition,\n ),\n Property: [\"decorators\"].concat(ESLINT_VISITOR_KEYS.Property),\n PropertyDefinition: [\"decorators\", \"typeAnnotation\"].concat(\n ESLINT_VISITOR_KEYS.PropertyDefinition,\n ),\n };\n\n // AST Types that shares `\"type\"` property with Babel but have different shape\n const conflictTypes = {\n ExportAllDeclaration: ESLINT_VISITOR_KEYS.ExportAllDeclaration,\n };\n\n visitorKeys = {\n ...newTypes,\n ...babel.types.VISITOR_KEYS,\n ...conflictTypes,\n ...(process.env.BABEL_8_BREAKING\n ? {}\n : {\n ClassPrivateMethod: [\"decorators\"].concat(\n ESLINT_VISITOR_KEYS.MethodDefinition,\n ),\n }),\n };\n }\n return visitorKeys;\n}\n\nlet tokLabels;\nexport function getTokLabels() {\n return (tokLabels ||= (\n process.env.BABEL_8_BREAKING\n ? Object.fromEntries\n : (p: any[]) => p.reduce((o, [k, v]) => ({ ...o, [k]: v }), {})\n )(Object.entries(babel.tokTypes).map(([key, tok]) => [key, tok.label])));\n}\n"],"mappings":";;;;;;;MACOA,oBAAoB,GAAAC,OAAA,CAAW,qBAAqB;AAAA,MACpDC,KAAK,GAAAD,OAAA,CAAW,kBAAkB;AAEzC,MAAME,mBAAmB,GAAGH,oBAAoB,CAACI,IAAI;AAErD,IAAIC,WAAqC;AAClC,SAASC,cAAcA,CAAA,EAAG;EAC/B,IAAI,CAACD,WAAW,EAAE;IAEhB,MAAME,QAAQ,GAAG;MACfC,eAAe,EAAEL,mBAAmB,CAACK,eAAe;MACpDC,gBAAgB,EAAEN,mBAAmB,CAACM,gBAAgB;MACtDC,OAAO,EAAEP,mBAAmB,CAACO,OAAO;MACpCC,gBAAgB,EAAE,CAAC,YAAY,CAAC,CAACC,MAAM,CACrCT,mBAAmB,CAACQ,gBACtB,CAAC;MACDE,QAAQ,EAAE,CAAC,YAAY,CAAC,CAACD,MAAM,CAACT,mBAAmB,CAACU,QAAQ,CAAC;MAC7DC,kBAAkB,EAAE,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAACF,MAAM,CACzDT,mBAAmB,CAACW,kBACtB;IACF,CAAC;IAGD,MAAMC,aAAa,GAAG;MACpBC,oBAAoB,EAAEb,mBAAmB,CAACa;IAC5C,CAAC;IAEDX,WAAW,GAAAY,MAAA,CAAAC,MAAA,KACNX,QAAQ,EACRL,KAAK,CAACiB,KAAK,CAACC,YAAY,EACxBL,aAAa,EAGZ;MACEM,kBAAkB,EAAE,CAAC,YAAY,CAAC,CAACT,MAAM,CACvCT,mBAAmB,CAACQ,gBACtB;IACF,CAAC,CACN;EACH;EACA,OAAON,WAAW;AACpB;AAEA,IAAIiB,SAAS;AACN,SAASC,YAAYA,CAAA,EAAG;EAC7B,OAAQD,SAAS,KAATA,SAAS,GAAK,CAGfE,CAAQ,IAAKA,CAAC,CAACC,MAAM,CAAC,CAACC,CAAC,EAAE,CAACC,CAAC,EAAEC,CAAC,CAAC,KAAAX,MAAA,CAAAC,MAAA,KAAWQ,CAAC;IAAE,CAACC,CAAC,GAAGC;EAAC,EAAG,EAAE,CAAC,CAAC,CAAC,EACjE,CAAAX,MAAA,CAAAY,OAAA,KAAAH,CAAA,IAAAT,MAAA,CAAAa,IAAA,CAAAJ,CAAA,EAAAK,GAAA,CAAAJ,CAAA,KAAAA,CAAA,EAAAD,CAAA,CAAAC,CAAA,MAAezB,KAAK,CAAC8B,QAAQ,CAAC,CAACD,GAAG,CAAC,CAAC,CAACE,GAAG,EAAEC,GAAG,CAAC,KAAK,CAACD,GAAG,EAAEC,GAAG,CAACC,KAAK,CAAC,CAAC,CAAC;AACzE","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,19 @@ +"use strict"; + +module.exports = exports; +function initialize(babel) { + exports.init = null; + exports.version = babel.version; + exports.traverse = babel.traverse; + exports.types = babel.types; + exports.tokTypes = babel.tokTypes; + exports.parseSync = babel.parseSync; + exports.parseAsync = babel.parseAsync; + exports.loadPartialConfigSync = babel.loadPartialConfigSync; + exports.loadPartialConfigAsync = babel.loadPartialConfigAsync; + exports.createConfigItemAsync = babel.createConfigItemAsync; + exports.createConfigItemSync = babel.createConfigItemSync || babel.createConfigItem; +} +initialize(require("@babel/core")); + +//# sourceMappingURL=babel-core.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/babel-core.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["exports","initialize","babel","init","version","traverse","types","tokTypes","parseSync","parseAsync","loadPartialConfigSync","loadPartialConfigAsync","createConfigItemAsync","createConfigItemSync","createConfigItem","require"],"sources":["../../src/worker/babel-core.cts"],"sourcesContent":["export = exports as typeof import(\"@babel/core\") & {\n init: Promise | null;\n};\n\nfunction initialize(babel: typeof import(\"@babel/core\")) {\n exports.init = null;\n exports.version = babel.version;\n exports.traverse = babel.traverse;\n exports.types = babel.types;\n exports.tokTypes = babel.tokTypes;\n exports.parseSync = babel.parseSync;\n exports.parseAsync = babel.parseAsync;\n exports.loadPartialConfigSync = babel.loadPartialConfigSync;\n exports.loadPartialConfigAsync = babel.loadPartialConfigAsync;\n exports.createConfigItemAsync = babel.createConfigItemAsync;\n\n if (process.env.BABEL_8_BREAKING) {\n exports.createConfigItemSync = babel.createConfigItemSync;\n } else {\n // babel.createConfigItemSync is available on 7.13+\n // we support Babel 7.11+\n exports.createConfigItemSync =\n babel.createConfigItemSync || babel.createConfigItem;\n }\n}\n\nif (USE_ESM) {\n exports.init = import(\"@babel/core\").then(initialize);\n} else {\n initialize(require(\"@babel/core\"));\n}\n"],"mappings":";;iBAASA,OAAO;AAIhB,SAASC,UAAUA,CAACC,KAAmC,EAAE;EACvDF,OAAO,CAACG,IAAI,GAAG,IAAI;EACnBH,OAAO,CAACI,OAAO,GAAGF,KAAK,CAACE,OAAO;EAC/BJ,OAAO,CAACK,QAAQ,GAAGH,KAAK,CAACG,QAAQ;EACjCL,OAAO,CAACM,KAAK,GAAGJ,KAAK,CAACI,KAAK;EAC3BN,OAAO,CAACO,QAAQ,GAAGL,KAAK,CAACK,QAAQ;EACjCP,OAAO,CAACQ,SAAS,GAAGN,KAAK,CAACM,SAAS;EACnCR,OAAO,CAACS,UAAU,GAAGP,KAAK,CAACO,UAAU;EACrCT,OAAO,CAACU,qBAAqB,GAAGR,KAAK,CAACQ,qBAAqB;EAC3DV,OAAO,CAACW,sBAAsB,GAAGT,KAAK,CAACS,sBAAsB;EAC7DX,OAAO,CAACY,qBAAqB,GAAGV,KAAK,CAACU,qBAAqB;EAOzDZ,OAAO,CAACa,oBAAoB,GAC1BX,KAAK,CAACW,oBAAoB,IAAIX,KAAK,CAACY,gBAAgB;AAE1D;AAKEb,UAAU,CAACc,OAAO,CAAC,aAAa,CAAC,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/configuration.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/configuration.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/configuration.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,99 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.normalizeBabelParseConfig = normalizeBabelParseConfig; +exports.normalizeBabelParseConfigSync = normalizeBabelParseConfigSync; +function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); } +function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; } +const babel = require("./babel-core.cjs"); +const semver = require("semver"); +const ESLINT_VERSION = require("../utils/eslint-version.cjs"); +function getParserPlugins(babelOptions) { + var _babelOptions$parserO, _babelOptions$parserO2; + const babelParserPlugins = (_babelOptions$parserO = (_babelOptions$parserO2 = babelOptions.parserOpts) == null ? void 0 : _babelOptions$parserO2.plugins) != null ? _babelOptions$parserO : []; + const estreeOptions = { + classFeatures: ESLINT_VERSION >= 8 + }; + for (const plugin of babelParserPlugins) { + if (Array.isArray(plugin) && plugin[0] === "estree") { + Object.assign(estreeOptions, plugin[1]); + break; + } + } + return [["estree", estreeOptions], ...babelParserPlugins]; +} +function normalizeParserOptions(options, version) { + var _options$allowImportE, _options$ecmaFeatures2, _options$ecmaFeatures3; + if (options.sourceType === "commonjs" && !semver.satisfies(version, ">=7.28.0")) { + var _options$ecmaFeatures; + options.sourceType = "script"; + options.ecmaFeatures = Object.assign({}, (_options$ecmaFeatures = options.ecmaFeatures) != null ? _options$ecmaFeatures : {}, { + globalReturn: true + }); + } + return Object.assign({ + sourceType: options.sourceType, + filename: options.filePath + }, options.babelOptions, { + parserOpts: Object.assign({}, { + allowImportExportEverywhere: (_options$allowImportE = options.allowImportExportEverywhere) != null ? _options$allowImportE : false, + allowSuperOutsideMethod: true + }, options.sourceType !== "commonjs" ? { + allowReturnOutsideFunction: (_options$ecmaFeatures2 = (_options$ecmaFeatures3 = options.ecmaFeatures) == null ? void 0 : _options$ecmaFeatures3.globalReturn) != null ? _options$ecmaFeatures2 : true + } : {}, options.babelOptions.parserOpts, { + plugins: getParserPlugins(options.babelOptions), + attachComment: false, + ranges: true, + tokens: true + }), + caller: Object.assign({ + name: "@babel/eslint-parser" + }, options.babelOptions.caller) + }); +} +function validateResolvedConfig(config, options, parseOptions) { + if (config !== null) { + if (options.requireConfigFile !== false) { + if (!config.hasFilesystemConfig()) { + let error = `No Babel config file detected for ${config.options.filename}. Either disable config file checking with requireConfigFile: false, or configure Babel so that it can find the config files.`; + if (config.options.filename.includes("node_modules")) { + error += `\nIf you have a .babelrc.js file or use package.json#babel, keep in mind that it's not used when parsing dependencies. If you want your config to be applied to your whole app, consider using babel.config.js or babel.config.json instead.`; + } + throw new Error(error); + } + } + if (config.options) return config.options; + } + return getDefaultParserOptions(parseOptions); +} +function getDefaultParserOptions(options) { + return Object.assign({ + plugins: [] + }, options, { + babelrc: false, + configFile: false, + browserslistConfigFile: false, + ignore: null, + only: null + }); +} +function normalizeBabelParseConfig(_x) { + return _normalizeBabelParseConfig.apply(this, arguments); +} +function _normalizeBabelParseConfig() { + _normalizeBabelParseConfig = _asyncToGenerator(function* (options) { + const parseOptions = normalizeParserOptions(options, babel.version); + const config = yield babel.loadPartialConfigAsync(parseOptions); + return validateResolvedConfig(config, options, parseOptions); + }); + return _normalizeBabelParseConfig.apply(this, arguments); +} +function normalizeBabelParseConfigSync(options) { + const parseOptions = normalizeParserOptions(options, babel.version); + const config = babel.loadPartialConfigSync(parseOptions); + return validateResolvedConfig(config, options, parseOptions); +} + +//# sourceMappingURL=configuration.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/configuration.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/configuration.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/configuration.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["babel","require","semver","ESLINT_VERSION","getParserPlugins","babelOptions","_babelOptions$parserO","_babelOptions$parserO2","babelParserPlugins","parserOpts","plugins","estreeOptions","classFeatures","plugin","Array","isArray","Object","assign","normalizeParserOptions","options","version","_options$allowImportE","_options$ecmaFeatures2","_options$ecmaFeatures3","sourceType","satisfies","_options$ecmaFeatures","ecmaFeatures","globalReturn","filename","filePath","allowImportExportEverywhere","allowSuperOutsideMethod","allowReturnOutsideFunction","attachComment","ranges","tokens","caller","name","validateResolvedConfig","config","parseOptions","requireConfigFile","hasFilesystemConfig","error","includes","Error","getDefaultParserOptions","babelrc","configFile","browserslistConfigFile","ignore","only","normalizeBabelParseConfig","_x","_normalizeBabelParseConfig","apply","arguments","_asyncToGenerator","loadPartialConfigAsync","normalizeBabelParseConfigSync","loadPartialConfigSync"],"sources":["../../src/worker/configuration.cts"],"sourcesContent":["import babel = require(\"./babel-core.cts\");\nimport semver = require(\"semver\");\nimport ESLINT_VERSION = require(\"../utils/eslint-version.cts\");\nimport type { InputOptions, NormalizedOptions } from \"@babel/core\";\nimport type { Options } from \"../types.cts\";\nimport type { PartialConfig } from \"../../../../packages/babel-core/src/config\";\n\n/**\n * Merge user supplied estree plugin options to default estree plugin options\n *\n * @returns {Array} Merged parser plugin descriptors\n */\nfunction getParserPlugins(\n babelOptions: InputOptions,\n): InputOptions[\"parserOpts\"][\"plugins\"] {\n const babelParserPlugins = babelOptions.parserOpts?.plugins ?? [];\n const estreeOptions = { classFeatures: ESLINT_VERSION >= 8 };\n for (const plugin of babelParserPlugins) {\n if (Array.isArray(plugin) && plugin[0] === \"estree\") {\n Object.assign(estreeOptions, plugin[1]);\n break;\n }\n }\n // estree must be the first parser plugin to work with other parser plugins\n return [[\"estree\", estreeOptions], ...babelParserPlugins];\n}\n\nfunction normalizeParserOptions(\n options: Options,\n version: string,\n): InputOptions & {\n showIgnoredFiles?: boolean;\n} {\n // Babel <= 7.28.0 does not support `sourceType: \"commonjs\"`.\n if (\n !process.env.BABEL_8_BREAKING &&\n options.sourceType === \"commonjs\" &&\n !semver.satisfies(version, REQUIRED_VERSION(\">=7.28.0\"))\n ) {\n options.sourceType = \"script\";\n options.ecmaFeatures = {\n ...(options.ecmaFeatures ?? {}),\n globalReturn: true,\n };\n }\n return {\n sourceType: options.sourceType,\n filename: options.filePath,\n ...options.babelOptions,\n parserOpts: {\n ...(process.env.BABEL_8_BREAKING\n ? {}\n : {\n allowImportExportEverywhere:\n options.allowImportExportEverywhere ?? false,\n allowSuperOutsideMethod: true,\n }),\n ...(options.sourceType !== \"commonjs\"\n ? {\n allowReturnOutsideFunction:\n options.ecmaFeatures?.globalReturn ??\n (process.env.BABEL_8_BREAKING ? false : true),\n }\n : {}),\n ...options.babelOptions.parserOpts,\n plugins: getParserPlugins(options.babelOptions),\n // skip comment attaching for parsing performance\n attachComment: false,\n ranges: true,\n tokens: true,\n },\n caller: {\n name: \"@babel/eslint-parser\",\n ...options.babelOptions.caller,\n },\n };\n}\n\nfunction validateResolvedConfig(\n config: PartialConfig,\n options: Options,\n parseOptions: InputOptions,\n): InputOptions | NormalizedOptions {\n if (config !== null) {\n if (options.requireConfigFile !== false) {\n if (!config.hasFilesystemConfig()) {\n let error = `No Babel config file detected for ${config.options.filename}. Either disable config file checking with requireConfigFile: false, or configure Babel so that it can find the config files.`;\n\n if (config.options.filename.includes(\"node_modules\")) {\n error += `\\nIf you have a .babelrc.js file or use package.json#babel, keep in mind that it's not used when parsing dependencies. If you want your config to be applied to your whole app, consider using babel.config.js or babel.config.json instead.`;\n }\n\n throw new Error(error);\n }\n }\n if (config.options) return config.options;\n }\n\n return getDefaultParserOptions(parseOptions);\n}\n\nfunction getDefaultParserOptions(options: InputOptions): InputOptions {\n return {\n plugins: [],\n ...options,\n babelrc: false,\n configFile: false,\n browserslistConfigFile: false,\n ignore: null,\n only: null,\n };\n}\n\nexport async function normalizeBabelParseConfig(\n options: Options,\n): Promise {\n const parseOptions = normalizeParserOptions(options, babel.version);\n const config = await babel.loadPartialConfigAsync(parseOptions);\n return validateResolvedConfig(config, options, parseOptions);\n}\n\nexport function normalizeBabelParseConfigSync(\n options: Options,\n): InputOptions | NormalizedOptions {\n const parseOptions = normalizeParserOptions(options, babel.version);\n const config = babel.loadPartialConfigSync(parseOptions);\n return validateResolvedConfig(config, options, parseOptions);\n}\n"],"mappings":"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","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,11 @@ +"use strict"; + +module.exports = function extractParserOptionsPlugin() { + return { + parserOverride(code, opts) { + return opts; + } + }; +}; + +//# sourceMappingURL=extract-parser-options-plugin.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/extract-parser-options-plugin.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["extractParserOptionsPlugin","parserOverride","code","opts"],"sources":["../../src/worker/extract-parser-options-plugin.cts"],"sourcesContent":["export = function extractParserOptionsPlugin() {\n return {\n parserOverride(code: string, opts: any) {\n return opts;\n },\n };\n};\n"],"mappings":";;iBAAS,SAASA,0BAA0BA,CAAA,EAAG;EAC7C,OAAO;IACLC,cAAcA,CAACC,IAAY,EAAEC,IAAS,EAAE;MACtC,OAAOA,IAAI;IACb;EACF,CAAC;AACH,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,31 @@ +"use strict"; + +const babel = require("./babel-core.cjs"); +const maybeParse = require("./maybeParse.cjs"); +const maybeParseSync = require("./maybeParseSync.cjs"); +const astInfo = require("./ast-info.cjs"); +const config = require("./configuration.cjs"); +const Clients = require("../client.cjs"); +var ACTIONS = Clients.ACTIONS; +module.exports = function handleMessage(action, payload) { + switch (action) { + case ACTIONS.GET_VERSION: + return babel.version; + case ACTIONS.GET_TYPES_INFO: + return { + FLOW_FLIPPED_ALIAS_KEYS: babel.types.FLIPPED_ALIAS_KEYS.Flow, + VISITOR_KEYS: babel.types.VISITOR_KEYS + }; + case ACTIONS.GET_TOKEN_LABELS: + return astInfo.getTokLabels(); + case ACTIONS.GET_VISITOR_KEYS: + return astInfo.getVisitorKeys(); + case ACTIONS.MAYBE_PARSE: + return config.normalizeBabelParseConfig(payload.options).then(options => maybeParse(payload.code, options)); + case ACTIONS.MAYBE_PARSE_SYNC: + return maybeParseSync(payload.code, config.normalizeBabelParseConfigSync(payload.options)); + } + throw new Error(`Unknown internal parser worker action: ${action}`); +}; + +//# sourceMappingURL=handle-message.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/handle-message.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["babel","require","maybeParse","maybeParseSync","astInfo","config","Clients","ACTIONS","module","exports","handleMessage","action","payload","GET_VERSION","version","GET_TYPES_INFO","FLOW_FLIPPED_ALIAS_KEYS","types","FLIPPED_ALIAS_KEYS","Flow","VISITOR_KEYS","GET_TOKEN_LABELS","getTokLabels","GET_VISITOR_KEYS","getVisitorKeys","MAYBE_PARSE","normalizeBabelParseConfig","options","then","code","MAYBE_PARSE_SYNC","normalizeBabelParseConfigSync","Error"],"sources":["../../src/worker/handle-message.cts"],"sourcesContent":["import babel = require(\"./babel-core.cts\");\nimport maybeParse = require(\"./maybeParse.cts\");\nimport maybeParseSync = require(\"./maybeParseSync.cts\");\nimport astInfo = require(\"./ast-info.cts\");\nimport config = require(\"./configuration.cts\");\n\nimport Clients = require(\"../client.cts\");\nimport ACTIONS = Clients.ACTIONS;\n\nexport = function handleMessage(action: ACTIONS, payload: any) {\n switch (action) {\n case ACTIONS.GET_VERSION:\n return babel.version;\n case ACTIONS.GET_TYPES_INFO:\n return {\n FLOW_FLIPPED_ALIAS_KEYS: babel.types.FLIPPED_ALIAS_KEYS.Flow,\n VISITOR_KEYS: babel.types.VISITOR_KEYS,\n };\n case ACTIONS.GET_TOKEN_LABELS:\n return astInfo.getTokLabels();\n case ACTIONS.GET_VISITOR_KEYS:\n return astInfo.getVisitorKeys();\n case ACTIONS.MAYBE_PARSE:\n return config\n .normalizeBabelParseConfig(payload.options)\n .then(options => maybeParse(payload.code, options));\n case ACTIONS.MAYBE_PARSE_SYNC:\n if (!USE_ESM) {\n return maybeParseSync(\n payload.code,\n config.normalizeBabelParseConfigSync(payload.options),\n );\n }\n }\n\n throw new Error(`Unknown internal parser worker action: ${action}`);\n};\n"],"mappings":";;MAAOA,KAAK,GAAAC,OAAA,CAAW,kBAAkB;AAAA,MAClCC,UAAU,GAAAD,OAAA,CAAW,kBAAkB;AAAA,MACvCE,cAAc,GAAAF,OAAA,CAAW,sBAAsB;AAAA,MAC/CG,OAAO,GAAAH,OAAA,CAAW,gBAAgB;AAAA,MAClCI,MAAM,GAAAJ,OAAA,CAAW,qBAAqB;AAAA,MAEtCK,OAAO,GAAAL,OAAA,CAAW,eAAe;AAAA,IACjCM,OAAO,GAAGD,OAAO,CAACC,OAAO;AAAAC,MAAA,CAAAC,OAAA,GAEvB,SAASC,aAAaA,CAACC,MAAe,EAAEC,OAAY,EAAE;EAC7D,QAAQD,MAAM;IACZ,KAAKJ,OAAO,CAACM,WAAW;MACtB,OAAOb,KAAK,CAACc,OAAO;IACtB,KAAKP,OAAO,CAACQ,cAAc;MACzB,OAAO;QACLC,uBAAuB,EAAEhB,KAAK,CAACiB,KAAK,CAACC,kBAAkB,CAACC,IAAI;QAC5DC,YAAY,EAAEpB,KAAK,CAACiB,KAAK,CAACG;MAC5B,CAAC;IACH,KAAKb,OAAO,CAACc,gBAAgB;MAC3B,OAAOjB,OAAO,CAACkB,YAAY,CAAC,CAAC;IAC/B,KAAKf,OAAO,CAACgB,gBAAgB;MAC3B,OAAOnB,OAAO,CAACoB,cAAc,CAAC,CAAC;IACjC,KAAKjB,OAAO,CAACkB,WAAW;MACtB,OAAOpB,MAAM,CACVqB,yBAAyB,CAACd,OAAO,CAACe,OAAO,CAAC,CAC1CC,IAAI,CAACD,OAAO,IAAIzB,UAAU,CAACU,OAAO,CAACiB,IAAI,EAAEF,OAAO,CAAC,CAAC;IACvD,KAAKpB,OAAO,CAACuB,gBAAgB;MAEzB,OAAO3B,cAAc,CACnBS,OAAO,CAACiB,IAAI,EACZxB,MAAM,CAAC0B,6BAA6B,CAACnB,OAAO,CAACe,OAAO,CACtD,CAAC;EAEP;EAEA,MAAM,IAAIK,KAAK,CAAC,0CAA0CrB,MAAM,EAAE,CAAC;AACrE,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/index.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/index.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/index.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,39 @@ +"use strict"; + +function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); } +function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; } +const babel = require("./babel-core.cjs"); +const handleMessage = require("./handle-message.cjs"); +const worker_threads = require("worker_threads"); +worker_threads.parentPort.addListener("message", _asyncToGenerator(function* ({ + signal, + port, + action, + payload +}) { + let response; + try { + if (babel.init) yield babel.init; + response = { + result: yield handleMessage(action, payload) + }; + } catch (error) { + response = { + error, + errorData: Object.assign({}, error) + }; + } + try { + port.postMessage(response); + } catch (_unused) { + port.postMessage({ + error: new Error("Cannot serialize worker response") + }); + } finally { + port.close(); + Atomics.store(signal, 0, 1); + Atomics.notify(signal, 0); + } +})); + +//# sourceMappingURL=index.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/index.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/index.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/index.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["babel","require","handleMessage","worker_threads","parentPort","addListener","_asyncToGenerator","signal","port","action","payload","response","init","result","error","errorData","Object","assign","postMessage","_unused","Error","close","Atomics","store","notify"],"sources":["../../src/worker/index.cts"],"sourcesContent":["import babel = require(\"./babel-core.cts\");\nimport handleMessage = require(\"./handle-message.cts\");\n\nimport worker_threads = require(\"worker_threads\");\n\nworker_threads.parentPort.addListener(\n \"message\",\n // eslint-disable-next-line @typescript-eslint/no-misused-promises\n async ({ signal, port, action, payload }) => {\n let response;\n\n try {\n if (babel.init) await babel.init;\n\n response = { result: await handleMessage(action, payload) };\n } catch (error) {\n response = { error, errorData: { ...error } };\n }\n\n try {\n port.postMessage(response);\n } catch {\n port.postMessage({\n error: new Error(\"Cannot serialize worker response\"),\n });\n } finally {\n port.close();\n Atomics.store(signal, 0, 1);\n Atomics.notify(signal, 0);\n }\n },\n);\n"],"mappings":";;;;MAAOA,KAAK,GAAAC,OAAA,CAAW,kBAAkB;AAAA,MAClCC,aAAa,GAAAD,OAAA,CAAW,sBAAsB;AAAA,MAE9CE,cAAc,GAAAF,OAAA,CAAW,gBAAgB;AAEhDE,cAAc,CAACC,UAAU,CAACC,WAAW,CACnC,SAAS,EAAAC,iBAAA,CAET,WAAO;EAAEC,MAAM;EAAEC,IAAI;EAAEC,MAAM;EAAEC;AAAQ,CAAC,EAAK;EAC3C,IAAIC,QAAQ;EAEZ,IAAI;IACF,IAAIX,KAAK,CAACY,IAAI,EAAE,MAAMZ,KAAK,CAACY,IAAI;IAEhCD,QAAQ,GAAG;MAAEE,MAAM,QAAQX,aAAa,CAACO,MAAM,EAAEC,OAAO;IAAE,CAAC;EAC7D,CAAC,CAAC,OAAOI,KAAK,EAAE;IACdH,QAAQ,GAAG;MAAEG,KAAK;MAAEC,SAAS,EAAAC,MAAA,CAAAC,MAAA,KAAOH,KAAK;IAAG,CAAC;EAC/C;EAEA,IAAI;IACFN,IAAI,CAACU,WAAW,CAACP,QAAQ,CAAC;EAC5B,CAAC,CAAC,OAAAQ,OAAA,EAAM;IACNX,IAAI,CAACU,WAAW,CAAC;MACfJ,KAAK,EAAE,IAAIM,KAAK,CAAC,kCAAkC;IACrD,CAAC,CAAC;EACJ,CAAC,SAAS;IACRZ,IAAI,CAACa,KAAK,CAAC,CAAC;IACZC,OAAO,CAACC,KAAK,CAAChB,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;IAC3Be,OAAO,CAACE,MAAM,CAACjB,MAAM,EAAE,CAAC,CAAC;EAC3B;AACF,CAAC,CACH,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,56 @@ +"use strict"; + +function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); } +function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; } +const babel = require("./babel-core.cjs"); +const convert = require("../convert/index.cjs"); +const astInfo = require("./ast-info.cjs"); +const extractParserOptionsPlugin = require("./extract-parser-options-plugin.cjs"); +const { + getVisitorKeys, + getTokLabels +} = astInfo; +const ref = {}; +let extractParserOptionsConfigItem; +const MULTIPLE_OVERRIDES = /More than one plugin attempted to override parsing/; +module.exports = function () { + var _asyncMaybeParse = _asyncToGenerator(function* (code, options) { + if (!extractParserOptionsConfigItem) { + extractParserOptionsConfigItem = yield babel.createConfigItemAsync([extractParserOptionsPlugin, ref], { + dirname: __dirname, + type: "plugin" + }); + } + const { + plugins + } = options; + options.plugins = plugins.concat(extractParserOptionsConfigItem); + let ast; + try { + return { + parserOptions: yield babel.parseAsync(code, options), + ast: null + }; + } catch (err) { + if (!MULTIPLE_OVERRIDES.test(err.message)) { + throw err; + } + } + options.plugins = plugins; + try { + ast = yield babel.parseAsync(code, options); + } catch (err) { + throw convert.convertError(err); + } + return { + ast: convert.convertFile(ast, code, getTokLabels(), getVisitorKeys()), + parserOptions: null + }; + }); + function asyncMaybeParse(_x, _x2) { + return _asyncMaybeParse.apply(this, arguments); + } + return asyncMaybeParse; +}(); + +//# sourceMappingURL=maybeParse.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParse.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["babel","require","convert","astInfo","extractParserOptionsPlugin","getVisitorKeys","getTokLabels","ref","extractParserOptionsConfigItem","MULTIPLE_OVERRIDES","module","exports","_asyncMaybeParse","_asyncToGenerator","code","options","createConfigItemAsync","dirname","__dirname","type","plugins","concat","ast","parserOptions","parseAsync","err","test","message","convertError","convertFile","asyncMaybeParse","_x","_x2","apply","arguments"],"sources":["../../src/worker/maybeParse.cts"],"sourcesContent":["import babel = require(\"./babel-core.cts\");\nimport convert = require(\"../convert/index.cts\");\nimport astInfo = require(\"./ast-info.cts\");\nimport extractParserOptionsPlugin = require(\"./extract-parser-options-plugin.cjs\");\n\nimport type { InputOptions, ConfigItem } from \"@babel/core\";\nimport type { AST, ParseResult } from \"../types.cts\";\n\nconst { getVisitorKeys, getTokLabels } = astInfo;\n\nconst ref = {};\nlet extractParserOptionsConfigItem: ConfigItem;\n\nconst MULTIPLE_OVERRIDES = /More than one plugin attempted to override parsing/;\n\nexport = async function asyncMaybeParse(\n code: string,\n options: InputOptions,\n): Promise<{\n ast: AST.Program | null;\n parserOptions: ParseResult | null;\n}> {\n if (!extractParserOptionsConfigItem) {\n extractParserOptionsConfigItem = await babel.createConfigItemAsync(\n [extractParserOptionsPlugin, ref],\n { dirname: __dirname, type: \"plugin\" },\n );\n }\n const { plugins } = options;\n options.plugins = plugins.concat(extractParserOptionsConfigItem);\n\n let ast;\n\n try {\n return {\n parserOptions: await babel.parseAsync(code, options),\n ast: null,\n };\n } catch (err) {\n if (!MULTIPLE_OVERRIDES.test(err.message)) {\n throw err;\n }\n }\n\n // There was already a parserOverride, so remove our plugin.\n options.plugins = plugins;\n\n try {\n ast = await babel.parseAsync(code, options);\n } catch (err) {\n throw convert.convertError(err);\n }\n\n return {\n ast: convert.convertFile(ast, code, getTokLabels(), getVisitorKeys()),\n parserOptions: null,\n };\n};\n"],"mappings":";;;;MAAOA,KAAK,GAAAC,OAAA,CAAW,kBAAkB;AAAA,MAClCC,OAAO,GAAAD,OAAA,CAAW,sBAAsB;AAAA,MACxCE,OAAO,GAAAF,OAAA,CAAW,gBAAgB;AAAA,MAClCG,0BAA0B,GAAAH,OAAA,CAAW,qCAAqC;AAKjF,MAAM;EAAEI,cAAc;EAAEC;AAAa,CAAC,GAAGH,OAAO;AAEhD,MAAMI,GAAG,GAAG,CAAC,CAAC;AACd,IAAIC,8BAA+C;AAEnD,MAAMC,kBAAkB,GAAG,oDAAoD;AAACC,MAAA,CAAAC,OAAA;EAAA,IAAAC,gBAAA,GAAAC,iBAAA,CAEvE,WACPC,IAAY,EACZC,OAAqB,EAIpB;IACD,IAAI,CAACP,8BAA8B,EAAE;MACnCA,8BAA8B,SAASR,KAAK,CAACgB,qBAAqB,CAChE,CAACZ,0BAA0B,EAAEG,GAAG,CAAC,EACjC;QAAEU,OAAO,EAAEC,SAAS;QAAEC,IAAI,EAAE;MAAS,CACvC,CAAC;IACH;IACA,MAAM;MAAEC;IAAQ,CAAC,GAAGL,OAAO;IAC3BA,OAAO,CAACK,OAAO,GAAGA,OAAO,CAACC,MAAM,CAACb,8BAA8B,CAAC;IAEhE,IAAIc,GAAG;IAEP,IAAI;MACF,OAAO;QACLC,aAAa,QAAQvB,KAAK,CAACwB,UAAU,CAACV,IAAI,EAAEC,OAAO,CAAC;QACpDO,GAAG,EAAE;MACP,CAAC;IACH,CAAC,CAAC,OAAOG,GAAG,EAAE;MACZ,IAAI,CAAChB,kBAAkB,CAACiB,IAAI,CAACD,GAAG,CAACE,OAAO,CAAC,EAAE;QACzC,MAAMF,GAAG;MACX;IACF;IAGAV,OAAO,CAACK,OAAO,GAAGA,OAAO;IAEzB,IAAI;MACFE,GAAG,SAAStB,KAAK,CAACwB,UAAU,CAACV,IAAI,EAAEC,OAAO,CAAC;IAC7C,CAAC,CAAC,OAAOU,GAAG,EAAE;MACZ,MAAMvB,OAAO,CAAC0B,YAAY,CAACH,GAAG,CAAC;IACjC;IAEA,OAAO;MACLH,GAAG,EAAEpB,OAAO,CAAC2B,WAAW,CAACP,GAAG,EAAER,IAAI,EAAER,YAAY,CAAC,CAAC,EAAED,cAAc,CAAC,CAAC,CAAC;MACrEkB,aAAa,EAAE;IACjB,CAAC;EACH,CAAC;EAAA,SA1CuBO,eAAeA,CAAAC,EAAA,EAAAC,GAAA;IAAA,OAAApB,gBAAA,CAAAqB,KAAA,OAAAC,SAAA;EAAA;EAAA,OAAfJ,eAAe;AAAA","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParseSync.cjs =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParseSync.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParseSync.cjs (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,48 @@ +"use strict"; + +const babel = require("./babel-core.cjs"); +const convert = require("../convert/index.cjs"); +const astInfo = require("./ast-info.cjs"); +const extractParserOptionsPlugin = require("./extract-parser-options-plugin.cjs"); +const { + getVisitorKeys, + getTokLabels +} = astInfo; +const ref = {}; +let extractParserOptionsConfigItem; +const MULTIPLE_OVERRIDES = /More than one plugin attempted to override parsing/; +module.exports = function maybeParseSync(code, options) { + if (!extractParserOptionsConfigItem) { + extractParserOptionsConfigItem = babel.createConfigItemSync([extractParserOptionsPlugin, ref], { + dirname: __dirname, + type: "plugin" + }); + } + const { + plugins + } = options; + options.plugins = plugins.concat(extractParserOptionsConfigItem); + let ast; + try { + return { + parserOptions: babel.parseSync(code, options), + ast: null + }; + } catch (err) { + if (!MULTIPLE_OVERRIDES.test(err.message)) { + throw err; + } + } + options.plugins = plugins; + try { + ast = babel.parseSync(code, options); + } catch (err) { + throw convert.convertError(err); + } + return { + ast: convert.convertFile(ast, code, getTokLabels(), getVisitorKeys()), + parserOptions: null + }; +}; + +//# sourceMappingURL=maybeParseSync.cjs.map Index: frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParseSync.cjs.map =================================================================== --- frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParseSync.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/lib/worker/maybeParseSync.cjs.map (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1 @@ +{"version":3,"names":["babel","require","convert","astInfo","extractParserOptionsPlugin","getVisitorKeys","getTokLabels","ref","extractParserOptionsConfigItem","MULTIPLE_OVERRIDES","module","exports","maybeParseSync","code","options","createConfigItemSync","dirname","__dirname","type","plugins","concat","ast","parserOptions","parseSync","err","test","message","convertError","convertFile"],"sources":["../../src/worker/maybeParseSync.cts"],"sourcesContent":["import babel = require(\"./babel-core.cts\");\nimport convert = require(\"../convert/index.cts\");\nimport astInfo = require(\"./ast-info.cts\");\nimport extractParserOptionsPlugin = require(\"./extract-parser-options-plugin.cjs\");\n\nimport type { InputOptions, ConfigItem, NormalizedOptions } from \"@babel/core\";\nimport type { AST, ParseResult } from \"../types.cts\";\n\nconst { getVisitorKeys, getTokLabels } = astInfo;\n\nconst ref = {};\nlet extractParserOptionsConfigItem: ConfigItem;\n\nconst MULTIPLE_OVERRIDES = /More than one plugin attempted to override parsing/;\n\nexport = function maybeParseSync(\n code: string,\n options: InputOptions | NormalizedOptions,\n): {\n ast: AST.Program | null;\n parserOptions: ParseResult | null;\n} {\n if (!extractParserOptionsConfigItem) {\n extractParserOptionsConfigItem = babel.createConfigItemSync(\n [extractParserOptionsPlugin, ref],\n { dirname: __dirname, type: \"plugin\" },\n );\n }\n const { plugins } = options;\n options.plugins = plugins.concat(extractParserOptionsConfigItem);\n\n let ast;\n\n try {\n return {\n parserOptions: babel.parseSync(code, options),\n ast: null,\n };\n } catch (err) {\n if (!MULTIPLE_OVERRIDES.test(err.message)) {\n throw err;\n }\n }\n\n // There was already a parserOverride, so remove our plugin.\n options.plugins = plugins;\n\n try {\n ast = babel.parseSync(code, options);\n } catch (err) {\n throw convert.convertError(err);\n }\n\n return {\n ast: convert.convertFile(ast, code, getTokLabels(), getVisitorKeys()),\n parserOptions: null,\n };\n};\n"],"mappings":";;MAAOA,KAAK,GAAAC,OAAA,CAAW,kBAAkB;AAAA,MAClCC,OAAO,GAAAD,OAAA,CAAW,sBAAsB;AAAA,MACxCE,OAAO,GAAAF,OAAA,CAAW,gBAAgB;AAAA,MAClCG,0BAA0B,GAAAH,OAAA,CAAW,qCAAqC;AAKjF,MAAM;EAAEI,cAAc;EAAEC;AAAa,CAAC,GAAGH,OAAO;AAEhD,MAAMI,GAAG,GAAG,CAAC,CAAC;AACd,IAAIC,8BAA+C;AAEnD,MAAMC,kBAAkB,GAAG,oDAAoD;AAACC,MAAA,CAAAC,OAAA,GAEvE,SAASC,cAAcA,CAC9BC,IAAY,EACZC,OAAyC,EAIzC;EACA,IAAI,CAACN,8BAA8B,EAAE;IACnCA,8BAA8B,GAAGR,KAAK,CAACe,oBAAoB,CACzD,CAACX,0BAA0B,EAAEG,GAAG,CAAC,EACjC;MAAES,OAAO,EAAEC,SAAS;MAAEC,IAAI,EAAE;IAAS,CACvC,CAAC;EACH;EACA,MAAM;IAAEC;EAAQ,CAAC,GAAGL,OAAO;EAC3BA,OAAO,CAACK,OAAO,GAAGA,OAAO,CAACC,MAAM,CAACZ,8BAA8B,CAAC;EAEhE,IAAIa,GAAG;EAEP,IAAI;IACF,OAAO;MACLC,aAAa,EAAEtB,KAAK,CAACuB,SAAS,CAACV,IAAI,EAAEC,OAAO,CAAC;MAC7CO,GAAG,EAAE;IACP,CAAC;EACH,CAAC,CAAC,OAAOG,GAAG,EAAE;IACZ,IAAI,CAACf,kBAAkB,CAACgB,IAAI,CAACD,GAAG,CAACE,OAAO,CAAC,EAAE;MACzC,MAAMF,GAAG;IACX;EACF;EAGAV,OAAO,CAACK,OAAO,GAAGA,OAAO;EAEzB,IAAI;IACFE,GAAG,GAAGrB,KAAK,CAACuB,SAAS,CAACV,IAAI,EAAEC,OAAO,CAAC;EACtC,CAAC,CAAC,OAAOU,GAAG,EAAE;IACZ,MAAMtB,OAAO,CAACyB,YAAY,CAACH,GAAG,CAAC;EACjC;EAEA,OAAO;IACLH,GAAG,EAAEnB,OAAO,CAAC0B,WAAW,CAACP,GAAG,EAAER,IAAI,EAAEP,YAAY,CAAC,CAAC,EAAED,cAAc,CAAC,CAAC,CAAC;IACrEiB,aAAa,EAAE;EACjB,CAAC;AACH,CAAC","ignoreList":[]} Index: frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,16 @@ +#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") + +case `uname` in + *CYGWIN*|*MINGW*|*MSYS*) + if command -v cygpath > /dev/null 2>&1; then + basedir=`cygpath -w "$basedir"` + fi + ;; +esac + +if [ -x "$basedir/node" ]; then + exec "$basedir/node" "$basedir/../semver/bin/semver.js" "$@" +else + exec node "$basedir/../semver/bin/semver.js" "$@" +fi Index: frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver.cmd =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver.cmd (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver.cmd (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,17 @@ +@ECHO off +GOTO start +:find_dp0 +SET dp0=%~dp0 +EXIT /b +:start +SETLOCAL +CALL :find_dp0 + +IF EXIST "%dp0%\node.exe" ( + SET "_prog=%dp0%\node.exe" +) ELSE ( + SET "_prog=node" + SET PATHEXT=%PATHEXT:;.JS;=;% +) + +endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\semver\bin\semver.js" %* Index: frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver.ps1 =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver.ps1 (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/.bin/semver.ps1 (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,28 @@ +#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent + +$exe="" +if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +} +$ret=0 +if (Test-Path "$basedir/node$exe") { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "$basedir/node$exe" "$basedir/../semver/bin/semver.js" $args + } else { + & "$basedir/node$exe" "$basedir/../semver/bin/semver.js" $args + } + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & "node$exe" "$basedir/../semver/bin/semver.js" $args + } else { + & "node$exe" "$basedir/../semver/bin/semver.js" $args + } + $ret=$LASTEXITCODE +} +exit $ret Index: frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/CHANGELOG.md =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/CHANGELOG.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/CHANGELOG.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,36 @@ +v2.1.0 - May 3, 2021 + +* [`908fdf8`](https://github.com/eslint/eslint-visitor-keys/commit/908fdf8c0d9a352c696c8c1f4901280d1a0795f7) Update: add PrivateIdentifier and PropertyDefinition (#20) (Toru Nagashima) +* [`2d7be11`](https://github.com/eslint/eslint-visitor-keys/commit/2d7be11e4d13ac702c9fe3c529cadbd75b370146) Chore: No longer test in Node.js 13 (#17) (Michaël De Boey) +* [`b41b509`](https://github.com/eslint/eslint-visitor-keys/commit/b41b509b153ecd8d47af46a421122f64e93d4c67) Docs: Update required Node.js version (#15) (Michaël De Boey) + +v2.0.0 - August 14, 2020 + +* [`fb86ca3`](https://github.com/eslint/eslint-visitor-keys/commit/fb86ca315daafc84e23ed9005db40b0892b972a6) Breaking: drop support for Node <10 (#13) (Kai Cataldo) +* [`69383b3`](https://github.com/eslint/eslint-visitor-keys/commit/69383b372915e33ada094880ecc6b6e8f8c7ca4e) Chore: move to GitHub Actions (#14) (Kai Cataldo) + +v1.3.0 - June 19, 2020 + +* [`c92dd7f`](https://github.com/eslint/eslint-visitor-keys/commit/c92dd7ff96f0044dba12d681406a025b92b4c437) Update: add `ChainExpression` node (#12) (Toru Nagashima) + +v1.2.0 - June 4, 2020 + +* [`21f28bf`](https://github.com/eslint/eslint-visitor-keys/commit/21f28bf11be5329d740a8bf6bdbcd0ef13bbf1a2) Update: added exported in exportAllDeclaration key (#10) (Anix) + +v1.1.0 - August 13, 2019 + +* [`9331cc0`](https://github.com/eslint/eslint-visitor-keys/commit/9331cc09e756e65b9044c9186445a474b037fac6) Update: add ImportExpression (#8) (Toru Nagashima) +* [`5967f58`](https://github.com/eslint/eslint-visitor-keys/commit/5967f583b04f17fba9226aaa394e45d476d2b8af) Chore: add supported Node.js versions to CI (#7) (Kai Cataldo) +* [`6f7c60f`](https://github.com/eslint/eslint-visitor-keys/commit/6f7c60fef2ceec9f6323202df718321cec45cab0) Upgrade: eslint-release@1.0.0 (#5) (Teddy Katz) + +v1.0.0 - December 18, 2017 + +* 1f6bd38 Breaking: update keys (#4) (Toru Nagashima) + +v0.1.0 - November 17, 2017 + +* 17b4a88 Chore: update `repository` field in package.json (#3) (Toru Nagashima) +* a5a026b New: eslint-visitor-keys (#1) (Toru Nagashima) +* a1a48b8 Update: Change license to Apache 2 (#2) (Ilya Volodin) +* 2204715 Initial commit (Toru Nagashima) + Index: frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/LICENSE =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright contributors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. Index: frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/README.md =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,98 @@ +# eslint-visitor-keys + +[![npm version](https://img.shields.io/npm/v/eslint-visitor-keys.svg)](https://www.npmjs.com/package/eslint-visitor-keys) +[![Downloads/month](https://img.shields.io/npm/dm/eslint-visitor-keys.svg)](http://www.npmtrends.com/eslint-visitor-keys) +[![Build Status](https://travis-ci.org/eslint/eslint-visitor-keys.svg?branch=master)](https://travis-ci.org/eslint/eslint-visitor-keys) +[![Dependency Status](https://david-dm.org/eslint/eslint-visitor-keys.svg)](https://david-dm.org/eslint/eslint-visitor-keys) + +Constants and utilities about visitor keys to traverse AST. + +## 💿 Installation + +Use [npm] to install. + +```bash +$ npm install eslint-visitor-keys +``` + +### Requirements + +- [Node.js] 10.0.0 or later. + +## 📖 Usage + +```js +const evk = require("eslint-visitor-keys") +``` + +### evk.KEYS + +> type: `{ [type: string]: string[] | undefined }` + +Visitor keys. This keys are frozen. + +This is an object. Keys are the type of [ESTree] nodes. Their values are an array of property names which have child nodes. + +For example: + +``` +console.log(evk.KEYS.AssignmentExpression) // → ["left", "right"] +``` + +### evk.getKeys(node) + +> type: `(node: object) => string[]` + +Get the visitor keys of a given AST node. + +This is similar to `Object.keys(node)` of ES Standard, but some keys are excluded: `parent`, `leadingComments`, `trailingComments`, and names which start with `_`. + +This will be used to traverse unknown nodes. + +For example: + +``` +const node = { + type: "AssignmentExpression", + left: { type: "Identifier", name: "foo" }, + right: { type: "Literal", value: 0 } +} +console.log(evk.getKeys(node)) // → ["type", "left", "right"] +``` + +### evk.unionWith(additionalKeys) + +> type: `(additionalKeys: object) => { [type: string]: string[] | undefined }` + +Make the union set with `evk.KEYS` and the given keys. + +- The order of keys is, `additionalKeys` is at first, then `evk.KEYS` is concatenated after that. +- It removes duplicated keys as keeping the first one. + +For example: + +``` +console.log(evk.unionWith({ + MethodDefinition: ["decorators"] +})) // → { ..., MethodDefinition: ["decorators", "key", "value"], ... } +``` + +## 📰 Change log + +See [GitHub releases](https://github.com/eslint/eslint-visitor-keys/releases). + +## 🍻 Contributing + +Welcome. See [ESLint contribution guidelines](https://eslint.org/docs/developer-guide/contributing/). + +### Development commands + +- `npm test` runs tests and measures code coverage. +- `npm run lint` checks source codes with ESLint. +- `npm run coverage` opens the code coverage report of the previous test with your default browser. +- `npm run release` publishes this package to [npm] registory. + + +[npm]: https://www.npmjs.com/ +[Node.js]: https://nodejs.org/en/ +[ESTree]: https://github.com/estree/estree Index: frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/lib/index.js =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/lib/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/lib/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,81 @@ +/** + * @author Toru Nagashima + * See LICENSE file in root directory for full license. + */ +"use strict"; + +const KEYS = require("./visitor-keys.json"); + +// Types. +const NODE_TYPES = Object.freeze(Object.keys(KEYS)); + +// Freeze the keys. +for (const type of NODE_TYPES) { + Object.freeze(KEYS[type]); +} +Object.freeze(KEYS); + +// List to ignore keys. +const KEY_BLACKLIST = new Set([ + "parent", + "leadingComments", + "trailingComments" +]); + +/** + * Check whether a given key should be used or not. + * @param {string} key The key to check. + * @returns {boolean} `true` if the key should be used. + */ +function filterKey(key) { + return !KEY_BLACKLIST.has(key) && key[0] !== "_"; +} + +//------------------------------------------------------------------------------ +// Public interfaces +//------------------------------------------------------------------------------ + +module.exports = Object.freeze({ + + /** + * Visitor keys. + * @type {{ [type: string]: string[] | undefined }} + */ + KEYS, + + /** + * Get visitor keys of a given node. + * @param {Object} node The AST node to get keys. + * @returns {string[]} Visitor keys of the node. + */ + getKeys(node) { + return Object.keys(node).filter(filterKey); + }, + + // Disable valid-jsdoc rule because it reports syntax error on the type of @returns. + // eslint-disable-next-line valid-jsdoc + /** + * Make the union set with `KEYS` and given keys. + * @param {Object} additionalKeys The additional keys. + * @returns {{ [type: string]: string[] | undefined }} The union set. + */ + unionWith(additionalKeys) { + const retv = Object.assign({}, KEYS); + + for (const type of Object.keys(additionalKeys)) { + if (retv.hasOwnProperty(type)) { + const keys = new Set(additionalKeys[type]); + + for (const key of retv[type]) { + keys.add(key); + } + + retv[type] = Object.freeze(Array.from(keys)); + } else { + retv[type] = Object.freeze(Array.from(additionalKeys[type])); + } + } + + return Object.freeze(retv); + } +}); Index: frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/lib/visitor-keys.json =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/lib/visitor-keys.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/lib/visitor-keys.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,289 @@ +{ + "AssignmentExpression": [ + "left", + "right" + ], + "AssignmentPattern": [ + "left", + "right" + ], + "ArrayExpression": [ + "elements" + ], + "ArrayPattern": [ + "elements" + ], + "ArrowFunctionExpression": [ + "params", + "body" + ], + "AwaitExpression": [ + "argument" + ], + "BlockStatement": [ + "body" + ], + "BinaryExpression": [ + "left", + "right" + ], + "BreakStatement": [ + "label" + ], + "CallExpression": [ + "callee", + "arguments" + ], + "CatchClause": [ + "param", + "body" + ], + "ChainExpression": [ + "expression" + ], + "ClassBody": [ + "body" + ], + "ClassDeclaration": [ + "id", + "superClass", + "body" + ], + "ClassExpression": [ + "id", + "superClass", + "body" + ], + "ConditionalExpression": [ + "test", + "consequent", + "alternate" + ], + "ContinueStatement": [ + "label" + ], + "DebuggerStatement": [], + "DoWhileStatement": [ + "body", + "test" + ], + "EmptyStatement": [], + "ExportAllDeclaration": [ + "exported", + "source" + ], + "ExportDefaultDeclaration": [ + "declaration" + ], + "ExportNamedDeclaration": [ + "declaration", + "specifiers", + "source" + ], + "ExportSpecifier": [ + "exported", + "local" + ], + "ExpressionStatement": [ + "expression" + ], + "ExperimentalRestProperty": [ + "argument" + ], + "ExperimentalSpreadProperty": [ + "argument" + ], + "ForStatement": [ + "init", + "test", + "update", + "body" + ], + "ForInStatement": [ + "left", + "right", + "body" + ], + "ForOfStatement": [ + "left", + "right", + "body" + ], + "FunctionDeclaration": [ + "id", + "params", + "body" + ], + "FunctionExpression": [ + "id", + "params", + "body" + ], + "Identifier": [], + "IfStatement": [ + "test", + "consequent", + "alternate" + ], + "ImportDeclaration": [ + "specifiers", + "source" + ], + "ImportDefaultSpecifier": [ + "local" + ], + "ImportExpression": [ + "source" + ], + "ImportNamespaceSpecifier": [ + "local" + ], + "ImportSpecifier": [ + "imported", + "local" + ], + "JSXAttribute": [ + "name", + "value" + ], + "JSXClosingElement": [ + "name" + ], + "JSXElement": [ + "openingElement", + "children", + "closingElement" + ], + "JSXEmptyExpression": [], + "JSXExpressionContainer": [ + "expression" + ], + "JSXIdentifier": [], + "JSXMemberExpression": [ + "object", + "property" + ], + "JSXNamespacedName": [ + "namespace", + "name" + ], + "JSXOpeningElement": [ + "name", + "attributes" + ], + "JSXSpreadAttribute": [ + "argument" + ], + "JSXText": [], + "JSXFragment": [ + "openingFragment", + "children", + "closingFragment" + ], + "Literal": [], + "LabeledStatement": [ + "label", + "body" + ], + "LogicalExpression": [ + "left", + "right" + ], + "MemberExpression": [ + "object", + "property" + ], + "MetaProperty": [ + "meta", + "property" + ], + "MethodDefinition": [ + "key", + "value" + ], + "NewExpression": [ + "callee", + "arguments" + ], + "ObjectExpression": [ + "properties" + ], + "ObjectPattern": [ + "properties" + ], + "PrivateIdentifier": [], + "Program": [ + "body" + ], + "Property": [ + "key", + "value" + ], + "PropertyDefinition": [ + "key", + "value" + ], + "RestElement": [ + "argument" + ], + "ReturnStatement": [ + "argument" + ], + "SequenceExpression": [ + "expressions" + ], + "SpreadElement": [ + "argument" + ], + "Super": [], + "SwitchStatement": [ + "discriminant", + "cases" + ], + "SwitchCase": [ + "test", + "consequent" + ], + "TaggedTemplateExpression": [ + "tag", + "quasi" + ], + "TemplateElement": [], + "TemplateLiteral": [ + "quasis", + "expressions" + ], + "ThisExpression": [], + "ThrowStatement": [ + "argument" + ], + "TryStatement": [ + "block", + "handler", + "finalizer" + ], + "UnaryExpression": [ + "argument" + ], + "UpdateExpression": [ + "argument" + ], + "VariableDeclaration": [ + "declarations" + ], + "VariableDeclarator": [ + "id", + "init" + ], + "WhileStatement": [ + "test", + "body" + ], + "WithStatement": [ + "object", + "body" + ], + "YieldExpression": [ + "argument" + ] +} Index: frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/package.json =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,39 @@ +{ + "name": "eslint-visitor-keys", + "version": "2.1.0", + "description": "Constants and utilities about visitor keys to traverse AST.", + "main": "lib/index.js", + "files": [ + "lib" + ], + "engines": { + "node": ">=10" + }, + "dependencies": {}, + "devDependencies": { + "eslint": "^4.7.2", + "eslint-config-eslint": "^4.0.0", + "eslint-release": "^1.0.0", + "mocha": "^3.5.3", + "nyc": "^11.2.1", + "opener": "^1.4.3" + }, + "scripts": { + "lint": "eslint lib tests/lib", + "test": "nyc mocha tests/lib", + "coverage": "nyc report --reporter lcov && opener coverage/lcov-report/index.html", + "generate-release": "eslint-generate-release", + "generate-alpharelease": "eslint-generate-prerelease alpha", + "generate-betarelease": "eslint-generate-prerelease beta", + "generate-rcrelease": "eslint-generate-prerelease rc", + "publish-release": "eslint-publish-release" + }, + "repository": "eslint/eslint-visitor-keys", + "keywords": [], + "author": "Toru Nagashima (https://github.com/mysticatea)", + "license": "Apache-2.0", + "bugs": { + "url": "https://github.com/eslint/eslint-visitor-keys/issues" + }, + "homepage": "https://github.com/eslint/eslint-visitor-keys#readme" +} Index: frontend/node_modules/@babel/eslint-parser/node_modules/semver/LICENSE =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/semver/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/semver/LICENSE (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) Isaac Z. Schlueter and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Index: frontend/node_modules/@babel/eslint-parser/node_modules/semver/README.md =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/semver/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/semver/README.md (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,443 @@ +semver(1) -- The semantic versioner for npm +=========================================== + +## Install + +```bash +npm install semver +```` + +## Usage + +As a node module: + +```js +const semver = require('semver') + +semver.valid('1.2.3') // '1.2.3' +semver.valid('a.b.c') // null +semver.clean(' =v1.2.3 ') // '1.2.3' +semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true +semver.gt('1.2.3', '9.8.7') // false +semver.lt('1.2.3', '9.8.7') // true +semver.minVersion('>=1.0.0') // '1.0.0' +semver.valid(semver.coerce('v2')) // '2.0.0' +semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7' +``` + +As a command-line utility: + +``` +$ semver -h + +A JavaScript implementation of the https://semver.org/ specification +Copyright Isaac Z. Schlueter + +Usage: semver [options] [ [...]] +Prints valid versions sorted by SemVer precedence + +Options: +-r --range + Print versions that match the specified range. + +-i --increment [] + Increment a version by the specified level. Level can + be one of: major, minor, patch, premajor, preminor, + prepatch, or prerelease. Default level is 'patch'. + Only one version may be specified. + +--preid + Identifier to be used to prefix premajor, preminor, + prepatch or prerelease version increments. + +-l --loose + Interpret versions and ranges loosely + +-p --include-prerelease + Always include prerelease versions in range matching + +-c --coerce + Coerce a string into SemVer if possible + (does not imply --loose) + +--rtl + Coerce version strings right to left + +--ltr + Coerce version strings left to right (default) + +Program exits successfully if any valid version satisfies +all supplied ranges, and prints all satisfying versions. + +If no satisfying versions are found, then exits failure. + +Versions are printed in ascending order, so supplying +multiple versions to the utility will just sort them. +``` + +## Versions + +A "version" is described by the `v2.0.0` specification found at +. + +A leading `"="` or `"v"` character is stripped off and ignored. + +## Ranges + +A `version range` is a set of `comparators` which specify versions +that satisfy the range. + +A `comparator` is composed of an `operator` and a `version`. The set +of primitive `operators` is: + +* `<` Less than +* `<=` Less than or equal to +* `>` Greater than +* `>=` Greater than or equal to +* `=` Equal. If no operator is specified, then equality is assumed, + so this operator is optional, but MAY be included. + +For example, the comparator `>=1.2.7` would match the versions +`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6` +or `1.1.0`. + +Comparators can be joined by whitespace to form a `comparator set`, +which is satisfied by the **intersection** of all of the comparators +it includes. + +A range is composed of one or more comparator sets, joined by `||`. A +version matches a range if and only if every comparator in at least +one of the `||`-separated comparator sets is satisfied by the version. + +For example, the range `>=1.2.7 <1.3.0` would match the versions +`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`, +or `1.1.0`. + +The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`, +`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`. + +### Prerelease Tags + +If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then +it will only be allowed to satisfy comparator sets if at least one +comparator with the same `[major, minor, patch]` tuple also has a +prerelease tag. + +For example, the range `>1.2.3-alpha.3` would be allowed to match the +version `1.2.3-alpha.7`, but it would *not* be satisfied by +`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater +than" `1.2.3-alpha.3` according to the SemVer sort rules. The version +range only accepts prerelease tags on the `1.2.3` version. The +version `3.4.5` *would* satisfy the range, because it does not have a +prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`. + +The purpose for this behavior is twofold. First, prerelease versions +frequently are updated very quickly, and contain many breaking changes +that are (by the author's design) not yet fit for public consumption. +Therefore, by default, they are excluded from range matching +semantics. + +Second, a user who has opted into using a prerelease version has +clearly indicated the intent to use *that specific* set of +alpha/beta/rc versions. By including a prerelease tag in the range, +the user is indicating that they are aware of the risk. However, it +is still not appropriate to assume that they have opted into taking a +similar risk on the *next* set of prerelease versions. + +Note that this behavior can be suppressed (treating all prerelease +versions as if they were normal versions, for the purpose of range +matching) by setting the `includePrerelease` flag on the options +object to any +[functions](https://github.com/npm/node-semver#functions) that do +range matching. + +#### Prerelease Identifiers + +The method `.inc` takes an additional `identifier` string argument that +will append the value of the string as a prerelease identifier: + +```javascript +semver.inc('1.2.3', 'prerelease', 'beta') +// '1.2.4-beta.0' +``` + +command-line example: + +```bash +$ semver 1.2.3 -i prerelease --preid beta +1.2.4-beta.0 +``` + +Which then can be used to increment further: + +```bash +$ semver 1.2.4-beta.0 -i prerelease +1.2.4-beta.1 +``` + +### Advanced Range Syntax + +Advanced range syntax desugars to primitive comparators in +deterministic ways. + +Advanced ranges may be combined in the same way as primitive +comparators using white space or `||`. + +#### Hyphen Ranges `X.Y.Z - A.B.C` + +Specifies an inclusive set. + +* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4` + +If a partial version is provided as the first version in the inclusive +range, then the missing pieces are replaced with zeroes. + +* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4` + +If a partial version is provided as the second version in the +inclusive range, then all versions that start with the supplied parts +of the tuple are accepted, but nothing that would be greater than the +provided tuple parts. + +* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0` +* `1.2.3 - 2` := `>=1.2.3 <3.0.0` + +#### X-Ranges `1.2.x` `1.X` `1.2.*` `*` + +Any of `X`, `x`, or `*` may be used to "stand in" for one of the +numeric values in the `[major, minor, patch]` tuple. + +* `*` := `>=0.0.0` (Any version satisfies) +* `1.x` := `>=1.0.0 <2.0.0` (Matching major version) +* `1.2.x` := `>=1.2.0 <1.3.0` (Matching major and minor versions) + +A partial version range is treated as an X-Range, so the special +character is in fact optional. + +* `""` (empty string) := `*` := `>=0.0.0` +* `1` := `1.x.x` := `>=1.0.0 <2.0.0` +* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0` + +#### Tilde Ranges `~1.2.3` `~1.2` `~1` + +Allows patch-level changes if a minor version is specified on the +comparator. Allows minor-level changes if not. + +* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0` +* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0` (Same as `1.2.x`) +* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0` (Same as `1.x`) +* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0` +* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0` (Same as `0.2.x`) +* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0` (Same as `0.x`) +* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0` Note that prereleases in + the `1.2.3` version will be allowed, if they are greater than or + equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but + `1.2.4-beta.2` would not, because it is a prerelease of a + different `[major, minor, patch]` tuple. + +#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4` + +Allows changes that do not modify the left-most non-zero element in the +`[major, minor, patch]` tuple. In other words, this allows patch and +minor updates for versions `1.0.0` and above, patch updates for +versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`. + +Many authors treat a `0.x` version as if the `x` were the major +"breaking-change" indicator. + +Caret ranges are ideal when an author may make breaking changes +between `0.2.4` and `0.3.0` releases, which is a common practice. +However, it presumes that there will *not* be breaking changes between +`0.2.4` and `0.2.5`. It allows for changes that are presumed to be +additive (but non-breaking), according to commonly observed practices. + +* `^1.2.3` := `>=1.2.3 <2.0.0` +* `^0.2.3` := `>=0.2.3 <0.3.0` +* `^0.0.3` := `>=0.0.3 <0.0.4` +* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0` Note that prereleases in + the `1.2.3` version will be allowed, if they are greater than or + equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but + `1.2.4-beta.2` would not, because it is a prerelease of a + different `[major, minor, patch]` tuple. +* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4` Note that prereleases in the + `0.0.3` version *only* will be allowed, if they are greater than or + equal to `beta`. So, `0.0.3-pr.2` would be allowed. + +When parsing caret ranges, a missing `patch` value desugars to the +number `0`, but will allow flexibility within that value, even if the +major and minor versions are both `0`. + +* `^1.2.x` := `>=1.2.0 <2.0.0` +* `^0.0.x` := `>=0.0.0 <0.1.0` +* `^0.0` := `>=0.0.0 <0.1.0` + +A missing `minor` and `patch` values will desugar to zero, but also +allow flexibility within those values, even if the major version is +zero. + +* `^1.x` := `>=1.0.0 <2.0.0` +* `^0.x` := `>=0.0.0 <1.0.0` + +### Range Grammar + +Putting all this together, here is a Backus-Naur grammar for ranges, +for the benefit of parser authors: + +```bnf +range-set ::= range ( logical-or range ) * +logical-or ::= ( ' ' ) * '||' ( ' ' ) * +range ::= hyphen | simple ( ' ' simple ) * | '' +hyphen ::= partial ' - ' partial +simple ::= primitive | partial | tilde | caret +primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial +partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )? +xr ::= 'x' | 'X' | '*' | nr +nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) * +tilde ::= '~' partial +caret ::= '^' partial +qualifier ::= ( '-' pre )? ( '+' build )? +pre ::= parts +build ::= parts +parts ::= part ( '.' part ) * +part ::= nr | [-0-9A-Za-z]+ +``` + +## Functions + +All methods and classes take a final `options` object argument. All +options in this object are `false` by default. The options supported +are: + +- `loose` Be more forgiving about not-quite-valid semver strings. + (Any resulting output will always be 100% strict compliant, of + course.) For backwards compatibility reasons, if the `options` + argument is a boolean value instead of an object, it is interpreted + to be the `loose` param. +- `includePrerelease` Set to suppress the [default + behavior](https://github.com/npm/node-semver#prerelease-tags) of + excluding prerelease tagged versions from ranges unless they are + explicitly opted into. + +Strict-mode Comparators and Ranges will be strict about the SemVer +strings that they parse. + +* `valid(v)`: Return the parsed version, or null if it's not valid. +* `inc(v, release)`: Return the version incremented by the release + type (`major`, `premajor`, `minor`, `preminor`, `patch`, + `prepatch`, or `prerelease`), or null if it's not valid + * `premajor` in one call will bump the version up to the next major + version and down to a prerelease of that major version. + `preminor`, and `prepatch` work the same way. + * If called from a non-prerelease version, the `prerelease` will work the + same as `prepatch`. It increments the patch version, then makes a + prerelease. If the input version is already a prerelease it simply + increments it. +* `prerelease(v)`: Returns an array of prerelease components, or null + if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]` +* `major(v)`: Return the major version number. +* `minor(v)`: Return the minor version number. +* `patch(v)`: Return the patch version number. +* `intersects(r1, r2, loose)`: Return true if the two supplied ranges + or comparators intersect. +* `parse(v)`: Attempt to parse a string as a semantic version, returning either + a `SemVer` object or `null`. + +### Comparison + +* `gt(v1, v2)`: `v1 > v2` +* `gte(v1, v2)`: `v1 >= v2` +* `lt(v1, v2)`: `v1 < v2` +* `lte(v1, v2)`: `v1 <= v2` +* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent, + even if they're not the exact same string. You already know how to + compare strings. +* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`. +* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call + the corresponding function above. `"==="` and `"!=="` do simple + string comparison, but are included for completeness. Throws if an + invalid comparison string is provided. +* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if + `v2` is greater. Sorts in ascending order if passed to `Array.sort()`. +* `rcompare(v1, v2)`: The reverse of compare. Sorts an array of versions + in descending order when passed to `Array.sort()`. +* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions + are equal. Sorts in ascending order if passed to `Array.sort()`. + `v2` is greater. Sorts in ascending order if passed to `Array.sort()`. +* `diff(v1, v2)`: Returns difference between two versions by the release type + (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`), + or null if the versions are the same. + +### Comparators + +* `intersects(comparator)`: Return true if the comparators intersect + +### Ranges + +* `validRange(range)`: Return the valid range or null if it's not valid +* `satisfies(version, range)`: Return true if the version satisfies the + range. +* `maxSatisfying(versions, range)`: Return the highest version in the list + that satisfies the range, or `null` if none of them do. +* `minSatisfying(versions, range)`: Return the lowest version in the list + that satisfies the range, or `null` if none of them do. +* `minVersion(range)`: Return the lowest version that can possibly match + the given range. +* `gtr(version, range)`: Return `true` if version is greater than all the + versions possible in the range. +* `ltr(version, range)`: Return `true` if version is less than all the + versions possible in the range. +* `outside(version, range, hilo)`: Return true if the version is outside + the bounds of the range in either the high or low direction. The + `hilo` argument must be either the string `'>'` or `'<'`. (This is + the function called by `gtr` and `ltr`.) +* `intersects(range)`: Return true if any of the ranges comparators intersect + +Note that, since ranges may be non-contiguous, a version might not be +greater than a range, less than a range, *or* satisfy a range! For +example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9` +until `2.0.0`, so the version `1.2.10` would not be greater than the +range (because `2.0.1` satisfies, which is higher), nor less than the +range (since `1.2.8` satisfies, which is lower), and it also does not +satisfy the range. + +If you want to know if a version satisfies or does not satisfy a +range, use the `satisfies(version, range)` function. + +### Coercion + +* `coerce(version, options)`: Coerces a string to semver if possible + +This aims to provide a very forgiving translation of a non-semver string to +semver. It looks for the first digit in a string, and consumes all +remaining characters which satisfy at least a partial semver (e.g., `1`, +`1.2`, `1.2.3`) up to the max permitted length (256 characters). Longer +versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`). All +surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes +`3.4.0`). Only text which lacks digits will fail coercion (`version one` +is not valid). The maximum length for any semver component considered for +coercion is 16 characters; longer components will be ignored +(`10000000000000000.4.7.4` becomes `4.7.4`). The maximum value for any +semver component is `Integer.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value +components are invalid (`9999999999999999.4.7.4` is likely invalid). + +If the `options.rtl` flag is set, then `coerce` will return the right-most +coercible tuple that does not share an ending index with a longer coercible +tuple. For example, `1.2.3.4` will return `2.3.4` in rtl mode, not +`4.0.0`. `1.2.3/4` will return `4.0.0`, because the `4` is not a part of +any other overlapping SemVer tuple. + +### Clean + +* `clean(version)`: Clean a string to be a valid semver if possible + +This will return a cleaned and trimmed semver version. If the provided version is not valid a null will be returned. This does not work for ranges. + +ex. +* `s.clean(' = v 2.1.5foo')`: `null` +* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'` +* `s.clean(' = v 2.1.5-foo')`: `null` +* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'` +* `s.clean('=v2.1.5')`: `'2.1.5'` +* `s.clean(' =v2.1.5')`: `2.1.5` +* `s.clean(' 2.1.5 ')`: `'2.1.5'` +* `s.clean('~1.0.0')`: `null` Index: frontend/node_modules/@babel/eslint-parser/node_modules/semver/bin/semver.js =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/semver/bin/semver.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/semver/bin/semver.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,174 @@ +#!/usr/bin/env node +// Standalone semver comparison program. +// Exits successfully and prints matching version(s) if +// any supplied version is valid and passes all tests. + +var argv = process.argv.slice(2) + +var versions = [] + +var range = [] + +var inc = null + +var version = require('../package.json').version + +var loose = false + +var includePrerelease = false + +var coerce = false + +var rtl = false + +var identifier + +var semver = require('../semver') + +var reverse = false + +var options = {} + +main() + +function main () { + if (!argv.length) return help() + while (argv.length) { + var a = argv.shift() + var indexOfEqualSign = a.indexOf('=') + if (indexOfEqualSign !== -1) { + a = a.slice(0, indexOfEqualSign) + argv.unshift(a.slice(indexOfEqualSign + 1)) + } + switch (a) { + case '-rv': case '-rev': case '--rev': case '--reverse': + reverse = true + break + case '-l': case '--loose': + loose = true + break + case '-p': case '--include-prerelease': + includePrerelease = true + break + case '-v': case '--version': + versions.push(argv.shift()) + break + case '-i': case '--inc': case '--increment': + switch (argv[0]) { + case 'major': case 'minor': case 'patch': case 'prerelease': + case 'premajor': case 'preminor': case 'prepatch': + inc = argv.shift() + break + default: + inc = 'patch' + break + } + break + case '--preid': + identifier = argv.shift() + break + case '-r': case '--range': + range.push(argv.shift()) + break + case '-c': case '--coerce': + coerce = true + break + case '--rtl': + rtl = true + break + case '--ltr': + rtl = false + break + case '-h': case '--help': case '-?': + return help() + default: + versions.push(a) + break + } + } + + var options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl } + + versions = versions.map(function (v) { + return coerce ? (semver.coerce(v, options) || { version: v }).version : v + }).filter(function (v) { + return semver.valid(v) + }) + if (!versions.length) return fail() + if (inc && (versions.length !== 1 || range.length)) { return failInc() } + + for (var i = 0, l = range.length; i < l; i++) { + versions = versions.filter(function (v) { + return semver.satisfies(v, range[i], options) + }) + if (!versions.length) return fail() + } + return success(versions) +} + +function failInc () { + console.error('--inc can only be used on a single version with no range') + fail() +} + +function fail () { process.exit(1) } + +function success () { + var compare = reverse ? 'rcompare' : 'compare' + versions.sort(function (a, b) { + return semver[compare](a, b, options) + }).map(function (v) { + return semver.clean(v, options) + }).map(function (v) { + return inc ? semver.inc(v, inc, options, identifier) : v + }).forEach(function (v, i, _) { console.log(v) }) +} + +function help () { + console.log(['SemVer ' + version, + '', + 'A JavaScript implementation of the https://semver.org/ specification', + 'Copyright Isaac Z. Schlueter', + '', + 'Usage: semver [options] [ [...]]', + 'Prints valid versions sorted by SemVer precedence', + '', + 'Options:', + '-r --range ', + ' Print versions that match the specified range.', + '', + '-i --increment []', + ' Increment a version by the specified level. Level can', + ' be one of: major, minor, patch, premajor, preminor,', + " prepatch, or prerelease. Default level is 'patch'.", + ' Only one version may be specified.', + '', + '--preid ', + ' Identifier to be used to prefix premajor, preminor,', + ' prepatch or prerelease version increments.', + '', + '-l --loose', + ' Interpret versions and ranges loosely', + '', + '-p --include-prerelease', + ' Always include prerelease versions in range matching', + '', + '-c --coerce', + ' Coerce a string into SemVer if possible', + ' (does not imply --loose)', + '', + '--rtl', + ' Coerce version strings right to left', + '', + '--ltr', + ' Coerce version strings left to right (default)', + '', + 'Program exits successfully if any valid version satisfies', + 'all supplied ranges, and prints all satisfying versions.', + '', + 'If no satisfying versions are found, then exits failure.', + '', + 'Versions are printed in ascending order, so supplying', + 'multiple versions to the utility will just sort them.' + ].join('\n')) +} Index: frontend/node_modules/@babel/eslint-parser/node_modules/semver/package.json =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/semver/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/semver/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,38 @@ +{ + "name": "semver", + "version": "6.3.1", + "description": "The semantic version parser used by npm.", + "main": "semver.js", + "scripts": { + "test": "tap test/ --100 --timeout=30", + "lint": "echo linting disabled", + "postlint": "template-oss-check", + "template-oss-apply": "template-oss-apply --force", + "lintfix": "npm run lint -- --fix", + "snap": "tap test/ --100 --timeout=30", + "posttest": "npm run lint" + }, + "devDependencies": { + "@npmcli/template-oss": "4.17.0", + "tap": "^12.7.0" + }, + "license": "ISC", + "repository": { + "type": "git", + "url": "https://github.com/npm/node-semver.git" + }, + "bin": { + "semver": "./bin/semver.js" + }, + "files": [ + "bin", + "range.bnf", + "semver.js" + ], + "author": "GitHub Inc.", + "templateOSS": { + "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.", + "content": "./scripts/template-oss", + "version": "4.17.0" + } +} Index: frontend/node_modules/@babel/eslint-parser/node_modules/semver/range.bnf =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/semver/range.bnf (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/semver/range.bnf (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,16 @@ +range-set ::= range ( logical-or range ) * +logical-or ::= ( ' ' ) * '||' ( ' ' ) * +range ::= hyphen | simple ( ' ' simple ) * | '' +hyphen ::= partial ' - ' partial +simple ::= primitive | partial | tilde | caret +primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial +partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )? +xr ::= 'x' | 'X' | '*' | nr +nr ::= '0' | [1-9] ( [0-9] ) * +tilde ::= '~' partial +caret ::= '^' partial +qualifier ::= ( '-' pre )? ( '+' build )? +pre ::= parts +build ::= parts +parts ::= part ( '.' part ) * +part ::= nr | [-0-9A-Za-z]+ Index: frontend/node_modules/@babel/eslint-parser/node_modules/semver/semver.js =================================================================== --- frontend/node_modules/@babel/eslint-parser/node_modules/semver/semver.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/node_modules/semver/semver.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,1643 @@ +exports = module.exports = SemVer + +var debug +/* istanbul ignore next */ +if (typeof process === 'object' && + process.env && + process.env.NODE_DEBUG && + /\bsemver\b/i.test(process.env.NODE_DEBUG)) { + debug = function () { + var args = Array.prototype.slice.call(arguments, 0) + args.unshift('SEMVER') + console.log.apply(console, args) + } +} else { + debug = function () {} +} + +// Note: this is the semver.org version of the spec that it implements +// Not necessarily the package version of this code. +exports.SEMVER_SPEC_VERSION = '2.0.0' + +var MAX_LENGTH = 256 +var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || + /* istanbul ignore next */ 9007199254740991 + +// Max safe segment length for coercion. +var MAX_SAFE_COMPONENT_LENGTH = 16 + +var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6 + +// The actual regexps go on exports.re +var re = exports.re = [] +var safeRe = exports.safeRe = [] +var src = exports.src = [] +var t = exports.tokens = {} +var R = 0 + +function tok (n) { + t[n] = R++ +} + +var LETTERDASHNUMBER = '[a-zA-Z0-9-]' + +// Replace some greedy regex tokens to prevent regex dos issues. These regex are +// used internally via the safeRe object since all inputs in this library get +// normalized first to trim and collapse all extra whitespace. The original +// regexes are exported for userland consumption and lower level usage. A +// future breaking change could export the safer regex only with a note that +// all input should have extra whitespace removed. +var safeRegexReplacements = [ + ['\\s', 1], + ['\\d', MAX_LENGTH], + [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH], +] + +function makeSafeRe (value) { + for (var i = 0; i < safeRegexReplacements.length; i++) { + var token = safeRegexReplacements[i][0] + var max = safeRegexReplacements[i][1] + value = value + .split(token + '*').join(token + '{0,' + max + '}') + .split(token + '+').join(token + '{1,' + max + '}') + } + return value +} + +// The following Regular Expressions can be used for tokenizing, +// validating, and parsing SemVer version strings. + +// ## Numeric Identifier +// A single `0`, or a non-zero digit followed by zero or more digits. + +tok('NUMERICIDENTIFIER') +src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*' +tok('NUMERICIDENTIFIERLOOSE') +src[t.NUMERICIDENTIFIERLOOSE] = '\\d+' + +// ## Non-numeric Identifier +// Zero or more digits, followed by a letter or hyphen, and then zero or +// more letters, digits, or hyphens. + +tok('NONNUMERICIDENTIFIER') +src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-]' + LETTERDASHNUMBER + '*' + +// ## Main Version +// Three dot-separated numeric identifiers. + +tok('MAINVERSION') +src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIER] + ')' + +tok('MAINVERSIONLOOSE') +src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')' + +// ## Pre-release Version Identifier +// A numeric identifier, or a non-numeric identifier. + +tok('PRERELEASEIDENTIFIER') +src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +tok('PRERELEASEIDENTIFIERLOOSE') +src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + + '|' + src[t.NONNUMERICIDENTIFIER] + ')' + +// ## Pre-release Version +// Hyphen, followed by one or more dot-separated pre-release version +// identifiers. + +tok('PRERELEASE') +src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))' + +tok('PRERELEASELOOSE') +src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))' + +// ## Build Metadata Identifier +// Any combination of digits, letters, or hyphens. + +tok('BUILDIDENTIFIER') +src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + '+' + +// ## Build Metadata +// Plus sign, followed by one or more period-separated build metadata +// identifiers. + +tok('BUILD') +src[t.BUILD] = '(?:\\+(' + src[t.BUILDIDENTIFIER] + + '(?:\\.' + src[t.BUILDIDENTIFIER] + ')*))' + +// ## Full Version String +// A main version, followed optionally by a pre-release version and +// build metadata. + +// Note that the only major, minor, patch, and pre-release sections of +// the version string are capturing groups. The build metadata is not a +// capturing group, because it should not ever be used in version +// comparison. + +tok('FULL') +tok('FULLPLAIN') +src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + + src[t.PRERELEASE] + '?' + + src[t.BUILD] + '?' + +src[t.FULL] = '^' + src[t.FULLPLAIN] + '$' + +// like full, but allows v1.2.3 and =1.2.3, which people do sometimes. +// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty +// common in the npm registry. +tok('LOOSEPLAIN') +src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + + src[t.PRERELEASELOOSE] + '?' + + src[t.BUILD] + '?' + +tok('LOOSE') +src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$' + +tok('GTLT') +src[t.GTLT] = '((?:<|>)?=?)' + +// Something like "2.*" or "1.2.x". +// Note that "x.x" is a valid xRange identifer, meaning "any version" +// Only the first item is strictly required. +tok('XRANGEIDENTIFIERLOOSE') +src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*' +tok('XRANGEIDENTIFIER') +src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*' + +tok('XRANGEPLAIN') +src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + + '(?:' + src[t.PRERELEASE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGEPLAINLOOSE') +src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + + '(?:' + src[t.PRERELEASELOOSE] + ')?' + + src[t.BUILD] + '?' + + ')?)?' + +tok('XRANGE') +src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$' +tok('XRANGELOOSE') +src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$' + +// Coercion. +// Extract anything that could conceivably be a part of a valid semver +tok('COERCE') +src[t.COERCE] = '(^|[^\\d])' + + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + + '(?:$|[^\\d])' +tok('COERCERTL') +re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g') +safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), 'g') + +// Tilde ranges. +// Meaning is "reasonably at or greater than" +tok('LONETILDE') +src[t.LONETILDE] = '(?:~>?)' + +tok('TILDETRIM') +src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+' +re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g') +safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), 'g') +var tildeTrimReplace = '$1~' + +tok('TILDE') +src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$' +tok('TILDELOOSE') +src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$' + +// Caret ranges. +// Meaning is "at least and backwards compatible with" +tok('LONECARET') +src[t.LONECARET] = '(?:\\^)' + +tok('CARETTRIM') +src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+' +re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g') +safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), 'g') +var caretTrimReplace = '$1^' + +tok('CARET') +src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$' +tok('CARETLOOSE') +src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$' + +// A simple gt/lt/eq thing, or just "" to indicate "any version" +tok('COMPARATORLOOSE') +src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$' +tok('COMPARATOR') +src[t.COMPARATOR] = '^' + src[t.GTLT] + '\\s*(' + src[t.FULLPLAIN] + ')$|^$' + +// An expression to strip any whitespace between the gtlt and the thing +// it modifies, so that `> 1.2.3` ==> `>1.2.3` +tok('COMPARATORTRIM') +src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')' + +// this one has to use the /g flag +re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g') +safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), 'g') +var comparatorTrimReplace = '$1$2$3' + +// Something like `1.2.3 - 1.2.4` +// Note that these all use the loose form, because they'll be +// checked against either the strict or loose comparator form +// later. +tok('HYPHENRANGE') +src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAIN] + ')' + + '\\s*$' + +tok('HYPHENRANGELOOSE') +src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s+-\\s+' + + '(' + src[t.XRANGEPLAINLOOSE] + ')' + + '\\s*$' + +// Star ranges basically just allow anything at all. +tok('STAR') +src[t.STAR] = '(<|>)?=?\\s*\\*' + +// Compile to actual regexp objects. +// All are flag-free, unless they were created above with a flag. +for (var i = 0; i < R; i++) { + debug(i, src[i]) + if (!re[i]) { + re[i] = new RegExp(src[i]) + + // Replace all greedy whitespace to prevent regex dos issues. These regex are + // used internally via the safeRe object since all inputs in this library get + // normalized first to trim and collapse all extra whitespace. The original + // regexes are exported for userland consumption and lower level usage. A + // future breaking change could export the safer regex only with a note that + // all input should have extra whitespace removed. + safeRe[i] = new RegExp(makeSafeRe(src[i])) + } +} + +exports.parse = parse +function parse (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (version instanceof SemVer) { + return version + } + + if (typeof version !== 'string') { + return null + } + + if (version.length > MAX_LENGTH) { + return null + } + + var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL] + if (!r.test(version)) { + return null + } + + try { + return new SemVer(version, options) + } catch (er) { + return null + } +} + +exports.valid = valid +function valid (version, options) { + var v = parse(version, options) + return v ? v.version : null +} + +exports.clean = clean +function clean (version, options) { + var s = parse(version.trim().replace(/^[=v]+/, ''), options) + return s ? s.version : null +} + +exports.SemVer = SemVer + +function SemVer (version, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + if (version instanceof SemVer) { + if (version.loose === options.loose) { + return version + } else { + version = version.version + } + } else if (typeof version !== 'string') { + throw new TypeError('Invalid Version: ' + version) + } + + if (version.length > MAX_LENGTH) { + throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') + } + + if (!(this instanceof SemVer)) { + return new SemVer(version, options) + } + + debug('SemVer', version, options) + this.options = options + this.loose = !!options.loose + + var m = version.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]) + + if (!m) { + throw new TypeError('Invalid Version: ' + version) + } + + this.raw = version + + // these are actually numbers + this.major = +m[1] + this.minor = +m[2] + this.patch = +m[3] + + if (this.major > MAX_SAFE_INTEGER || this.major < 0) { + throw new TypeError('Invalid major version') + } + + if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) { + throw new TypeError('Invalid minor version') + } + + if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) { + throw new TypeError('Invalid patch version') + } + + // numberify any prerelease numeric ids + if (!m[4]) { + this.prerelease = [] + } else { + this.prerelease = m[4].split('.').map(function (id) { + if (/^[0-9]+$/.test(id)) { + var num = +id + if (num >= 0 && num < MAX_SAFE_INTEGER) { + return num + } + } + return id + }) + } + + this.build = m[5] ? m[5].split('.') : [] + this.format() +} + +SemVer.prototype.format = function () { + this.version = this.major + '.' + this.minor + '.' + this.patch + if (this.prerelease.length) { + this.version += '-' + this.prerelease.join('.') + } + return this.version +} + +SemVer.prototype.toString = function () { + return this.version +} + +SemVer.prototype.compare = function (other) { + debug('SemVer.compare', this.version, this.options, other) + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return this.compareMain(other) || this.comparePre(other) +} + +SemVer.prototype.compareMain = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + return compareIdentifiers(this.major, other.major) || + compareIdentifiers(this.minor, other.minor) || + compareIdentifiers(this.patch, other.patch) +} + +SemVer.prototype.comparePre = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + // NOT having a prerelease is > having one + if (this.prerelease.length && !other.prerelease.length) { + return -1 + } else if (!this.prerelease.length && other.prerelease.length) { + return 1 + } else if (!this.prerelease.length && !other.prerelease.length) { + return 0 + } + + var i = 0 + do { + var a = this.prerelease[i] + var b = other.prerelease[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +SemVer.prototype.compareBuild = function (other) { + if (!(other instanceof SemVer)) { + other = new SemVer(other, this.options) + } + + var i = 0 + do { + var a = this.build[i] + var b = other.build[i] + debug('prerelease compare', i, a, b) + if (a === undefined && b === undefined) { + return 0 + } else if (b === undefined) { + return 1 + } else if (a === undefined) { + return -1 + } else if (a === b) { + continue + } else { + return compareIdentifiers(a, b) + } + } while (++i) +} + +// preminor will bump the version up to the next minor release, and immediately +// down to pre-release. premajor and prepatch work the same way. +SemVer.prototype.inc = function (release, identifier) { + switch (release) { + case 'premajor': + this.prerelease.length = 0 + this.patch = 0 + this.minor = 0 + this.major++ + this.inc('pre', identifier) + break + case 'preminor': + this.prerelease.length = 0 + this.patch = 0 + this.minor++ + this.inc('pre', identifier) + break + case 'prepatch': + // If this is already a prerelease, it will bump to the next version + // drop any prereleases that might already exist, since they are not + // relevant at this point. + this.prerelease.length = 0 + this.inc('patch', identifier) + this.inc('pre', identifier) + break + // If the input is a non-prerelease version, this acts the same as + // prepatch. + case 'prerelease': + if (this.prerelease.length === 0) { + this.inc('patch', identifier) + } + this.inc('pre', identifier) + break + + case 'major': + // If this is a pre-major version, bump up to the same major version. + // Otherwise increment major. + // 1.0.0-5 bumps to 1.0.0 + // 1.1.0 bumps to 2.0.0 + if (this.minor !== 0 || + this.patch !== 0 || + this.prerelease.length === 0) { + this.major++ + } + this.minor = 0 + this.patch = 0 + this.prerelease = [] + break + case 'minor': + // If this is a pre-minor version, bump up to the same minor version. + // Otherwise increment minor. + // 1.2.0-5 bumps to 1.2.0 + // 1.2.1 bumps to 1.3.0 + if (this.patch !== 0 || this.prerelease.length === 0) { + this.minor++ + } + this.patch = 0 + this.prerelease = [] + break + case 'patch': + // If this is not a pre-release version, it will increment the patch. + // If it is a pre-release it will bump up to the same patch version. + // 1.2.0-5 patches to 1.2.0 + // 1.2.0 patches to 1.2.1 + if (this.prerelease.length === 0) { + this.patch++ + } + this.prerelease = [] + break + // This probably shouldn't be used publicly. + // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction. + case 'pre': + if (this.prerelease.length === 0) { + this.prerelease = [0] + } else { + var i = this.prerelease.length + while (--i >= 0) { + if (typeof this.prerelease[i] === 'number') { + this.prerelease[i]++ + i = -2 + } + } + if (i === -1) { + // didn't increment anything + this.prerelease.push(0) + } + } + if (identifier) { + // 1.2.0-beta.1 bumps to 1.2.0-beta.2, + // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0 + if (this.prerelease[0] === identifier) { + if (isNaN(this.prerelease[1])) { + this.prerelease = [identifier, 0] + } + } else { + this.prerelease = [identifier, 0] + } + } + break + + default: + throw new Error('invalid increment argument: ' + release) + } + this.format() + this.raw = this.version + return this +} + +exports.inc = inc +function inc (version, release, loose, identifier) { + if (typeof (loose) === 'string') { + identifier = loose + loose = undefined + } + + try { + return new SemVer(version, loose).inc(release, identifier).version + } catch (er) { + return null + } +} + +exports.diff = diff +function diff (version1, version2) { + if (eq(version1, version2)) { + return null + } else { + var v1 = parse(version1) + var v2 = parse(version2) + var prefix = '' + if (v1.prerelease.length || v2.prerelease.length) { + prefix = 'pre' + var defaultResult = 'prerelease' + } + for (var key in v1) { + if (key === 'major' || key === 'minor' || key === 'patch') { + if (v1[key] !== v2[key]) { + return prefix + key + } + } + } + return defaultResult // may be undefined + } +} + +exports.compareIdentifiers = compareIdentifiers + +var numeric = /^[0-9]+$/ +function compareIdentifiers (a, b) { + var anum = numeric.test(a) + var bnum = numeric.test(b) + + if (anum && bnum) { + a = +a + b = +b + } + + return a === b ? 0 + : (anum && !bnum) ? -1 + : (bnum && !anum) ? 1 + : a < b ? -1 + : 1 +} + +exports.rcompareIdentifiers = rcompareIdentifiers +function rcompareIdentifiers (a, b) { + return compareIdentifiers(b, a) +} + +exports.major = major +function major (a, loose) { + return new SemVer(a, loose).major +} + +exports.minor = minor +function minor (a, loose) { + return new SemVer(a, loose).minor +} + +exports.patch = patch +function patch (a, loose) { + return new SemVer(a, loose).patch +} + +exports.compare = compare +function compare (a, b, loose) { + return new SemVer(a, loose).compare(new SemVer(b, loose)) +} + +exports.compareLoose = compareLoose +function compareLoose (a, b) { + return compare(a, b, true) +} + +exports.compareBuild = compareBuild +function compareBuild (a, b, loose) { + var versionA = new SemVer(a, loose) + var versionB = new SemVer(b, loose) + return versionA.compare(versionB) || versionA.compareBuild(versionB) +} + +exports.rcompare = rcompare +function rcompare (a, b, loose) { + return compare(b, a, loose) +} + +exports.sort = sort +function sort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(a, b, loose) + }) +} + +exports.rsort = rsort +function rsort (list, loose) { + return list.sort(function (a, b) { + return exports.compareBuild(b, a, loose) + }) +} + +exports.gt = gt +function gt (a, b, loose) { + return compare(a, b, loose) > 0 +} + +exports.lt = lt +function lt (a, b, loose) { + return compare(a, b, loose) < 0 +} + +exports.eq = eq +function eq (a, b, loose) { + return compare(a, b, loose) === 0 +} + +exports.neq = neq +function neq (a, b, loose) { + return compare(a, b, loose) !== 0 +} + +exports.gte = gte +function gte (a, b, loose) { + return compare(a, b, loose) >= 0 +} + +exports.lte = lte +function lte (a, b, loose) { + return compare(a, b, loose) <= 0 +} + +exports.cmp = cmp +function cmp (a, op, b, loose) { + switch (op) { + case '===': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a === b + + case '!==': + if (typeof a === 'object') + a = a.version + if (typeof b === 'object') + b = b.version + return a !== b + + case '': + case '=': + case '==': + return eq(a, b, loose) + + case '!=': + return neq(a, b, loose) + + case '>': + return gt(a, b, loose) + + case '>=': + return gte(a, b, loose) + + case '<': + return lt(a, b, loose) + + case '<=': + return lte(a, b, loose) + + default: + throw new TypeError('Invalid operator: ' + op) + } +} + +exports.Comparator = Comparator +function Comparator (comp, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (comp instanceof Comparator) { + if (comp.loose === !!options.loose) { + return comp + } else { + comp = comp.value + } + } + + if (!(this instanceof Comparator)) { + return new Comparator(comp, options) + } + + comp = comp.trim().split(/\s+/).join(' ') + debug('comparator', comp, options) + this.options = options + this.loose = !!options.loose + this.parse(comp) + + if (this.semver === ANY) { + this.value = '' + } else { + this.value = this.operator + this.semver.version + } + + debug('comp', this) +} + +var ANY = {} +Comparator.prototype.parse = function (comp) { + var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR] + var m = comp.match(r) + + if (!m) { + throw new TypeError('Invalid comparator: ' + comp) + } + + this.operator = m[1] !== undefined ? m[1] : '' + if (this.operator === '=') { + this.operator = '' + } + + // if it literally is just '>' or '' then allow anything. + if (!m[2]) { + this.semver = ANY + } else { + this.semver = new SemVer(m[2], this.options.loose) + } +} + +Comparator.prototype.toString = function () { + return this.value +} + +Comparator.prototype.test = function (version) { + debug('Comparator.test', version, this.options.loose) + + if (this.semver === ANY || version === ANY) { + return true + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + return cmp(version, this.operator, this.semver, this.options) +} + +Comparator.prototype.intersects = function (comp, options) { + if (!(comp instanceof Comparator)) { + throw new TypeError('a Comparator is required') + } + + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + var rangeTmp + + if (this.operator === '') { + if (this.value === '') { + return true + } + rangeTmp = new Range(comp.value, options) + return satisfies(this.value, rangeTmp, options) + } else if (comp.operator === '') { + if (comp.value === '') { + return true + } + rangeTmp = new Range(this.value, options) + return satisfies(comp.semver, rangeTmp, options) + } + + var sameDirectionIncreasing = + (this.operator === '>=' || this.operator === '>') && + (comp.operator === '>=' || comp.operator === '>') + var sameDirectionDecreasing = + (this.operator === '<=' || this.operator === '<') && + (comp.operator === '<=' || comp.operator === '<') + var sameSemVer = this.semver.version === comp.semver.version + var differentDirectionsInclusive = + (this.operator === '>=' || this.operator === '<=') && + (comp.operator === '>=' || comp.operator === '<=') + var oppositeDirectionsLessThan = + cmp(this.semver, '<', comp.semver, options) && + ((this.operator === '>=' || this.operator === '>') && + (comp.operator === '<=' || comp.operator === '<')) + var oppositeDirectionsGreaterThan = + cmp(this.semver, '>', comp.semver, options) && + ((this.operator === '<=' || this.operator === '<') && + (comp.operator === '>=' || comp.operator === '>')) + + return sameDirectionIncreasing || sameDirectionDecreasing || + (sameSemVer && differentDirectionsInclusive) || + oppositeDirectionsLessThan || oppositeDirectionsGreaterThan +} + +exports.Range = Range +function Range (range, options) { + if (!options || typeof options !== 'object') { + options = { + loose: !!options, + includePrerelease: false + } + } + + if (range instanceof Range) { + if (range.loose === !!options.loose && + range.includePrerelease === !!options.includePrerelease) { + return range + } else { + return new Range(range.raw, options) + } + } + + if (range instanceof Comparator) { + return new Range(range.value, options) + } + + if (!(this instanceof Range)) { + return new Range(range, options) + } + + this.options = options + this.loose = !!options.loose + this.includePrerelease = !!options.includePrerelease + + // First reduce all whitespace as much as possible so we do not have to rely + // on potentially slow regexes like \s*. This is then stored and used for + // future error messages as well. + this.raw = range + .trim() + .split(/\s+/) + .join(' ') + + // First, split based on boolean or || + this.set = this.raw.split('||').map(function (range) { + return this.parseRange(range.trim()) + }, this).filter(function (c) { + // throw out any that are not relevant for whatever reason + return c.length + }) + + if (!this.set.length) { + throw new TypeError('Invalid SemVer Range: ' + this.raw) + } + + this.format() +} + +Range.prototype.format = function () { + this.range = this.set.map(function (comps) { + return comps.join(' ').trim() + }).join('||').trim() + return this.range +} + +Range.prototype.toString = function () { + return this.range +} + +Range.prototype.parseRange = function (range) { + var loose = this.options.loose + // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4` + var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE] + range = range.replace(hr, hyphenReplace) + debug('hyphen replace', range) + // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5` + range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace) + debug('comparator trim', range, safeRe[t.COMPARATORTRIM]) + + // `~ 1.2.3` => `~1.2.3` + range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace) + + // `^ 1.2.3` => `^1.2.3` + range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace) + + // normalize spaces + range = range.split(/\s+/).join(' ') + + // At this point, the range is completely trimmed and + // ready to be split into comparators. + + var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR] + var set = range.split(' ').map(function (comp) { + return parseComparator(comp, this.options) + }, this).join(' ').split(/\s+/) + if (this.options.loose) { + // in loose mode, throw out any that are not valid comparators + set = set.filter(function (comp) { + return !!comp.match(compRe) + }) + } + set = set.map(function (comp) { + return new Comparator(comp, this.options) + }, this) + + return set +} + +Range.prototype.intersects = function (range, options) { + if (!(range instanceof Range)) { + throw new TypeError('a Range is required') + } + + return this.set.some(function (thisComparators) { + return ( + isSatisfiable(thisComparators, options) && + range.set.some(function (rangeComparators) { + return ( + isSatisfiable(rangeComparators, options) && + thisComparators.every(function (thisComparator) { + return rangeComparators.every(function (rangeComparator) { + return thisComparator.intersects(rangeComparator, options) + }) + }) + ) + }) + ) + }) +} + +// take a set of comparators and determine whether there +// exists a version which can satisfy it +function isSatisfiable (comparators, options) { + var result = true + var remainingComparators = comparators.slice() + var testComparator = remainingComparators.pop() + + while (result && remainingComparators.length) { + result = remainingComparators.every(function (otherComparator) { + return testComparator.intersects(otherComparator, options) + }) + + testComparator = remainingComparators.pop() + } + + return result +} + +// Mostly just for testing and legacy API reasons +exports.toComparators = toComparators +function toComparators (range, options) { + return new Range(range, options).set.map(function (comp) { + return comp.map(function (c) { + return c.value + }).join(' ').trim().split(' ') + }) +} + +// comprised of xranges, tildes, stars, and gtlt's at this point. +// already replaced the hyphen ranges +// turn into a set of JUST comparators. +function parseComparator (comp, options) { + debug('comp', comp, options) + comp = replaceCarets(comp, options) + debug('caret', comp) + comp = replaceTildes(comp, options) + debug('tildes', comp) + comp = replaceXRanges(comp, options) + debug('xrange', comp) + comp = replaceStars(comp, options) + debug('stars', comp) + return comp +} + +function isX (id) { + return !id || id.toLowerCase() === 'x' || id === '*' +} + +// ~, ~> --> * (any, kinda silly) +// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0 +// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0 +// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0 +// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0 +// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0 +function replaceTildes (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceTilde(comp, options) + }).join(' ') +} + +function replaceTilde (comp, options) { + var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE] + return comp.replace(r, function (_, M, m, p, pr) { + debug('tilde', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + // ~1.2 == >=1.2.0 <1.3.0 + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else if (pr) { + debug('replaceTilde pr', pr) + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } else { + // ~1.2.3 == >=1.2.3 <1.3.0 + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + + debug('tilde return', ret) + return ret + }) +} + +// ^ --> * (any, kinda silly) +// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0 +// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0 +// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0 +// ^1.2.3 --> >=1.2.3 <2.0.0 +// ^1.2.0 --> >=1.2.0 <2.0.0 +function replaceCarets (comp, options) { + return comp.trim().split(/\s+/).map(function (comp) { + return replaceCaret(comp, options) + }).join(' ') +} + +function replaceCaret (comp, options) { + debug('caret', comp, options) + var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET] + return comp.replace(r, function (_, M, m, p, pr) { + debug('caret', comp, _, M, m, p, pr) + var ret + + if (isX(M)) { + ret = '' + } else if (isX(m)) { + ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0' + } else if (isX(p)) { + if (M === '0') { + ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0' + } else { + ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0' + } + } else if (pr) { + debug('replaceCaret pr', pr) + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + '-' + pr + + ' <' + (+M + 1) + '.0.0' + } + } else { + debug('no pr') + if (M === '0') { + if (m === '0') { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + m + '.' + (+p + 1) + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + M + '.' + (+m + 1) + '.0' + } + } else { + ret = '>=' + M + '.' + m + '.' + p + + ' <' + (+M + 1) + '.0.0' + } + } + + debug('caret return', ret) + return ret + }) +} + +function replaceXRanges (comp, options) { + debug('replaceXRanges', comp, options) + return comp.split(/\s+/).map(function (comp) { + return replaceXRange(comp, options) + }).join(' ') +} + +function replaceXRange (comp, options) { + comp = comp.trim() + var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE] + return comp.replace(r, function (ret, gtlt, M, m, p, pr) { + debug('xRange', comp, ret, gtlt, M, m, p, pr) + var xM = isX(M) + var xm = xM || isX(m) + var xp = xm || isX(p) + var anyX = xp + + if (gtlt === '=' && anyX) { + gtlt = '' + } + + // if we're including prereleases in the match, then we need + // to fix this to -0, the lowest possible prerelease value + pr = options.includePrerelease ? '-0' : '' + + if (xM) { + if (gtlt === '>' || gtlt === '<') { + // nothing is allowed + ret = '<0.0.0-0' + } else { + // nothing is forbidden + ret = '*' + } + } else if (gtlt && anyX) { + // we know patch is an x, because we have any x at all. + // replace X with 0 + if (xm) { + m = 0 + } + p = 0 + + if (gtlt === '>') { + // >1 => >=2.0.0 + // >1.2 => >=1.3.0 + // >1.2.3 => >= 1.2.4 + gtlt = '>=' + if (xm) { + M = +M + 1 + m = 0 + p = 0 + } else { + m = +m + 1 + p = 0 + } + } else if (gtlt === '<=') { + // <=0.7.x is actually <0.8.0, since any 0.7.x should + // pass. Similarly, <=7.x is actually <8.0.0, etc. + gtlt = '<' + if (xm) { + M = +M + 1 + } else { + m = +m + 1 + } + } + + ret = gtlt + M + '.' + m + '.' + p + pr + } else if (xm) { + ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr + } else if (xp) { + ret = '>=' + M + '.' + m + '.0' + pr + + ' <' + M + '.' + (+m + 1) + '.0' + pr + } + + debug('xRange return', ret) + + return ret + }) +} + +// Because * is AND-ed with everything else in the comparator, +// and '' means "any version", just remove the *s entirely. +function replaceStars (comp, options) { + debug('replaceStars', comp, options) + // Looseness is ignored here. star is always as loose as it gets! + return comp.trim().replace(safeRe[t.STAR], '') +} + +// This function is passed to string.replace(re[t.HYPHENRANGE]) +// M, m, patch, prerelease, build +// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5 +// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do +// 1.2 - 3.4 => >=1.2.0 <3.5.0 +function hyphenReplace ($0, + from, fM, fm, fp, fpr, fb, + to, tM, tm, tp, tpr, tb) { + if (isX(fM)) { + from = '' + } else if (isX(fm)) { + from = '>=' + fM + '.0.0' + } else if (isX(fp)) { + from = '>=' + fM + '.' + fm + '.0' + } else { + from = '>=' + from + } + + if (isX(tM)) { + to = '' + } else if (isX(tm)) { + to = '<' + (+tM + 1) + '.0.0' + } else if (isX(tp)) { + to = '<' + tM + '.' + (+tm + 1) + '.0' + } else if (tpr) { + to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr + } else { + to = '<=' + to + } + + return (from + ' ' + to).trim() +} + +// if ANY of the sets match ALL of its comparators, then pass +Range.prototype.test = function (version) { + if (!version) { + return false + } + + if (typeof version === 'string') { + try { + version = new SemVer(version, this.options) + } catch (er) { + return false + } + } + + for (var i = 0; i < this.set.length; i++) { + if (testSet(this.set[i], version, this.options)) { + return true + } + } + return false +} + +function testSet (set, version, options) { + for (var i = 0; i < set.length; i++) { + if (!set[i].test(version)) { + return false + } + } + + if (version.prerelease.length && !options.includePrerelease) { + // Find the set of versions that are allowed to have prereleases + // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0 + // That should allow `1.2.3-pr.2` to pass. + // However, `1.2.4-alpha.notready` should NOT be allowed, + // even though it's within the range set by the comparators. + for (i = 0; i < set.length; i++) { + debug(set[i].semver) + if (set[i].semver === ANY) { + continue + } + + if (set[i].semver.prerelease.length > 0) { + var allowed = set[i].semver + if (allowed.major === version.major && + allowed.minor === version.minor && + allowed.patch === version.patch) { + return true + } + } + } + + // Version has a -pre, but it's not one of the ones we like. + return false + } + + return true +} + +exports.satisfies = satisfies +function satisfies (version, range, options) { + try { + range = new Range(range, options) + } catch (er) { + return false + } + return range.test(version) +} + +exports.maxSatisfying = maxSatisfying +function maxSatisfying (versions, range, options) { + var max = null + var maxSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!max || maxSV.compare(v) === -1) { + // compare(max, v, true) + max = v + maxSV = new SemVer(max, options) + } + } + }) + return max +} + +exports.minSatisfying = minSatisfying +function minSatisfying (versions, range, options) { + var min = null + var minSV = null + try { + var rangeObj = new Range(range, options) + } catch (er) { + return null + } + versions.forEach(function (v) { + if (rangeObj.test(v)) { + // satisfies(v, range, options) + if (!min || minSV.compare(v) === 1) { + // compare(min, v, true) + min = v + minSV = new SemVer(min, options) + } + } + }) + return min +} + +exports.minVersion = minVersion +function minVersion (range, loose) { + range = new Range(range, loose) + + var minver = new SemVer('0.0.0') + if (range.test(minver)) { + return minver + } + + minver = new SemVer('0.0.0-0') + if (range.test(minver)) { + return minver + } + + minver = null + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + comparators.forEach(function (comparator) { + // Clone to avoid manipulating the comparator's semver object. + var compver = new SemVer(comparator.semver.version) + switch (comparator.operator) { + case '>': + if (compver.prerelease.length === 0) { + compver.patch++ + } else { + compver.prerelease.push(0) + } + compver.raw = compver.format() + /* fallthrough */ + case '': + case '>=': + if (!minver || gt(minver, compver)) { + minver = compver + } + break + case '<': + case '<=': + /* Ignore maximum versions */ + break + /* istanbul ignore next */ + default: + throw new Error('Unexpected operation: ' + comparator.operator) + } + }) + } + + if (minver && range.test(minver)) { + return minver + } + + return null +} + +exports.validRange = validRange +function validRange (range, options) { + try { + // Return '*' instead of '' so that truthiness works. + // This will throw if it's invalid anyway + return new Range(range, options).range || '*' + } catch (er) { + return null + } +} + +// Determine if version is less than all the versions possible in the range +exports.ltr = ltr +function ltr (version, range, options) { + return outside(version, range, '<', options) +} + +// Determine if version is greater than all the versions possible in the range. +exports.gtr = gtr +function gtr (version, range, options) { + return outside(version, range, '>', options) +} + +exports.outside = outside +function outside (version, range, hilo, options) { + version = new SemVer(version, options) + range = new Range(range, options) + + var gtfn, ltefn, ltfn, comp, ecomp + switch (hilo) { + case '>': + gtfn = gt + ltefn = lte + ltfn = lt + comp = '>' + ecomp = '>=' + break + case '<': + gtfn = lt + ltefn = gte + ltfn = gt + comp = '<' + ecomp = '<=' + break + default: + throw new TypeError('Must provide a hilo val of "<" or ">"') + } + + // If it satisifes the range it is not outside + if (satisfies(version, range, options)) { + return false + } + + // From now on, variable terms are as if we're in "gtr" mode. + // but note that everything is flipped for the "ltr" function. + + for (var i = 0; i < range.set.length; ++i) { + var comparators = range.set[i] + + var high = null + var low = null + + comparators.forEach(function (comparator) { + if (comparator.semver === ANY) { + comparator = new Comparator('>=0.0.0') + } + high = high || comparator + low = low || comparator + if (gtfn(comparator.semver, high.semver, options)) { + high = comparator + } else if (ltfn(comparator.semver, low.semver, options)) { + low = comparator + } + }) + + // If the edge version comparator has a operator then our version + // isn't outside it + if (high.operator === comp || high.operator === ecomp) { + return false + } + + // If the lowest version comparator has an operator and our version + // is less than it then it isn't higher than the range + if ((!low.operator || low.operator === comp) && + ltefn(version, low.semver)) { + return false + } else if (low.operator === ecomp && ltfn(version, low.semver)) { + return false + } + } + return true +} + +exports.prerelease = prerelease +function prerelease (version, options) { + var parsed = parse(version, options) + return (parsed && parsed.prerelease.length) ? parsed.prerelease : null +} + +exports.intersects = intersects +function intersects (r1, r2, options) { + r1 = new Range(r1, options) + r2 = new Range(r2, options) + return r1.intersects(r2) +} + +exports.coerce = coerce +function coerce (version, options) { + if (version instanceof SemVer) { + return version + } + + if (typeof version === 'number') { + version = String(version) + } + + if (typeof version !== 'string') { + return null + } + + options = options || {} + + var match = null + if (!options.rtl) { + match = version.match(safeRe[t.COERCE]) + } else { + // Find the right-most coercible string that does not share + // a terminus with a more left-ward coercible string. + // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4' + // + // Walk through the string checking with a /g regexp + // Manually set the index so as to pick up overlapping matches. + // Stop when we get a match that ends at the string end, since no + // coercible string can be more right-ward without the same terminus. + var next + while ((next = safeRe[t.COERCERTL].exec(version)) && + (!match || match.index + match[0].length !== version.length) + ) { + if (!match || + next.index + next[0].length !== match.index + match[0].length) { + match = next + } + safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length + } + // leave it in a clean state + safeRe[t.COERCERTL].lastIndex = -1 + } + + if (match === null) { + return null + } + + return parse(match[2] + + '.' + (match[3] || '0') + + '.' + (match[4] || '0'), options) +} Index: frontend/node_modules/@babel/eslint-parser/package.json =================================================================== --- frontend/node_modules/@babel/eslint-parser/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/package.json (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,55 @@ +{ + "name": "@babel/eslint-parser", + "version": "7.28.6", + "description": "ESLint parser that allows for linting of experimental syntax transformed by Babel", + "author": "The Babel Team (https://babel.dev/team)", + "license": "MIT", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "eslint/babel-eslint-parser" + }, + "publishConfig": { + "access": "public" + }, + "bugs": { + "url": "https://github.com/babel/babel/issues" + }, + "homepage": "https://babel.dev/", + "engines": { + "node": "^10.13.0 || ^12.13.0 || >=14.0.0" + }, + "main": "./lib/index.cjs", + "type": "module", + "types": "./types.d.cts", + "exports": { + ".": { + "default": "./lib/index.cjs", + "types": "./types.d.cts" + }, + "./experimental-worker": { + "default": "./lib/experimental-worker.cjs", + "types": "./types.d.cts" + }, + "./package.json": "./package.json" + }, + "peerDependencies": { + "@babel/core": "^7.11.0", + "eslint": "^7.5.0 || ^8.0.0 || ^9.0.0" + }, + "dependencies": { + "@nicolo-ribaudo/eslint-scope-5-internals": "5.1.1-v1", + "eslint-visitor-keys": "^2.1.0", + "semver": "^6.3.1" + }, + "devDependencies": { + "@babel/core": "^7.28.6", + "@babel/helper-fixtures": "^7.28.6", + "@types/eslint": "^8.56.2", + "@types/estree": "^1.0.5", + "@typescript-eslint/scope-manager": "^6.19.0", + "dedent": "^1.5.3", + "eslint": "^9.21.0", + "typescript-eslint": "^8.48.0" + } +} Index: frontend/node_modules/@babel/eslint-parser/types.d.cts =================================================================== --- frontend/node_modules/@babel/eslint-parser/types.d.cts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/@babel/eslint-parser/types.d.cts (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,9 @@ +import type { ESLint, Linter, AST } from "eslint"; + +export declare const meta: ESLint.ObjectMetaProperties["meta"]; + +export declare const parse: (text: string, options?: any) => AST.Program; +export declare const parseForESLint: ( + text: string, + options?: any +) => Linter.ESLintParseResult;