diff options
Diffstat (limited to 'node_modules/@babel/plugin-transform-block-scoping')
11 files changed, 793 insertions, 0 deletions
diff --git a/node_modules/@babel/plugin-transform-block-scoping/LICENSE b/node_modules/@babel/plugin-transform-block-scoping/LICENSE new file mode 100644 index 00000000..f31575ec --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/LICENSE @@ -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. diff --git a/node_modules/@babel/plugin-transform-block-scoping/README.md b/node_modules/@babel/plugin-transform-block-scoping/README.md new file mode 100644 index 00000000..5750b906 --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/README.md @@ -0,0 +1,19 @@ +# @babel/plugin-transform-block-scoping + +> Compile ES2015 block scoping (const and let) to ES5 + +See our website [@babel/plugin-transform-block-scoping](https://babeljs.io/docs/babel-plugin-transform-block-scoping) for more information. + +## Install + +Using npm: + +```sh +npm install --save-dev @babel/plugin-transform-block-scoping +``` + +or using yarn: + +```sh +yarn add @babel/plugin-transform-block-scoping --dev +``` diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/annex-B_3_3.js b/node_modules/@babel/plugin-transform-block-scoping/lib/annex-B_3_3.js new file mode 100644 index 00000000..5464912f --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/annex-B_3_3.js @@ -0,0 +1,101 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.annexB33FunctionsVisitor = void 0; +exports.isVarScope = isVarScope; +var _core = require("@babel/core"); +const annexB33FunctionsVisitor = { + VariableDeclaration(path) { + if (isStrict(path)) return; + if (path.node.kind !== "var") return; + const varScope = path.scope.getFunctionParent() || path.scope.getProgramParent(); + varScope.path.traverse(functionsToVarVisitor, { + names: Object.keys(path.getBindingIdentifiers()) + }); + }, + BlockStatement(path) { + if (isStrict(path)) return; + if (_core.types.isFunction(path.parent, { + body: path.node + })) return; + transformStatementList(path.get("body")); + }, + SwitchCase(path) { + if (isStrict(path)) return; + transformStatementList(path.get("consequent")); + } +}; +exports.annexB33FunctionsVisitor = annexB33FunctionsVisitor; +function transformStatementList(paths) { + outer: for (const path of paths) { + if (!path.isFunctionDeclaration()) continue; + if (path.node.async || path.node.generator) return; + const { + scope + } = path.parentPath; + if (isVarScope(scope)) return; + const { + name + } = path.node.id; + let currScope = scope; + do { + if (currScope.parent.hasOwnBinding(name)) continue outer; + currScope = currScope.parent; + } while (!isVarScope(currScope)); + maybeTransformBlockScopedFunction(path); + } +} +function maybeTransformBlockScopedFunction(path) { + const { + node, + parentPath: { + scope + } + } = path; + const { + id + } = node; + scope.removeOwnBinding(id.name); + node.id = null; + const varNode = _core.types.variableDeclaration("var", [_core.types.variableDeclarator(id, _core.types.toExpression(node))]); + varNode._blockHoist = 2; + const [varPath] = path.replaceWith(varNode); + scope.registerDeclaration(varPath); +} +const functionsToVarVisitor = { + Scope(path, { + names + }) { + for (const name of names) { + const binding = path.scope.getOwnBinding(name); + if (binding && binding.kind === "hoisted") { + maybeTransformBlockScopedFunction(binding.path); + } + } + }, + "Expression|Declaration"(path) { + path.skip(); + } +}; +function isVarScope(scope) { + return scope.path.isFunctionParent() || scope.path.isProgram(); +} +function isStrict(path) { + return !!path.find(({ + node + }) => { + var _node$directives; + if (_core.types.isProgram(node)) { + if (node.sourceType === "module") return true; + } else if (_core.types.isClass(node)) { + return true; + } else if (!_core.types.isBlockStatement(node)) { + return false; + } + return (_node$directives = node.directives) == null ? void 0 : _node$directives.some(directive => directive.value.value === "use strict"); + }); +} + +//# sourceMappingURL=annex-B_3_3.js.map diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/annex-B_3_3.js.map b/node_modules/@babel/plugin-transform-block-scoping/lib/annex-B_3_3.js.map new file mode 100644 index 00000000..b69793b3 --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/annex-B_3_3.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_core","require","annexB33FunctionsVisitor","VariableDeclaration","path","isStrict","node","kind","varScope","scope","getFunctionParent","getProgramParent","traverse","functionsToVarVisitor","names","Object","keys","getBindingIdentifiers","BlockStatement","t","isFunction","parent","body","transformStatementList","get","SwitchCase","exports","paths","outer","isFunctionDeclaration","async","generator","parentPath","isVarScope","name","id","currScope","hasOwnBinding","maybeTransformBlockScopedFunction","removeOwnBinding","varNode","variableDeclaration","variableDeclarator","toExpression","_blockHoist","varPath","replaceWith","registerDeclaration","Scope","binding","getOwnBinding","Expression|Declaration","skip","isFunctionParent","isProgram","find","_node$directives","sourceType","isClass","isBlockStatement","directives","some","directive","value"],"sources":["../src/annex-B_3_3.ts"],"sourcesContent":["import { types as t } from \"@babel/core\";\nimport type { NodePath, Visitor, Scope } from \"@babel/traverse\";\n\n// Whenever a function declaration in a nested block scope\n// doesn't conflict with a block-scoped binding from an outer\n// scope, we transform it to a variable declaration.\n//\n// This implements the Annex B.3.3 behavior.\n//\n// TODO(Babel 8): Figure out how this should interact with\n// the transform-block-scoped functions plugin (it feels\n// wrong to handle this transform here), and what we want\n// to do with Annex B behavior in general.\n\n// To avoid confusing block-scoped variables transformed to\n// var with original vars, this transformation happens in two\n// different places:\n// 1. For functions that \"conflict\" with var-variables, in\n// the VariableDeclaration visitor.\n// 2. For functions that don't conflict with any variable,\n// in the FunctionDeclaration visitor.\n\nexport const annexB33FunctionsVisitor: Visitor = {\n VariableDeclaration(path) {\n if (isStrict(path)) return;\n if (path.node.kind !== \"var\") return;\n\n const varScope =\n path.scope.getFunctionParent() || path.scope.getProgramParent();\n // eslint-disable-next-line @typescript-eslint/no-use-before-define\n varScope.path.traverse(functionsToVarVisitor, {\n names: Object.keys(path.getBindingIdentifiers()),\n });\n },\n\n // NOTE: These two visitors target the same nodes as the\n // block-scoped-functions plugin\n\n BlockStatement(path) {\n if (isStrict(path)) return;\n if (t.isFunction(path.parent, { body: path.node })) return;\n transformStatementList(path.get(\"body\"));\n },\n\n SwitchCase(path) {\n if (isStrict(path)) return;\n transformStatementList(path.get(\"consequent\"));\n },\n};\n\nfunction transformStatementList(paths: NodePath<t.Statement>[]) {\n outer: for (const path of paths) {\n if (!path.isFunctionDeclaration()) continue;\n // Annex B.3.3 only applies to plain functions.\n if (path.node.async || path.node.generator) return;\n\n const { scope } = path.parentPath;\n if (isVarScope(scope)) return;\n\n const { name } = path.node.id;\n let currScope = scope;\n do {\n if (currScope.parent.hasOwnBinding(name)) continue outer;\n currScope = currScope.parent;\n } while (!isVarScope(currScope));\n\n maybeTransformBlockScopedFunction(path);\n }\n}\n\nfunction maybeTransformBlockScopedFunction(\n path: NodePath<t.FunctionDeclaration>,\n) {\n const {\n node,\n parentPath: { scope },\n } = path;\n\n const { id } = node;\n scope.removeOwnBinding(id.name);\n node.id = null;\n\n const varNode = t.variableDeclaration(\"var\", [\n t.variableDeclarator(id, t.toExpression(node)),\n ]);\n // @ts-expect-error undocumented property\n varNode._blockHoist = 2;\n\n const [varPath] = path.replaceWith(varNode);\n scope.registerDeclaration(varPath);\n}\n\nconst functionsToVarVisitor: Visitor<{ names: string[] }> = {\n Scope(path, { names }) {\n for (const name of names) {\n const binding = path.scope.getOwnBinding(name);\n if (binding && binding.kind === \"hoisted\") {\n maybeTransformBlockScopedFunction(\n binding.path as NodePath<t.FunctionDeclaration>,\n );\n }\n }\n },\n \"Expression|Declaration\"(path) {\n path.skip();\n },\n};\n\nexport function isVarScope(scope: Scope) {\n return scope.path.isFunctionParent() || scope.path.isProgram();\n}\n\nfunction isStrict(path: NodePath) {\n return !!path.find(({ node }) => {\n if (t.isProgram(node)) {\n if (node.sourceType === \"module\") return true;\n } else if (t.isClass(node)) {\n return true;\n } else if (!t.isBlockStatement(node)) {\n return false;\n }\n\n return node.directives?.some(\n directive => directive.value.value === \"use strict\",\n );\n });\n}\n"],"mappings":"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"}
\ No newline at end of file diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/index.js b/node_modules/@babel/plugin-transform-block-scoping/lib/index.js new file mode 100644 index 00000000..6014ff65 --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/index.js @@ -0,0 +1,185 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; +var _helperPluginUtils = require("@babel/helper-plugin-utils"); +var _core = require("@babel/core"); +var _loop = require("./loop.js"); +var _validation = require("./validation.js"); +var _annexB_3_ = require("./annex-B_3_3.js"); +var _default = (0, _helperPluginUtils.declare)((api, opts) => { + api.assertVersion(7); + const { + throwIfClosureRequired = false, + tdz: tdzEnabled = false + } = opts; + if (typeof throwIfClosureRequired !== "boolean") { + throw new Error(`.throwIfClosureRequired must be a boolean, or undefined`); + } + if (typeof tdzEnabled !== "boolean") { + throw new Error(`.tdz must be a boolean, or undefined`); + } + return { + name: "transform-block-scoping", + visitor: _core.traverse.visitors.merge([_annexB_3_.annexB33FunctionsVisitor, { + Loop(path, state) { + const isForStatement = path.isForStatement(); + const headPath = isForStatement ? path.get("init") : path.isForXStatement() ? path.get("left") : null; + let needsBodyWrap = false; + const markNeedsBodyWrap = () => { + if (throwIfClosureRequired) { + throw path.buildCodeFrameError("Compiling let/const in this block would add a closure " + "(throwIfClosureRequired)."); + } + needsBodyWrap = true; + }; + const body = path.get("body"); + let bodyScope; + if (body.isBlockStatement()) { + bodyScope = body.scope; + const bindings = (0, _loop.getLoopBodyBindings)(path); + for (const binding of bindings) { + const { + capturedInClosure + } = (0, _loop.getUsageInBody)(binding, path); + if (capturedInClosure) markNeedsBodyWrap(); + } + } + const captured = []; + const updatedBindingsUsages = new Map(); + if (headPath && isBlockScoped(headPath.node)) { + const names = Object.keys(headPath.getBindingIdentifiers()); + const headScope = headPath.scope; + for (let name of names) { + var _bodyScope; + if ((_bodyScope = bodyScope) != null && _bodyScope.hasOwnBinding(name)) continue; + let binding = headScope.getOwnBinding(name); + if (!binding) { + headScope.crawl(); + binding = headScope.getOwnBinding(name); + } + const { + usages, + capturedInClosure, + hasConstantViolations + } = (0, _loop.getUsageInBody)(binding, path); + if (headScope.parent.hasBinding(name) || headScope.parent.hasGlobal(name)) { + const newName = headScope.generateUid(name); + headScope.rename(name, newName); + name = newName; + } + if (capturedInClosure) { + markNeedsBodyWrap(); + captured.push(name); + } + if (isForStatement && hasConstantViolations) { + updatedBindingsUsages.set(name, usages); + } + } + } + if (needsBodyWrap) { + const varPath = (0, _loop.wrapLoopBody)(path, captured, updatedBindingsUsages); + if (headPath != null && headPath.isVariableDeclaration()) { + transformBlockScopedVariable(headPath, state, tdzEnabled); + } + varPath.get("declarations.0.init").unwrapFunctionEnvironment(); + } + }, + VariableDeclaration(path, state) { + transformBlockScopedVariable(path, state, tdzEnabled); + }, + ClassDeclaration(path) { + const { + id + } = path.node; + if (!id) return; + const { + scope + } = path.parentPath; + if (!(0, _annexB_3_.isVarScope)(scope) && scope.parent.hasBinding(id.name, { + noUids: true + })) { + path.scope.rename(id.name); + } + } + }]) + }; +}); +exports.default = _default; +const conflictingFunctionsVisitor = { + Scope(path, { + names + }) { + for (const name of names) { + const binding = path.scope.getOwnBinding(name); + if (binding && binding.kind === "hoisted") { + path.scope.rename(name); + } + } + }, + "Expression|Declaration"(path) { + path.skip(); + } +}; +function transformBlockScopedVariable(path, state, tdzEnabled) { + if (!isBlockScoped(path.node)) return; + const dynamicTDZNames = (0, _validation.validateUsage)(path, state, tdzEnabled); + path.node.kind = "var"; + const bindingNames = Object.keys(path.getBindingIdentifiers()); + for (const name of bindingNames) { + const binding = path.scope.getOwnBinding(name); + if (!binding) continue; + binding.kind = "var"; + } + if (isInLoop(path) && !(0, _loop.isVarInLoopHead)(path) || dynamicTDZNames.length > 0) { + for (const decl of path.node.declarations) { + var _decl$init; + (_decl$init = decl.init) != null ? _decl$init : decl.init = path.scope.buildUndefinedNode(); + } + } + const blockScope = path.scope; + const varScope = blockScope.getFunctionParent() || blockScope.getProgramParent(); + if (varScope !== blockScope) { + for (const name of bindingNames) { + let newName = name; + if (blockScope.parent.hasBinding(name, { + noUids: true + }) || blockScope.parent.hasGlobal(name)) { + newName = blockScope.generateUid(name); + blockScope.rename(name, newName); + } + blockScope.moveBindingTo(newName, varScope); + } + } + blockScope.path.traverse(conflictingFunctionsVisitor, { + names: bindingNames + }); + for (const name of dynamicTDZNames) { + path.scope.push({ + id: _core.types.identifier(name), + init: state.addHelper("temporalUndefined") + }); + } +} +function isLetOrConst(kind) { + return kind === "let" || kind === "const"; +} +function isInLoop(path) { + if (!path.parentPath) return false; + if (path.parentPath.isLoop()) return true; + if (path.parentPath.isFunctionParent()) return false; + return isInLoop(path.parentPath); +} +function isBlockScoped(node) { + if (!_core.types.isVariableDeclaration(node)) return false; + if (node[_core.types.BLOCK_SCOPED_SYMBOL]) { + return true; + } + if (!isLetOrConst(node.kind) && node.kind !== "using") { + return false; + } + return true; +} + +//# sourceMappingURL=index.js.map diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/index.js.map b/node_modules/@babel/plugin-transform-block-scoping/lib/index.js.map new file mode 100644 index 00000000..9495087e --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/index.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_helperPluginUtils","require","_core","_loop","_validation","_annexB_3_","_default","declare","api","opts","assertVersion","throwIfClosureRequired","tdz","tdzEnabled","Error","name","visitor","traverse","visitors","merge","annexB33FunctionsVisitor","Loop","path","state","isForStatement","headPath","get","isForXStatement","needsBodyWrap","markNeedsBodyWrap","buildCodeFrameError","body","bodyScope","isBlockStatement","scope","bindings","getLoopBodyBindings","binding","capturedInClosure","getUsageInBody","captured","updatedBindingsUsages","Map","isBlockScoped","node","names","Object","keys","getBindingIdentifiers","headScope","_bodyScope","hasOwnBinding","getOwnBinding","crawl","usages","hasConstantViolations","parent","hasBinding","hasGlobal","newName","generateUid","rename","push","set","varPath","wrapLoopBody","isVariableDeclaration","transformBlockScopedVariable","unwrapFunctionEnvironment","VariableDeclaration","ClassDeclaration","id","parentPath","isVarScope","noUids","exports","default","conflictingFunctionsVisitor","Scope","kind","Expression|Declaration","skip","dynamicTDZNames","validateUsage","bindingNames","isInLoop","isVarInLoopHead","length","decl","declarations","_decl$init","init","buildUndefinedNode","blockScope","varScope","getFunctionParent","getProgramParent","moveBindingTo","t","identifier","addHelper","isLetOrConst","isLoop","isFunctionParent","BLOCK_SCOPED_SYMBOL"],"sources":["../src/index.ts"],"sourcesContent":["import { declare } from \"@babel/helper-plugin-utils\";\nimport type { NodePath, Scope, Visitor } from \"@babel/traverse\";\nimport { type PluginPass, types as t, traverse } from \"@babel/core\";\n\nimport {\n getLoopBodyBindings,\n getUsageInBody,\n isVarInLoopHead,\n wrapLoopBody,\n} from \"./loop.ts\";\nimport { validateUsage } from \"./validation.ts\";\nimport { annexB33FunctionsVisitor, isVarScope } from \"./annex-B_3_3.ts\";\n\nexport interface Options {\n tdz?: boolean;\n throwIfClosureRequired?: boolean;\n}\n\nexport default declare((api, opts: Options) => {\n api.assertVersion(7);\n\n const { throwIfClosureRequired = false, tdz: tdzEnabled = false } = opts;\n if (typeof throwIfClosureRequired !== \"boolean\") {\n throw new Error(`.throwIfClosureRequired must be a boolean, or undefined`);\n }\n if (typeof tdzEnabled !== \"boolean\") {\n throw new Error(`.tdz must be a boolean, or undefined`);\n }\n\n return {\n name: \"transform-block-scoping\",\n\n visitor: traverse.visitors.merge<PluginPass>([\n // TODO: Consider adding an option to control Annex B behavior.\n annexB33FunctionsVisitor,\n {\n Loop(path: NodePath<t.Loop>, state) {\n const isForStatement = path.isForStatement();\n const headPath = isForStatement\n ? path.get(\"init\")\n : path.isForXStatement()\n ? path.get(\"left\")\n : null;\n\n let needsBodyWrap = false;\n const markNeedsBodyWrap = () => {\n if (throwIfClosureRequired) {\n throw path.buildCodeFrameError(\n \"Compiling let/const in this block would add a closure \" +\n \"(throwIfClosureRequired).\",\n );\n }\n needsBodyWrap = true;\n };\n\n const body = path.get(\"body\");\n let bodyScope: Scope | null;\n if (body.isBlockStatement()) {\n bodyScope = body.scope;\n\n const bindings = getLoopBodyBindings(path);\n for (const binding of bindings) {\n const { capturedInClosure } = getUsageInBody(binding, path);\n if (capturedInClosure) markNeedsBodyWrap();\n }\n }\n\n const captured: string[] = [];\n const updatedBindingsUsages: Map<string, NodePath<t.Identifier>[]> =\n new Map();\n\n if (headPath && isBlockScoped(headPath.node)) {\n const names = Object.keys(headPath.getBindingIdentifiers());\n const headScope = headPath.scope;\n\n for (let name of names) {\n if (bodyScope?.hasOwnBinding(name)) continue; // shadowed\n\n let binding = headScope.getOwnBinding(name);\n if (!binding) {\n headScope.crawl();\n binding = headScope.getOwnBinding(name);\n }\n const { usages, capturedInClosure, hasConstantViolations } =\n getUsageInBody(binding, path);\n\n if (\n headScope.parent.hasBinding(name) ||\n headScope.parent.hasGlobal(name)\n ) {\n // If the binding is not captured, there is no need\n // of adding it to the closure param. However, rename\n // it if it shadows an outer binding, because the\n // closure will be moved to an outer level.\n const newName = headScope.generateUid(name);\n headScope.rename(name, newName);\n name = newName;\n }\n\n if (capturedInClosure) {\n markNeedsBodyWrap();\n captured.push(name);\n }\n\n if (isForStatement && hasConstantViolations) {\n updatedBindingsUsages.set(name, usages);\n }\n }\n }\n\n if (needsBodyWrap) {\n const varPath = wrapLoopBody(path, captured, updatedBindingsUsages);\n\n if (headPath?.isVariableDeclaration<t.Node>()) {\n // If we wrap the loop body, we transform the var\n // declaration in the loop head now, to avoid\n // invalid references that break other plugins:\n //\n // for (let head of x) {\n // let i = head;\n // setTimeout(() => i);\n // }\n //\n // would become\n //\n // function _loop() {\n // let i = head;\n // setTimeout(() => i);\n // }\n // for (let head of x) _loop();\n //\n // which references `head` in a scope where it's not visible.\n transformBlockScopedVariable(headPath, state, tdzEnabled);\n }\n\n varPath.get(\"declarations.0.init\").unwrapFunctionEnvironment();\n }\n },\n\n VariableDeclaration(path, state) {\n transformBlockScopedVariable(path, state, tdzEnabled);\n },\n\n // Class declarations are block-scoped: if there is\n // a class declaration in a nested block that conflicts\n // with an outer block-scoped binding, rename it.\n // TODO: Should this be moved to the classes plugin?\n ClassDeclaration(path) {\n const { id } = path.node;\n if (!id) return;\n\n const { scope } = path.parentPath;\n if (\n !isVarScope(scope) &&\n scope.parent.hasBinding(id.name, { noUids: true })\n ) {\n path.scope.rename(id.name);\n }\n },\n },\n ]),\n };\n});\n\nconst conflictingFunctionsVisitor: Visitor<{ names: string[] }> = {\n Scope(path, { names }) {\n for (const name of names) {\n const binding = path.scope.getOwnBinding(name);\n if (binding && binding.kind === \"hoisted\") {\n path.scope.rename(name);\n }\n }\n },\n \"Expression|Declaration\"(path) {\n path.skip();\n },\n};\n\nfunction transformBlockScopedVariable(\n path: NodePath<t.VariableDeclaration>,\n state: PluginPass,\n tdzEnabled: boolean,\n) {\n if (!isBlockScoped(path.node)) return;\n\n const dynamicTDZNames = validateUsage(path, state, tdzEnabled);\n\n path.node.kind = \"var\";\n\n const bindingNames = Object.keys(path.getBindingIdentifiers());\n for (const name of bindingNames) {\n const binding = path.scope.getOwnBinding(name);\n if (!binding) continue;\n binding.kind = \"var\";\n }\n\n if (\n (isInLoop(path) && !isVarInLoopHead(path)) ||\n dynamicTDZNames.length > 0\n ) {\n for (const decl of path.node.declarations) {\n // We explicitly add `void 0` to cases like\n // for (;;) { let a; }\n // to make sure that `a` doesn't keep the value from\n // the previous iteration.\n decl.init ??= path.scope.buildUndefinedNode();\n }\n }\n\n const blockScope = path.scope;\n const varScope =\n blockScope.getFunctionParent() || blockScope.getProgramParent();\n\n if (varScope !== blockScope) {\n for (const name of bindingNames) {\n let newName = name;\n if (\n // We pass `noUids` true because, if `name` was a generated\n // UID, it has been used to declare the current variable in\n // a nested scope and thus we don't need to assume that it\n // may be declared (but not registered yet) in an upper one.\n blockScope.parent.hasBinding(name, { noUids: true }) ||\n blockScope.parent.hasGlobal(name)\n ) {\n newName = blockScope.generateUid(name);\n blockScope.rename(name, newName);\n }\n\n blockScope.moveBindingTo(newName, varScope);\n }\n }\n\n blockScope.path.traverse(conflictingFunctionsVisitor, {\n names: bindingNames,\n });\n\n for (const name of dynamicTDZNames) {\n path.scope.push({\n id: t.identifier(name),\n init: state.addHelper(\"temporalUndefined\"),\n });\n }\n}\n\nfunction isLetOrConst(kind: string): kind is \"let\" | \"const\" {\n return kind === \"let\" || kind === \"const\";\n}\n\nfunction isInLoop(path: NodePath<t.Node>): boolean {\n if (!path.parentPath) return false;\n if (path.parentPath.isLoop()) return true;\n if (path.parentPath.isFunctionParent()) return false;\n return isInLoop(path.parentPath);\n}\n\nfunction isBlockScoped(node: t.Node): node is t.VariableDeclaration {\n if (!t.isVariableDeclaration(node)) return false;\n if (\n // @ts-expect-error Fixme: document symbol properties\n node[t.BLOCK_SCOPED_SYMBOL]\n ) {\n return true;\n }\n\n if (!isLetOrConst(node.kind) && node.kind !== \"using\") {\n return false;\n }\n\n return true;\n}\n"],"mappings":"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"}
\ No newline at end of file diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js b/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js new file mode 100644 index 00000000..0c0a17f8 --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js @@ -0,0 +1,294 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getLoopBodyBindings = getLoopBodyBindings; +exports.getUsageInBody = getUsageInBody; +exports.isVarInLoopHead = isVarInLoopHead; +exports.wrapLoopBody = wrapLoopBody; +var _core = require("@babel/core"); +const collectLoopBodyBindingsVisitor = { + "Expression|Declaration|Loop"(path) { + path.skip(); + }, + Scope(path, state) { + if (path.isFunctionParent()) path.skip(); + const { + bindings + } = path.scope; + for (const name of Object.keys(bindings)) { + const binding = bindings[name]; + if (binding.kind === "let" || binding.kind === "const" || binding.kind === "hoisted") { + state.blockScoped.push(binding); + } + } + } +}; +function getLoopBodyBindings(loopPath) { + const state = { + blockScoped: [] + }; + loopPath.traverse(collectLoopBodyBindingsVisitor, state); + return state.blockScoped; +} +function getUsageInBody(binding, loopPath) { + const seen = new WeakSet(); + let capturedInClosure = false; + const constantViolations = filterMap(binding.constantViolations, path => { + const { + inBody, + inClosure + } = relativeLoopLocation(path, loopPath); + if (!inBody) return null; + capturedInClosure || (capturedInClosure = inClosure); + const id = path.isUpdateExpression() ? path.get("argument") : path.isAssignmentExpression() ? path.get("left") : null; + if (id) seen.add(id.node); + return id; + }); + const references = filterMap(binding.referencePaths, path => { + if (seen.has(path.node)) return null; + const { + inBody, + inClosure + } = relativeLoopLocation(path, loopPath); + if (!inBody) return null; + capturedInClosure || (capturedInClosure = inClosure); + return path; + }); + return { + capturedInClosure, + hasConstantViolations: constantViolations.length > 0, + usages: references.concat(constantViolations) + }; +} +function relativeLoopLocation(path, loopPath) { + const bodyPath = loopPath.get("body"); + let inClosure = false; + for (let currPath = path; currPath; currPath = currPath.parentPath) { + if (currPath.isFunction() || currPath.isClass() || currPath.isMethod()) { + inClosure = true; + } + if (currPath === bodyPath) { + return { + inBody: true, + inClosure + }; + } else if (currPath === loopPath) { + return { + inBody: false, + inClosure + }; + } + } + throw new Error("Internal Babel error: path is not in loop. Please report this as a bug."); +} +const collectCompletionsAndVarsVisitor = { + Function(path) { + path.skip(); + }, + LabeledStatement: { + enter({ + node + }, state) { + state.labelsStack.push(node.label.name); + }, + exit({ + node + }, state) { + const popped = state.labelsStack.pop(); + if (popped !== node.label.name) { + throw new Error("Assertion failure. Please report this bug to Babel."); + } + } + }, + Loop: { + enter(_, state) { + state.labellessContinueTargets++; + state.labellessBreakTargets++; + }, + exit(_, state) { + state.labellessContinueTargets--; + state.labellessBreakTargets--; + } + }, + SwitchStatement: { + enter(_, state) { + state.labellessBreakTargets++; + }, + exit(_, state) { + state.labellessBreakTargets--; + } + }, + "BreakStatement|ContinueStatement"(path, state) { + const { + label + } = path.node; + if (label) { + if (state.labelsStack.includes(label.name)) return; + } else if (path.isBreakStatement() ? state.labellessBreakTargets > 0 : state.labellessContinueTargets > 0) { + return; + } + state.breaksContinues.push(path); + }, + ReturnStatement(path, state) { + state.returns.push(path); + }, + VariableDeclaration(path, state) { + if (path.parent === state.loopNode && isVarInLoopHead(path)) return; + if (path.node.kind === "var") state.vars.push(path); + } +}; +function wrapLoopBody(loopPath, captured, updatedBindingsUsages) { + const loopNode = loopPath.node; + const state = { + breaksContinues: [], + returns: [], + labelsStack: [], + labellessBreakTargets: 0, + labellessContinueTargets: 0, + vars: [], + loopNode + }; + loopPath.traverse(collectCompletionsAndVarsVisitor, state); + const callArgs = []; + const closureParams = []; + const updater = []; + for (const [name, updatedUsage] of updatedBindingsUsages) { + callArgs.push(_core.types.identifier(name)); + const innerName = loopPath.scope.generateUid(name); + closureParams.push(_core.types.identifier(innerName)); + updater.push(_core.types.assignmentExpression("=", _core.types.identifier(name), _core.types.identifier(innerName))); + for (const path of updatedUsage) path.replaceWith(_core.types.identifier(innerName)); + } + for (const name of captured) { + if (updatedBindingsUsages.has(name)) continue; + callArgs.push(_core.types.identifier(name)); + closureParams.push(_core.types.identifier(name)); + } + const id = loopPath.scope.generateUid("loop"); + const fn = _core.types.functionExpression(null, closureParams, _core.types.toBlock(loopNode.body)); + let call = _core.types.callExpression(_core.types.identifier(id), callArgs); + const fnParent = loopPath.findParent(p => p.isFunction()); + if (fnParent) { + const { + async, + generator + } = fnParent.node; + fn.async = async; + fn.generator = generator; + if (generator) call = _core.types.yieldExpression(call, true);else if (async) call = _core.types.awaitExpression(call); + } + const updaterNode = updater.length > 0 ? _core.types.expressionStatement(_core.types.sequenceExpression(updater)) : null; + if (updaterNode) fn.body.body.push(updaterNode); + const [varPath] = loopPath.insertBefore(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(id), fn)])); + const bodyStmts = []; + const varNames = []; + for (const varPath of state.vars) { + const assign = []; + for (const decl of varPath.node.declarations) { + varNames.push(...Object.keys(_core.types.getBindingIdentifiers(decl.id))); + if (decl.init) { + assign.push(_core.types.assignmentExpression("=", decl.id, decl.init)); + } + } + if (assign.length > 0) { + let replacement = assign.length === 1 ? assign[0] : _core.types.sequenceExpression(assign); + if (!_core.types.isForStatement(varPath.parent, { + init: varPath.node + }) && !_core.types.isForXStatement(varPath.parent, { + left: varPath.node + })) { + replacement = _core.types.expressionStatement(replacement); + } + varPath.replaceWith(replacement); + } else { + varPath.remove(); + } + } + if (varNames.length) { + varPath.pushContainer("declarations", varNames.map(name => _core.types.variableDeclarator(_core.types.identifier(name)))); + } + const labelNum = state.breaksContinues.length; + const returnNum = state.returns.length; + if (labelNum + returnNum === 0) { + bodyStmts.push(_core.types.expressionStatement(call)); + } else if (labelNum === 1 && returnNum === 0) { + for (const path of state.breaksContinues) { + const { + node + } = path; + const { + type, + label + } = node; + let name = type === "BreakStatement" ? "break" : "continue"; + if (label) name += " " + label.name; + path.replaceWith(_core.types.addComment(_core.types.returnStatement(_core.types.numericLiteral(1)), "trailing", " " + name, true)); + if (updaterNode) path.insertBefore(_core.types.cloneNode(updaterNode)); + bodyStmts.push(_core.template.statement.ast` + if (${call}) ${node} + `); + } + } else { + const completionId = loopPath.scope.generateUid("ret"); + if (varPath.isVariableDeclaration()) { + varPath.pushContainer("declarations", [_core.types.variableDeclarator(_core.types.identifier(completionId))]); + bodyStmts.push(_core.types.expressionStatement(_core.types.assignmentExpression("=", _core.types.identifier(completionId), call))); + } else { + bodyStmts.push(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(_core.types.identifier(completionId), call)])); + } + const injected = []; + for (const path of state.breaksContinues) { + const { + node + } = path; + const { + type, + label + } = node; + let name = type === "BreakStatement" ? "break" : "continue"; + if (label) name += " " + label.name; + let i = injected.indexOf(name); + const hasInjected = i !== -1; + if (!hasInjected) { + injected.push(name); + i = injected.length - 1; + } + path.replaceWith(_core.types.addComment(_core.types.returnStatement(_core.types.numericLiteral(i)), "trailing", " " + name, true)); + if (updaterNode) path.insertBefore(_core.types.cloneNode(updaterNode)); + if (hasInjected) continue; + bodyStmts.push(_core.template.statement.ast` + if (${_core.types.identifier(completionId)} === ${_core.types.numericLiteral(i)}) ${node} + `); + } + if (returnNum) { + for (const path of state.returns) { + const arg = path.node.argument || path.scope.buildUndefinedNode(); + path.replaceWith(_core.template.statement.ast` + return { v: ${arg} }; + `); + } + bodyStmts.push(_core.template.statement.ast` + if (${_core.types.identifier(completionId)}) return ${_core.types.identifier(completionId)}.v; + `); + } + } + loopNode.body = _core.types.blockStatement(bodyStmts); + return varPath; +} +function isVarInLoopHead(path) { + if (_core.types.isForStatement(path.parent)) return path.key === "init"; + if (_core.types.isForXStatement(path.parent)) return path.key === "left"; + return false; +} +function filterMap(list, fn) { + const result = []; + for (const item of list) { + const mapped = fn(item); + if (mapped) result.push(mapped); + } + return result; +} + +//# sourceMappingURL=loop.js.map diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js.map b/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js.map new file mode 100644 index 00000000..8a147389 --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/loop.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_core","require","collectLoopBodyBindingsVisitor","Expression|Declaration|Loop","path","skip","Scope","state","isFunctionParent","bindings","scope","name","Object","keys","binding","kind","blockScoped","push","getLoopBodyBindings","loopPath","traverse","getUsageInBody","seen","WeakSet","capturedInClosure","constantViolations","filterMap","inBody","inClosure","relativeLoopLocation","id","isUpdateExpression","get","isAssignmentExpression","add","node","references","referencePaths","has","hasConstantViolations","length","usages","concat","bodyPath","currPath","parentPath","isFunction","isClass","isMethod","Error","collectCompletionsAndVarsVisitor","Function","LabeledStatement","enter","labelsStack","label","exit","popped","pop","Loop","_","labellessContinueTargets","labellessBreakTargets","SwitchStatement","BreakStatement|ContinueStatement","includes","isBreakStatement","breaksContinues","ReturnStatement","returns","VariableDeclaration","parent","loopNode","isVarInLoopHead","vars","wrapLoopBody","captured","updatedBindingsUsages","callArgs","closureParams","updater","updatedUsage","t","identifier","innerName","generateUid","assignmentExpression","replaceWith","fn","functionExpression","toBlock","body","call","callExpression","fnParent","findParent","p","async","generator","yieldExpression","awaitExpression","updaterNode","expressionStatement","sequenceExpression","varPath","insertBefore","variableDeclaration","variableDeclarator","bodyStmts","varNames","assign","decl","declarations","getBindingIdentifiers","init","replacement","isForStatement","isForXStatement","left","remove","pushContainer","map","labelNum","returnNum","type","addComment","returnStatement","numericLiteral","cloneNode","template","statement","ast","completionId","isVariableDeclaration","injected","i","indexOf","hasInjected","arg","argument","buildUndefinedNode","blockStatement","key","list","result","item","mapped"],"sources":["../src/loop.ts"],"sourcesContent":["import { template, types as t } from \"@babel/core\";\nimport type { NodePath, Visitor, Binding } from \"@babel/traverse\";\n\ninterface LoopBodyBindingsState {\n blockScoped: Binding[];\n}\n\nconst collectLoopBodyBindingsVisitor: Visitor<LoopBodyBindingsState> = {\n \"Expression|Declaration|Loop\"(path) {\n path.skip();\n },\n Scope(path, state) {\n if (path.isFunctionParent()) path.skip();\n\n const { bindings } = path.scope;\n for (const name of Object.keys(bindings)) {\n const binding = bindings[name];\n if (\n binding.kind === \"let\" ||\n binding.kind === \"const\" ||\n binding.kind === \"hoisted\"\n ) {\n state.blockScoped.push(binding);\n }\n }\n },\n};\n\nexport function getLoopBodyBindings(loopPath: NodePath<t.Loop>) {\n const state: LoopBodyBindingsState = { blockScoped: [] };\n loopPath.traverse(collectLoopBodyBindingsVisitor, state);\n return state.blockScoped;\n}\n\nexport function getUsageInBody(binding: Binding, loopPath: NodePath<t.Loop>) {\n // UpdateExpressions are counted both as a reference and a mutation,\n // so we need to de-duplicate them.\n const seen = new WeakSet<t.Node>();\n\n let capturedInClosure = false;\n\n const constantViolations = filterMap(binding.constantViolations, path => {\n const { inBody, inClosure } = relativeLoopLocation(path, loopPath);\n if (!inBody) return null;\n capturedInClosure ||= inClosure;\n\n const id = path.isUpdateExpression()\n ? path.get(\"argument\")\n : path.isAssignmentExpression()\n ? path.get(\"left\")\n : null;\n if (id) seen.add(id.node);\n return id as NodePath<t.Identifier> | null;\n });\n\n const references = filterMap(binding.referencePaths, path => {\n if (seen.has(path.node)) return null;\n\n const { inBody, inClosure } = relativeLoopLocation(path, loopPath);\n if (!inBody) return null;\n capturedInClosure ||= inClosure;\n\n return path as NodePath<t.Identifier>;\n });\n\n return {\n capturedInClosure,\n hasConstantViolations: constantViolations.length > 0,\n usages: references.concat(constantViolations),\n };\n}\n\nfunction relativeLoopLocation(path: NodePath, loopPath: NodePath<t.Loop>) {\n const bodyPath = loopPath.get(\"body\");\n let inClosure = false;\n\n for (let currPath = path; currPath; currPath = currPath.parentPath) {\n if (currPath.isFunction() || currPath.isClass() || currPath.isMethod()) {\n inClosure = true;\n }\n if (currPath === bodyPath) {\n return { inBody: true, inClosure };\n } else if (currPath === loopPath) {\n return { inBody: false, inClosure };\n }\n }\n\n throw new Error(\n \"Internal Babel error: path is not in loop. Please report this as a bug.\",\n );\n}\n\ninterface CompletionsAndVarsState {\n breaksContinues: NodePath<t.BreakStatement | t.ContinueStatement>[];\n returns: NodePath<t.ReturnStatement>[];\n labelsStack: string[];\n labellessContinueTargets: number;\n labellessBreakTargets: number;\n\n vars: NodePath<t.VariableDeclaration>[];\n loopNode: t.Loop;\n}\n\nconst collectCompletionsAndVarsVisitor: Visitor<CompletionsAndVarsState> = {\n Function(path) {\n path.skip();\n },\n LabeledStatement: {\n enter({ node }, state) {\n state.labelsStack.push(node.label.name);\n },\n exit({ node }, state) {\n const popped = state.labelsStack.pop();\n if (popped !== node.label.name) {\n throw new Error(\"Assertion failure. Please report this bug to Babel.\");\n }\n },\n },\n Loop: {\n enter(_, state) {\n state.labellessContinueTargets++;\n state.labellessBreakTargets++;\n },\n exit(_, state) {\n state.labellessContinueTargets--;\n state.labellessBreakTargets--;\n },\n },\n SwitchStatement: {\n enter(_, state) {\n state.labellessBreakTargets++;\n },\n exit(_, state) {\n state.labellessBreakTargets--;\n },\n },\n \"BreakStatement|ContinueStatement\"(\n path: NodePath<t.BreakStatement | t.ContinueStatement>,\n state,\n ) {\n const { label } = path.node;\n if (label) {\n if (state.labelsStack.includes(label.name)) return;\n } else if (\n path.isBreakStatement()\n ? state.labellessBreakTargets > 0\n : state.labellessContinueTargets > 0\n ) {\n return;\n }\n state.breaksContinues.push(path);\n },\n ReturnStatement(path, state) {\n state.returns.push(path);\n },\n VariableDeclaration(path, state) {\n if (path.parent === state.loopNode && isVarInLoopHead(path)) return;\n if (path.node.kind === \"var\") state.vars.push(path);\n },\n};\n\nexport function wrapLoopBody(\n loopPath: NodePath<t.Loop>,\n captured: string[],\n updatedBindingsUsages: Map<string, NodePath<t.Identifier>[]>,\n) {\n const loopNode = loopPath.node;\n const state: CompletionsAndVarsState = {\n breaksContinues: [],\n returns: [],\n labelsStack: [],\n labellessBreakTargets: 0,\n labellessContinueTargets: 0,\n vars: [],\n loopNode,\n };\n loopPath.traverse(collectCompletionsAndVarsVisitor, state);\n\n const callArgs = [];\n const closureParams = [];\n const updater = [];\n for (const [name, updatedUsage] of updatedBindingsUsages) {\n callArgs.push(t.identifier(name));\n\n const innerName = loopPath.scope.generateUid(name);\n closureParams.push(t.identifier(innerName));\n updater.push(\n t.assignmentExpression(\"=\", t.identifier(name), t.identifier(innerName)),\n );\n for (const path of updatedUsage) path.replaceWith(t.identifier(innerName));\n }\n for (const name of captured) {\n if (updatedBindingsUsages.has(name)) continue; // already injected\n callArgs.push(t.identifier(name));\n closureParams.push(t.identifier(name));\n }\n\n const id = loopPath.scope.generateUid(\"loop\");\n const fn = t.functionExpression(\n null,\n closureParams,\n t.toBlock(loopNode.body),\n );\n let call: t.Expression = t.callExpression(t.identifier(id), callArgs);\n\n const fnParent = loopPath.findParent(p => p.isFunction());\n if (fnParent) {\n const { async, generator } = fnParent.node as t.Function;\n fn.async = async;\n fn.generator = generator;\n if (generator) call = t.yieldExpression(call, true);\n else if (async) call = t.awaitExpression(call);\n }\n\n const updaterNode =\n updater.length > 0\n ? t.expressionStatement(t.sequenceExpression(updater))\n : null;\n if (updaterNode) fn.body.body.push(updaterNode);\n\n // NOTE: Calling .insertBefore on the loop path might cause the\n // loop to be moved in the AST. For example, in\n // if (true) for (let x of y) ...\n // .insertBefore will replace the loop with a block:\n // if (true) { var _loop = ...; for (let x of y) ... }\n // All subsequent operations in this function on the loop node\n // must not assume that loopPath still represents the loop.\n // TODO: Consider using a function declaration\n const [varPath] = loopPath.insertBefore(\n t.variableDeclaration(\"var\", [t.variableDeclarator(t.identifier(id), fn)]),\n ) as [NodePath<t.VariableDeclaration>];\n\n const bodyStmts: t.Statement[] = [];\n\n const varNames: string[] = [];\n for (const varPath of state.vars) {\n const assign = [];\n for (const decl of varPath.node.declarations) {\n varNames.push(...Object.keys(t.getBindingIdentifiers(decl.id)));\n if (decl.init) {\n assign.push(t.assignmentExpression(\"=\", decl.id, decl.init));\n }\n }\n if (assign.length > 0) {\n let replacement: t.Node =\n assign.length === 1 ? assign[0] : t.sequenceExpression(assign);\n if (\n !t.isForStatement(varPath.parent, { init: varPath.node }) &&\n !t.isForXStatement(varPath.parent, { left: varPath.node })\n ) {\n replacement = t.expressionStatement(replacement);\n }\n varPath.replaceWith(replacement);\n } else {\n varPath.remove();\n }\n }\n if (varNames.length) {\n varPath.pushContainer(\n \"declarations\",\n varNames.map(name => t.variableDeclarator(t.identifier(name))),\n );\n }\n\n const labelNum = state.breaksContinues.length;\n const returnNum = state.returns.length;\n if (labelNum + returnNum === 0) {\n bodyStmts.push(t.expressionStatement(call));\n } else if (labelNum === 1 && returnNum === 0) {\n for (const path of state.breaksContinues) {\n const { node } = path;\n const { type, label } = node;\n let name = type === \"BreakStatement\" ? \"break\" : \"continue\";\n if (label) name += \" \" + label.name;\n path.replaceWith(\n t.addComment(\n t.returnStatement(t.numericLiteral(1)),\n \"trailing\",\n \" \" + name,\n true,\n ),\n );\n if (updaterNode) path.insertBefore(t.cloneNode(updaterNode));\n\n bodyStmts.push(\n template.statement.ast`\n if (${call}) ${node}\n `,\n );\n }\n } else {\n const completionId = loopPath.scope.generateUid(\"ret\");\n\n if (varPath.isVariableDeclaration()) {\n varPath.pushContainer(\"declarations\", [\n t.variableDeclarator(t.identifier(completionId)),\n ]);\n bodyStmts.push(\n t.expressionStatement(\n t.assignmentExpression(\"=\", t.identifier(completionId), call),\n ),\n );\n } else {\n bodyStmts.push(\n t.variableDeclaration(\"var\", [\n t.variableDeclarator(t.identifier(completionId), call),\n ]),\n );\n }\n\n const injected: string[] = [];\n for (const path of state.breaksContinues) {\n const { node } = path;\n const { type, label } = node;\n let name = type === \"BreakStatement\" ? \"break\" : \"continue\";\n if (label) name += \" \" + label.name;\n\n let i = injected.indexOf(name);\n const hasInjected = i !== -1;\n if (!hasInjected) {\n injected.push(name);\n i = injected.length - 1;\n }\n\n path.replaceWith(\n t.addComment(\n t.returnStatement(t.numericLiteral(i)),\n \"trailing\",\n \" \" + name,\n true,\n ),\n );\n if (updaterNode) path.insertBefore(t.cloneNode(updaterNode));\n\n if (hasInjected) continue;\n\n bodyStmts.push(\n template.statement.ast`\n if (${t.identifier(completionId)} === ${t.numericLiteral(i)}) ${node}\n `,\n );\n }\n\n if (returnNum) {\n for (const path of state.returns) {\n const arg = path.node.argument || path.scope.buildUndefinedNode();\n path.replaceWith(\n template.statement.ast`\n return { v: ${arg} };\n `,\n );\n }\n\n bodyStmts.push(\n template.statement.ast`\n if (${t.identifier(completionId)}) return ${t.identifier(\n completionId,\n )}.v;\n `,\n );\n }\n }\n\n loopNode.body = t.blockStatement(bodyStmts);\n\n return varPath;\n}\n\nexport function isVarInLoopHead(path: NodePath<t.VariableDeclaration>) {\n if (t.isForStatement(path.parent)) return path.key === \"init\";\n if (t.isForXStatement(path.parent)) return path.key === \"left\";\n return false;\n}\n\nfunction filterMap<T, U extends object>(list: T[], fn: (item: T) => U | null) {\n const result: U[] = [];\n for (const item of list) {\n const mapped = fn(item);\n if (mapped) result.push(mapped);\n }\n return result;\n}\n"],"mappings":"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"}
\ No newline at end of file diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/validation.js b/node_modules/@babel/plugin-transform-block-scoping/lib/validation.js new file mode 100644 index 00000000..3985a42b --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/validation.js @@ -0,0 +1,133 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.validateUsage = validateUsage; +var _core = require("@babel/core"); +function validateUsage(path, state, tdzEnabled) { + const dynamicTDZNames = []; + for (const name of Object.keys(path.getBindingIdentifiers())) { + const binding = path.scope.getBinding(name); + if (!binding) continue; + if (tdzEnabled) { + if (injectTDZChecks(binding, state)) dynamicTDZNames.push(name); + } + if (path.node.kind === "const") { + disallowConstantViolations(name, binding, state); + } + } + return dynamicTDZNames; +} +function disallowConstantViolations(name, binding, state) { + for (const violation of binding.constantViolations) { + const readOnlyError = state.addHelper("readOnlyError"); + const throwNode = _core.types.callExpression(readOnlyError, [_core.types.stringLiteral(name)]); + if (violation.isAssignmentExpression()) { + const { + operator, + left, + right + } = violation.node; + if (operator === "=") { + const exprs = [right]; + exprs.push(throwNode); + violation.replaceWith(_core.types.sequenceExpression(exprs)); + } else if (["&&=", "||=", "??="].includes(operator)) { + violation.replaceWith(_core.types.logicalExpression(operator.slice(0, -1), left, _core.types.sequenceExpression([right, throwNode]))); + } else { + violation.replaceWith(_core.types.sequenceExpression([_core.types.binaryExpression(operator.slice(0, -1), left, right), throwNode])); + } + } else if (violation.isUpdateExpression()) { + violation.replaceWith(_core.types.sequenceExpression([_core.types.unaryExpression("+", violation.get("argument").node), throwNode])); + } else if (violation.isForXStatement()) { + violation.ensureBlock(); + violation.get("left").replaceWith(_core.types.variableDeclaration("var", [_core.types.variableDeclarator(violation.scope.generateUidIdentifier(name))])); + violation.node.body.body.unshift(_core.types.expressionStatement(throwNode)); + } + } +} +function getTDZStatus(refPath, bindingPath) { + const executionStatus = bindingPath._guessExecutionStatusRelativeTo(refPath); + if (executionStatus === "before") { + return "outside"; + } else if (executionStatus === "after") { + return "inside"; + } else { + return "maybe"; + } +} +const skipTDZChecks = new WeakSet(); +function buildTDZAssert(status, node, state) { + if (status === "maybe") { + const clone = _core.types.cloneNode(node); + skipTDZChecks.add(clone); + return _core.types.callExpression(state.addHelper("temporalRef"), [clone, _core.types.stringLiteral(node.name)]); + } else { + return _core.types.callExpression(state.addHelper("tdz"), [_core.types.stringLiteral(node.name)]); + } +} +function getTDZReplacement(path, state, id = path.node) { + var _path$scope$getBindin; + if (skipTDZChecks.has(id)) return; + skipTDZChecks.add(id); + const bindingPath = (_path$scope$getBindin = path.scope.getBinding(id.name)) == null ? void 0 : _path$scope$getBindin.path; + if (!bindingPath || bindingPath.isFunctionDeclaration()) return; + const status = getTDZStatus(path, bindingPath); + if (status === "outside") return; + if (status === "maybe") { + bindingPath.parent._tdzThis = true; + } + return { + status, + node: buildTDZAssert(status, id, state) + }; +} +function injectTDZChecks(binding, state) { + const allUsages = new Set(binding.referencePaths); + binding.constantViolations.forEach(allUsages.add, allUsages); + let dynamicTdz = false; + for (const path of binding.constantViolations) { + const { + node + } = path; + if (skipTDZChecks.has(node)) continue; + skipTDZChecks.add(node); + if (path.isUpdateExpression()) { + const arg = path.get("argument"); + const replacement = getTDZReplacement(path, state, arg.node); + if (!replacement) continue; + if (replacement.status === "maybe") { + dynamicTdz = true; + path.insertBefore(replacement.node); + } else { + path.replaceWith(replacement.node); + } + } else if (path.isAssignmentExpression()) { + const nodes = []; + const ids = path.getBindingIdentifiers(); + for (const name of Object.keys(ids)) { + const replacement = getTDZReplacement(path, state, ids[name]); + if (replacement) { + nodes.push(_core.types.expressionStatement(replacement.node)); + if (replacement.status === "inside") break; + if (replacement.status === "maybe") dynamicTdz = true; + } + } + if (nodes.length > 0) path.insertBefore(nodes); + } + } + for (const path of binding.referencePaths) { + if (path.parentPath.isUpdateExpression()) continue; + if (path.parentPath.isFor({ + left: path.node + })) continue; + const replacement = getTDZReplacement(path, state); + if (!replacement) continue; + if (replacement.status === "maybe") dynamicTdz = true; + path.replaceWith(replacement.node); + } + return dynamicTdz; +} + +//# sourceMappingURL=validation.js.map diff --git a/node_modules/@babel/plugin-transform-block-scoping/lib/validation.js.map b/node_modules/@babel/plugin-transform-block-scoping/lib/validation.js.map new file mode 100644 index 00000000..886b6076 --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/lib/validation.js.map @@ -0,0 +1 @@ +{"version":3,"names":["_core","require","validateUsage","path","state","tdzEnabled","dynamicTDZNames","name","Object","keys","getBindingIdentifiers","binding","scope","getBinding","injectTDZChecks","push","node","kind","disallowConstantViolations","violation","constantViolations","readOnlyError","addHelper","throwNode","t","callExpression","stringLiteral","isAssignmentExpression","operator","left","right","exprs","replaceWith","sequenceExpression","includes","logicalExpression","slice","binaryExpression","isUpdateExpression","unaryExpression","get","isForXStatement","ensureBlock","variableDeclaration","variableDeclarator","generateUidIdentifier","body","unshift","expressionStatement","getTDZStatus","refPath","bindingPath","executionStatus","_guessExecutionStatusRelativeTo","skipTDZChecks","WeakSet","buildTDZAssert","status","clone","cloneNode","add","getTDZReplacement","id","_path$scope$getBindin","has","isFunctionDeclaration","parent","_tdzThis","allUsages","Set","referencePaths","forEach","dynamicTdz","arg","replacement","insertBefore","nodes","ids","length","parentPath","isFor"],"sources":["../src/validation.ts"],"sourcesContent":["import { types as t, type PluginPass } from \"@babel/core\";\nimport type { Binding, NodePath } from \"@babel/traverse\";\n\nexport function validateUsage(\n path: NodePath<t.VariableDeclaration>,\n state: PluginPass,\n tdzEnabled: boolean,\n) {\n const dynamicTDZNames = [];\n\n for (const name of Object.keys(path.getBindingIdentifiers())) {\n const binding = path.scope.getBinding(name);\n // binding may be null. ref: https://github.com/babel/babel/issues/15300\n if (!binding) continue;\n if (tdzEnabled) {\n if (injectTDZChecks(binding, state)) dynamicTDZNames.push(name);\n }\n if (path.node.kind === \"const\") {\n disallowConstantViolations(name, binding, state);\n }\n }\n\n return dynamicTDZNames;\n}\n\nfunction disallowConstantViolations(\n name: string,\n binding: Binding,\n state: PluginPass,\n) {\n for (const violation of binding.constantViolations) {\n const readOnlyError = state.addHelper(\"readOnlyError\");\n const throwNode = t.callExpression(readOnlyError, [t.stringLiteral(name)]);\n\n if (violation.isAssignmentExpression()) {\n const { operator, left, right } = violation.node;\n if (operator === \"=\") {\n const exprs = [right];\n exprs.push(throwNode);\n violation.replaceWith(t.sequenceExpression(exprs));\n } else if ([\"&&=\", \"||=\", \"??=\"].includes(operator)) {\n violation.replaceWith(\n t.logicalExpression(\n // @ts-expect-error todo: give a better type to operator\n operator.slice(0, -1),\n left,\n t.sequenceExpression([right, throwNode]),\n ),\n );\n } else {\n violation.replaceWith(\n t.sequenceExpression([\n t.binaryExpression(\n // @ts-expect-error todo: give a better type to operator\n operator.slice(0, -1),\n left,\n right,\n ),\n throwNode,\n ]),\n );\n }\n } else if (violation.isUpdateExpression()) {\n violation.replaceWith(\n t.sequenceExpression([\n t.unaryExpression(\"+\", violation.get(\"argument\").node),\n throwNode,\n ]),\n );\n } else if (violation.isForXStatement()) {\n violation.ensureBlock();\n violation\n .get(\"left\")\n .replaceWith(\n t.variableDeclaration(\"var\", [\n t.variableDeclarator(violation.scope.generateUidIdentifier(name)),\n ]),\n );\n violation.node.body.body.unshift(t.expressionStatement(throwNode));\n }\n }\n}\n\nfunction getTDZStatus(refPath: NodePath, bindingPath: NodePath) {\n const executionStatus = bindingPath._guessExecutionStatusRelativeTo(refPath);\n\n if (executionStatus === \"before\") {\n return \"outside\";\n } else if (executionStatus === \"after\") {\n return \"inside\";\n } else {\n return \"maybe\";\n }\n}\n\nconst skipTDZChecks = new WeakSet();\n\nfunction buildTDZAssert(\n status: \"maybe\" | \"inside\",\n node: t.Identifier | t.JSXIdentifier,\n state: PluginPass,\n) {\n if (status === \"maybe\") {\n const clone = t.cloneNode(node);\n skipTDZChecks.add(clone);\n return t.callExpression(state.addHelper(\"temporalRef\"), [\n // @ts-expect-error Fixme: we may need to handle JSXIdentifier\n clone,\n t.stringLiteral(node.name),\n ]);\n } else {\n return t.callExpression(state.addHelper(\"tdz\"), [\n t.stringLiteral(node.name),\n ]);\n }\n}\n\ntype TDZReplacement = { status: \"maybe\" | \"inside\"; node: t.Expression };\nfunction getTDZReplacement(\n path: NodePath<t.Identifier | t.JSXIdentifier>,\n state: PluginPass,\n): TDZReplacement | undefined;\nfunction getTDZReplacement(\n path: NodePath,\n state: PluginPass,\n id: t.Identifier | t.JSXIdentifier,\n): TDZReplacement | undefined;\nfunction getTDZReplacement(\n path: NodePath,\n state: PluginPass,\n id: t.Identifier | t.JSXIdentifier = path.node as any,\n): TDZReplacement | undefined {\n if (skipTDZChecks.has(id)) return;\n skipTDZChecks.add(id);\n\n const bindingPath = path.scope.getBinding(id.name)?.path;\n\n if (!bindingPath || bindingPath.isFunctionDeclaration()) return;\n\n const status = getTDZStatus(path, bindingPath);\n if (status === \"outside\") return;\n\n if (status === \"maybe\") {\n // add tdzThis to parent variable declarator so it's exploded\n // @ts-expect-error todo(flow->ts): avoid mutations\n bindingPath.parent._tdzThis = true;\n }\n\n return { status, node: buildTDZAssert(status, id, state) };\n}\n\nfunction injectTDZChecks(binding: Binding, state: PluginPass) {\n const allUsages = new Set(binding.referencePaths);\n binding.constantViolations.forEach(allUsages.add, allUsages);\n\n let dynamicTdz = false;\n\n for (const path of binding.constantViolations) {\n const { node } = path;\n if (skipTDZChecks.has(node)) continue;\n skipTDZChecks.add(node);\n\n if (path.isUpdateExpression()) {\n // arg is an identifier referencing the current binding\n const arg = path.get(\"argument\") as NodePath<t.Identifier>;\n\n const replacement = getTDZReplacement(path, state, arg.node);\n if (!replacement) continue;\n\n if (replacement.status === \"maybe\") {\n dynamicTdz = true;\n path.insertBefore(replacement.node);\n } else {\n path.replaceWith(replacement.node);\n }\n } else if (path.isAssignmentExpression()) {\n const nodes = [];\n const ids = path.getBindingIdentifiers();\n\n for (const name of Object.keys(ids)) {\n const replacement = getTDZReplacement(path, state, ids[name]);\n if (replacement) {\n nodes.push(t.expressionStatement(replacement.node));\n if (replacement.status === \"inside\") break;\n if (replacement.status === \"maybe\") dynamicTdz = true;\n }\n }\n\n if (nodes.length > 0) path.insertBefore(nodes);\n }\n }\n\n for (const path of binding.referencePaths as NodePath<t.Identifier>[]) {\n if (path.parentPath.isUpdateExpression()) continue;\n // It will be handled after transforming the loop\n if (path.parentPath.isFor({ left: path.node })) continue;\n\n const replacement = getTDZReplacement(path, state);\n if (!replacement) continue;\n if (replacement.status === \"maybe\") dynamicTdz = true;\n\n path.replaceWith(replacement.node);\n }\n\n return dynamicTdz;\n}\n"],"mappings":"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"}
\ No newline at end of file diff --git a/node_modules/@babel/plugin-transform-block-scoping/package.json b/node_modules/@babel/plugin-transform-block-scoping/package.json new file mode 100644 index 00000000..6b9eaad9 --- /dev/null +++ b/node_modules/@babel/plugin-transform-block-scoping/package.json @@ -0,0 +1,35 @@ +{ + "name": "@babel/plugin-transform-block-scoping", + "version": "7.23.0", + "description": "Compile ES2015 block scoping (const and let) to ES5", + "repository": { + "type": "git", + "url": "https://github.com/babel/babel.git", + "directory": "packages/babel-plugin-transform-block-scoping" + }, + "homepage": "https://babel.dev/docs/en/next/babel-plugin-transform-block-scoping", + "license": "MIT", + "publishConfig": { + "access": "public" + }, + "main": "./lib/index.js", + "dependencies": { + "@babel/helper-plugin-utils": "^7.22.5" + }, + "keywords": [ + "babel-plugin" + ], + "peerDependencies": { + "@babel/core": "^7.0.0-0" + }, + "devDependencies": { + "@babel/core": "^7.23.0", + "@babel/helper-plugin-test-runner": "^7.22.5", + "@babel/traverse": "^7.23.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "author": "The Babel Team (https://babel.dev/team)", + "type": "commonjs" +}
\ No newline at end of file |