@next-core/cook 1.0.1

package/dist/cjs/precook.js

@@ -0,0 +1,432 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.precook = precook;
+
+var _hasOwnProperty = require("./hasOwnProperty");
+
+var _AnalysisContext = require("./AnalysisContext");
+
+var _traverse = require("./traverse");
+
+/**
+ * Analysis an AST of a storyboard function or an evaluation expression.
+ *
+ * @param rootAst - The root AST.
+ * @param options - Analysis options.
+ * @returns A set of global variables the root AST attempts to access.
+ */
+function precook(rootAst, {
+  expressionOnly,
+  visitors
+} = {}) {
+  const attemptToVisitGlobals = new Set();
+  const analysisContextStack = [];
+  const rootEnv = new _AnalysisContext.AnalysisEnvironment(null);
+  const rootContext = new _AnalysisContext.AnalysisContext();
+  rootContext.VariableEnvironment = rootEnv;
+  rootContext.LexicalEnvironment = rootEnv;
+  analysisContextStack.push(rootContext);
+
+  function getRunningContext() {
+    return analysisContextStack[analysisContextStack.length - 1];
+  }
+
+  function visit(node) {
+    if ((0, _hasOwnProperty.hasOwnProperty)(visitors, node.type)) {
+      visitors[node.type](node);
+    }
+  }
+
+  function Evaluate(node) {
+    if (Array.isArray(node)) {
+      for (const n of node) {
+        Evaluate(n);
+      }
+    } else if (node) {
+      // `node` maybe `null` in some cases.
+      visitors && visit(node); // Expressions:
+
+      switch (node.type) {
+        case "Identifier":
+          if (!ResolveBinding(node.name)) {
+            attemptToVisitGlobals.add(node.name);
+
+            if (visitors && (0, _hasOwnProperty.hasOwnProperty)(visitors, "__GlobalVariable")) {
+              visitors.__GlobalVariable(node);
+            }
+          }
+
+          return;
+
+        case "ArrayExpression":
+        case "ArrayPattern":
+          Evaluate(node.elements);
+          return;
+
+        case "ArrowFunctionExpression":
+          {
+            const env = getRunningContext().LexicalEnvironment;
+            const closure = OrdinaryFunctionCreate(node, env);
+            CallFunction(closure);
+            return;
+          }
+
+        case "AssignmentPattern":
+        case "BinaryExpression":
+        case "LogicalExpression":
+          Evaluate(node.left);
+          Evaluate(node.right);
+          return;
+
+        case "CallExpression":
+        case "NewExpression":
+          Evaluate(node.callee);
+          Evaluate(node.arguments);
+          return;
+
+        case "ChainExpression":
+          Evaluate(node.expression);
+          return;
+
+        case "ConditionalExpression":
+          Evaluate(node.test);
+          Evaluate(node.consequent);
+          Evaluate(node.alternate);
+          return;
+
+        case "MemberExpression":
+          Evaluate(node.object);
+
+          if (node.computed) {
+            Evaluate(node.property);
+          }
+
+          return;
+
+        case "ObjectExpression":
+        case "ObjectPattern":
+          Evaluate(node.properties);
+          return;
+
+        case "Property":
+          if (node.computed) {
+            Evaluate(node.key);
+          }
+
+          Evaluate(node.value);
+          return;
+
+        case "RestElement":
+        case "SpreadElement":
+        case "UnaryExpression":
+          Evaluate(node.argument);
+          return;
+
+        case "SequenceExpression":
+        case "TemplateLiteral":
+          Evaluate(node.expressions);
+          return;
+
+        case "TaggedTemplateExpression":
+          Evaluate(node.tag);
+          Evaluate(node.quasi);
+          return;
+
+        case "Literal":
+          return;
+      }
+
+      if (!expressionOnly) {
+        // Statements and assignments:
+        switch (node.type) {
+          case "AssignmentExpression":
+            Evaluate(node.right);
+            Evaluate(node.left);
+            return;
+
+          case "BlockStatement":
+            {
+              if (!node.body.length) {
+                return;
+              }
+
+              const runningContext = getRunningContext();
+              const oldEnv = runningContext.LexicalEnvironment;
+              const blockEnv = new _AnalysisContext.AnalysisEnvironment(oldEnv);
+              BlockDeclarationInstantiation(node.body, blockEnv);
+              runningContext.LexicalEnvironment = blockEnv;
+              Evaluate(node.body);
+              runningContext.LexicalEnvironment = oldEnv;
+              return;
+            }
+
+          case "BreakStatement":
+          case "ContinueStatement":
+          case "EmptyStatement":
+            return;
+
+          case "CatchClause":
+            {
+              const runningContext = getRunningContext();
+              const oldEnv = runningContext.LexicalEnvironment;
+              const catchEnv = new _AnalysisContext.AnalysisEnvironment(oldEnv);
+              BoundNamesInstantiation(node.param, catchEnv);
+              runningContext.LexicalEnvironment = catchEnv;
+              Evaluate(node.param);
+              Evaluate(node.body);
+              runningContext.LexicalEnvironment = oldEnv;
+              return;
+            }
+
+          case "DoWhileStatement":
+            Evaluate(node.body);
+            Evaluate(node.test);
+            return;
+
+          case "ExpressionStatement":
+          case "TSAsExpression":
+            Evaluate(node.expression);
+            return;
+
+          case "ForInStatement":
+          case "ForOfStatement":
+            {
+              // ForIn/OfHeadEvaluation
+              const lexicalBinding = node.left.type === "VariableDeclaration" && node.left.kind !== "var";
+              const runningContext = getRunningContext();
+              const oldEnv = runningContext.LexicalEnvironment;
+
+              if (lexicalBinding) {
+                const newEnv = new _AnalysisContext.AnalysisEnvironment(oldEnv);
+                BoundNamesInstantiation(node.left, newEnv);
+                runningContext.LexicalEnvironment = newEnv;
+              }
+
+              Evaluate(node.right);
+              runningContext.LexicalEnvironment = oldEnv; // ForIn/OfBodyEvaluation
+
+              if (lexicalBinding) {
+                const iterationEnv = new _AnalysisContext.AnalysisEnvironment(oldEnv);
+                BoundNamesInstantiation(node.left, iterationEnv);
+                runningContext.LexicalEnvironment = iterationEnv;
+              }
+
+              Evaluate(node.left);
+              Evaluate(node.body);
+              runningContext.LexicalEnvironment = oldEnv;
+              return;
+            }
+
+          case "ForStatement":
+            {
+              var _node$init;
+
+              const lexicalBinding = ((_node$init = node.init) === null || _node$init === void 0 ? void 0 : _node$init.type) === "VariableDeclaration" && node.init.kind !== "var";
+              const runningContext = getRunningContext();
+              const oldEnv = runningContext.LexicalEnvironment;
+
+              if (lexicalBinding) {
+                const loopEnv = new _AnalysisContext.AnalysisEnvironment(oldEnv);
+                BoundNamesInstantiation(node.init, loopEnv);
+                runningContext.LexicalEnvironment = loopEnv;
+              }
+
+              Evaluate(node.init);
+              Evaluate(node.test);
+              Evaluate(node.body);
+              Evaluate(node.update);
+              runningContext.LexicalEnvironment = oldEnv;
+              return;
+            }
+
+          case "FunctionDeclaration":
+            {
+              const [fn] = (0, _traverse.collectBoundNames)(node);
+              const env = getRunningContext().LexicalEnvironment;
+              const fo = OrdinaryFunctionCreate(node, env);
+              env.CreateBinding(fn);
+              CallFunction(fo);
+              return;
+            }
+
+          case "FunctionExpression":
+            {
+              const closure = InstantiateOrdinaryFunctionExpression(node);
+              CallFunction(closure);
+              return;
+            }
+
+          case "IfStatement":
+            Evaluate(node.test);
+            Evaluate(node.consequent);
+            Evaluate(node.alternate);
+            return;
+
+          case "ReturnStatement":
+          case "ThrowStatement":
+          case "UpdateExpression":
+            Evaluate(node.argument);
+            return;
+
+          case "SwitchCase":
+            Evaluate(node.test);
+            Evaluate(node.consequent);
+            return;
+
+          case "SwitchStatement":
+            {
+              Evaluate(node.discriminant);
+              const runningContext = getRunningContext();
+              const oldEnv = runningContext.LexicalEnvironment;
+              const blockEnv = new _AnalysisContext.AnalysisEnvironment(oldEnv);
+              BlockDeclarationInstantiation(node.cases, blockEnv);
+              runningContext.LexicalEnvironment = blockEnv;
+              Evaluate(node.cases);
+              runningContext.LexicalEnvironment = oldEnv;
+              return;
+            }
+
+          case "TryStatement":
+            Evaluate(node.block);
+            Evaluate(node.handler);
+            Evaluate(node.finalizer);
+            return;
+
+          case "VariableDeclaration":
+            Evaluate(node.declarations);
+            return;
+
+          case "VariableDeclarator":
+            Evaluate(node.id);
+            Evaluate(node.init);
+            return;
+
+          case "WhileStatement":
+            Evaluate(node.test);
+            Evaluate(node.body);
+            return;
+        }
+      }
+
+      if (visitors && (0, _hasOwnProperty.hasOwnProperty)(visitors, "__UnknownNode")) {
+        visitors.__UnknownNode(node);
+      } else {
+        // eslint-disable-next-line no-console
+        console.warn(`Unsupported node type \`${node.type}\``);
+      }
+    }
+  }
+
+  function BoundNamesInstantiation(declarations, env) {
+    for (const name of (0, _traverse.collectBoundNames)(declarations)) {
+      env.CreateBinding(name);
+    }
+  }
+
+  function ResolveBinding(name) {
+    const env = getRunningContext().LexicalEnvironment;
+    return GetIdentifierReference(env, name);
+  }
+
+  function GetIdentifierReference(env, name) {
+    return !!env && (env.HasBinding(name) || GetIdentifierReference(env.OuterEnv, name));
+  }
+
+  function BlockDeclarationInstantiation(code, env) {
+    const declarations = (0, _traverse.collectScopedDeclarations)(code, {
+      var: false,
+      topLevel: false
+    });
+    BoundNamesInstantiation(declarations, env);
+  }
+
+  function CallFunction(closure) {
+    PrepareOrdinaryCall(closure);
+    FunctionDeclarationInstantiation(closure);
+    Evaluate(closure.ECMAScriptCode);
+    analysisContextStack.pop();
+  }
+
+  function PrepareOrdinaryCall(F) {
+    const calleeContext = new _AnalysisContext.AnalysisContext();
+    const localEnv = new _AnalysisContext.AnalysisEnvironment(F.Environment);
+    calleeContext.VariableEnvironment = localEnv;
+    calleeContext.LexicalEnvironment = localEnv;
+    analysisContextStack.push(calleeContext);
+  }
+
+  function FunctionDeclarationInstantiation(func) {
+    const calleeContext = getRunningContext();
+    const code = func.ECMAScriptCode;
+    const formals = func.FormalParameters;
+    const hasParameterExpressions = (0, _traverse.containsExpression)(formals);
+    const varDeclarations = (0, _traverse.collectScopedDeclarations)(code, {
+      var: true,
+      topLevel: true
+    });
+    const varNames = (0, _traverse.collectBoundNames)(varDeclarations);
+    const env = calleeContext.LexicalEnvironment;
+    BoundNamesInstantiation(formals, env);
+    Evaluate(formals);
+    let varEnv;
+
+    if (!hasParameterExpressions) {
+      // NOTE: Only a single Environment Record is needed for the parameters
+      // and top-level vars.
+      for (const n of varNames) {
+        env.CreateBinding(n);
+      }
+
+      varEnv = env;
+    } else {
+      // NOTE: A separate Environment Record is needed to ensure that closures
+      // created by expressions in the formal parameter list do not have
+      // visibility of declarations in the function body.
+      varEnv = new _AnalysisContext.AnalysisEnvironment(env);
+      calleeContext.VariableEnvironment = varEnv;
+
+      for (const n of varNames) {
+        varEnv.CreateBinding(n);
+      }
+    }
+
+    const lexEnv = varEnv;
+    calleeContext.LexicalEnvironment = lexEnv;
+    const lexDeclarations = (0, _traverse.collectScopedDeclarations)(code, {
+      var: false,
+      topLevel: true
+    });
+    BoundNamesInstantiation(lexDeclarations, lexEnv);
+  }
+
+  function InstantiateOrdinaryFunctionExpression(functionExpression) {
+    const scope = getRunningContext().LexicalEnvironment;
+
+    if (!functionExpression.id) {
+      return OrdinaryFunctionCreate(functionExpression, scope);
+    }
+
+    const name = functionExpression.id.name;
+    const funcEnv = new _AnalysisContext.AnalysisEnvironment(scope);
+    funcEnv.CreateBinding(name);
+    return OrdinaryFunctionCreate(functionExpression, funcEnv);
+  }
+
+  function OrdinaryFunctionCreate({
+    params,
+    body
+  }, scope) {
+    return {
+      FormalParameters: params,
+      ECMAScriptCode: body.type === "BlockStatement" ? body.body : body,
+      Environment: scope
+    };
+  }
+
+  Evaluate(rootAst);
+  return attemptToVisitGlobals;
+}
+//# sourceMappingURL=precook.js.map

package/dist/cjs/precook.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/precook.ts"],"names":["precook","rootAst","expressionOnly","visitors","attemptToVisitGlobals","Set","analysisContextStack","rootEnv","AnalysisEnvironment","rootContext","AnalysisContext","VariableEnvironment","LexicalEnvironment","push","getRunningContext","length","visit","node","type","Evaluate","Array","isArray","n","ResolveBinding","name","add","__GlobalVariable","elements","env","closure","OrdinaryFunctionCreate","CallFunction","left","right","callee","arguments","expression","test","consequent","alternate","object","computed","property","properties","key","value","argument","expressions","tag","quasi","body","runningContext","oldEnv","blockEnv","BlockDeclarationInstantiation","catchEnv","BoundNamesInstantiation","param","lexicalBinding","kind","newEnv","iterationEnv","init","loopEnv","update","fn","fo","CreateBinding","InstantiateOrdinaryFunctionExpression","discriminant","cases","block","handler","finalizer","declarations","id","__UnknownNode","console","warn","GetIdentifierReference","HasBinding","OuterEnv","code","var","topLevel","PrepareOrdinaryCall","FunctionDeclarationInstantiation","ECMAScriptCode","pop","F","calleeContext","localEnv","Environment","func","formals","FormalParameters","hasParameterExpressions","varDeclarations","varNames","varEnv","lexEnv","lexDeclarations","functionExpression","scope","funcEnv","params"],"mappings":"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","sourcesContent":["import {\n  ArrowFunctionExpression,\n  Expression,\n  FunctionDeclaration,\n  FunctionExpression,\n  Statement,\n  SwitchCase,\n  VariableDeclaration,\n} from \"@babel/types\";\nimport { hasOwnProperty } from \"./hasOwnProperty\";\nimport {\n  AnalysisContext,\n  AnalysisEnvironment,\n  AnalysisFunctionObject,\n} from \"./AnalysisContext\";\nimport { EstreeNode, EstreeVisitors, NodeWithBoundNames } from \"./interfaces\";\nimport {\n  collectBoundNames,\n  collectScopedDeclarations,\n  containsExpression,\n} from \"./traverse\";\n\nexport interface PrecookOptions {\n  expressionOnly?: boolean;\n  visitors?: EstreeVisitors;\n}\n\n/**\n * Analysis an AST of a storyboard function or an evaluation expression.\n *\n * @param rootAst - The root AST.\n * @param options - Analysis options.\n * @returns A set of global variables the root AST attempts to access.\n */\nexport function precook(\n  rootAst: Expression | FunctionDeclaration,\n  { expressionOnly, visitors }: PrecookOptions = {}\n): Set<string> {\n  const attemptToVisitGlobals = new Set<string>();\n  const analysisContextStack: AnalysisContext[] = [];\n  const rootEnv = new AnalysisEnvironment(null);\n  const rootContext = new AnalysisContext();\n  rootContext.VariableEnvironment = rootEnv;\n  rootContext.LexicalEnvironment = rootEnv;\n  analysisContextStack.push(rootContext);\n\n  function getRunningContext(): AnalysisContext {\n    return analysisContextStack[analysisContextStack.length - 1];\n  }\n\n  function visit(node: EstreeNode): void {\n    if (hasOwnProperty(visitors, node.type)) {\n      visitors[node.type](node);\n    }\n  }\n\n  function Evaluate(node: EstreeNode | EstreeNode[]): void {\n    if (Array.isArray(node)) {\n      for (const n of node) {\n        Evaluate(n);\n      }\n    } else if (node) {\n      // `node` maybe `null` in some cases.\n      visitors && visit(node);\n      // Expressions:\n      switch (node.type) {\n        case \"Identifier\":\n          if (!ResolveBinding(node.name)) {\n            attemptToVisitGlobals.add(node.name);\n            if (visitors && hasOwnProperty(visitors, \"__GlobalVariable\")) {\n              visitors.__GlobalVariable(node);\n            }\n          }\n          return;\n        case \"ArrayExpression\":\n        case \"ArrayPattern\":\n          Evaluate(node.elements);\n          return;\n        case \"ArrowFunctionExpression\": {\n          const env = getRunningContext().LexicalEnvironment;\n          const closure = OrdinaryFunctionCreate(node, env);\n          CallFunction(closure);\n          return;\n        }\n        case \"AssignmentPattern\":\n        case \"BinaryExpression\":\n        case \"LogicalExpression\":\n          Evaluate(node.left);\n          Evaluate(node.right);\n          return;\n        case \"CallExpression\":\n        case \"NewExpression\":\n          Evaluate(node.callee);\n          Evaluate(node.arguments);\n          return;\n        case \"ChainExpression\":\n          Evaluate(node.expression);\n          return;\n        case \"ConditionalExpression\":\n          Evaluate(node.test);\n          Evaluate(node.consequent);\n          Evaluate(node.alternate);\n          return;\n        case \"MemberExpression\":\n          Evaluate(node.object);\n          if (node.computed) {\n            Evaluate(node.property);\n          }\n          return;\n        case \"ObjectExpression\":\n        case \"ObjectPattern\":\n          Evaluate(node.properties);\n          return;\n        case \"Property\":\n          if (node.computed) {\n            Evaluate(node.key);\n          }\n          Evaluate(node.value);\n          return;\n        case \"RestElement\":\n        case \"SpreadElement\":\n        case \"UnaryExpression\":\n          Evaluate(node.argument);\n          return;\n        case \"SequenceExpression\":\n        case \"TemplateLiteral\":\n          Evaluate(node.expressions);\n          return;\n        case \"TaggedTemplateExpression\":\n          Evaluate(node.tag);\n          Evaluate(node.quasi);\n          return;\n        case \"Literal\":\n          return;\n      }\n      if (!expressionOnly) {\n        // Statements and assignments:\n        switch (node.type) {\n          case \"AssignmentExpression\":\n            Evaluate(node.right);\n            Evaluate(node.left);\n            return;\n          case \"BlockStatement\": {\n            if (!node.body.length) {\n              return;\n            }\n            const runningContext = getRunningContext();\n            const oldEnv = runningContext.LexicalEnvironment;\n            const blockEnv = new AnalysisEnvironment(oldEnv);\n            BlockDeclarationInstantiation(node.body, blockEnv);\n            runningContext.LexicalEnvironment = blockEnv;\n            Evaluate(node.body);\n            runningContext.LexicalEnvironment = oldEnv;\n            return;\n          }\n          case \"BreakStatement\":\n          case \"ContinueStatement\":\n          case \"EmptyStatement\":\n            return;\n          case \"CatchClause\": {\n            const runningContext = getRunningContext();\n            const oldEnv = runningContext.LexicalEnvironment;\n            const catchEnv = new AnalysisEnvironment(oldEnv);\n            BoundNamesInstantiation(node.param, catchEnv);\n            runningContext.LexicalEnvironment = catchEnv;\n            Evaluate(node.param);\n            Evaluate(node.body);\n            runningContext.LexicalEnvironment = oldEnv;\n            return;\n          }\n          case \"DoWhileStatement\":\n            Evaluate(node.body);\n            Evaluate(node.test);\n            return;\n          case \"ExpressionStatement\":\n          case \"TSAsExpression\":\n            Evaluate(node.expression);\n            return;\n          case \"ForInStatement\":\n          case \"ForOfStatement\": {\n            // ForIn/OfHeadEvaluation\n            const lexicalBinding =\n              node.left.type === \"VariableDeclaration\" &&\n              node.left.kind !== \"var\";\n            const runningContext = getRunningContext();\n            const oldEnv = runningContext.LexicalEnvironment;\n            if (lexicalBinding) {\n              const newEnv = new AnalysisEnvironment(oldEnv);\n              BoundNamesInstantiation(node.left, newEnv);\n              runningContext.LexicalEnvironment = newEnv;\n            }\n            Evaluate(node.right);\n            runningContext.LexicalEnvironment = oldEnv;\n\n            // ForIn/OfBodyEvaluation\n            if (lexicalBinding) {\n              const iterationEnv = new AnalysisEnvironment(oldEnv);\n              BoundNamesInstantiation(node.left, iterationEnv);\n              runningContext.LexicalEnvironment = iterationEnv;\n            }\n            Evaluate(node.left);\n            Evaluate(node.body);\n            runningContext.LexicalEnvironment = oldEnv;\n            return;\n          }\n          case \"ForStatement\": {\n            const lexicalBinding =\n              node.init?.type === \"VariableDeclaration\" &&\n              node.init.kind !== \"var\";\n            const runningContext = getRunningContext();\n            const oldEnv = runningContext.LexicalEnvironment;\n            if (lexicalBinding) {\n              const loopEnv = new AnalysisEnvironment(oldEnv);\n              BoundNamesInstantiation(\n                node.init as VariableDeclaration,\n                loopEnv\n              );\n              runningContext.LexicalEnvironment = loopEnv;\n            }\n            Evaluate(node.init);\n            Evaluate(node.test);\n            Evaluate(node.body);\n            Evaluate(node.update);\n            runningContext.LexicalEnvironment = oldEnv;\n            return;\n          }\n          case \"FunctionDeclaration\": {\n            const [fn] = collectBoundNames(node);\n            const env = getRunningContext().LexicalEnvironment;\n            const fo = OrdinaryFunctionCreate(node, env);\n            env.CreateBinding(fn);\n            CallFunction(fo);\n            return;\n          }\n          case \"FunctionExpression\": {\n            const closure = InstantiateOrdinaryFunctionExpression(node);\n            CallFunction(closure);\n            return;\n          }\n          case \"IfStatement\":\n            Evaluate(node.test);\n            Evaluate(node.consequent);\n            Evaluate(node.alternate);\n            return;\n          case \"ReturnStatement\":\n          case \"ThrowStatement\":\n          case \"UpdateExpression\":\n            Evaluate(node.argument);\n            return;\n          case \"SwitchCase\":\n            Evaluate(node.test);\n            Evaluate(node.consequent);\n            return;\n          case \"SwitchStatement\": {\n            Evaluate(node.discriminant);\n            const runningContext = getRunningContext();\n            const oldEnv = runningContext.LexicalEnvironment;\n            const blockEnv = new AnalysisEnvironment(oldEnv);\n            BlockDeclarationInstantiation(node.cases, blockEnv);\n            runningContext.LexicalEnvironment = blockEnv;\n            Evaluate(node.cases);\n            runningContext.LexicalEnvironment = oldEnv;\n            return;\n          }\n          case \"TryStatement\":\n            Evaluate(node.block);\n            Evaluate(node.handler);\n            Evaluate(node.finalizer);\n            return;\n          case \"VariableDeclaration\":\n            Evaluate(node.declarations);\n            return;\n          case \"VariableDeclarator\":\n            Evaluate(node.id);\n            Evaluate(node.init);\n            return;\n          case \"WhileStatement\":\n            Evaluate(node.test);\n            Evaluate(node.body);\n            return;\n        }\n      }\n      if (visitors && hasOwnProperty(visitors, \"__UnknownNode\")) {\n        visitors.__UnknownNode(node);\n      } else {\n        // eslint-disable-next-line no-console\n        console.warn(`Unsupported node type \\`${node.type}\\``);\n      }\n    }\n  }\n\n  function BoundNamesInstantiation(\n    declarations: NodeWithBoundNames | NodeWithBoundNames[],\n    env: AnalysisEnvironment\n  ): void {\n    for (const name of collectBoundNames(declarations)) {\n      env.CreateBinding(name);\n    }\n  }\n\n  function ResolveBinding(name: string): boolean {\n    const env = getRunningContext().LexicalEnvironment;\n    return GetIdentifierReference(env, name);\n  }\n\n  function GetIdentifierReference(\n    env: AnalysisEnvironment,\n    name: string\n  ): boolean {\n    return (\n      !!env &&\n      (env.HasBinding(name) || GetIdentifierReference(env.OuterEnv, name))\n    );\n  }\n\n  function BlockDeclarationInstantiation(\n    code: Statement[] | SwitchCase[],\n    env: AnalysisEnvironment\n  ): void {\n    const declarations = collectScopedDeclarations(code, {\n      var: false,\n      topLevel: false,\n    });\n    BoundNamesInstantiation(declarations, env);\n  }\n\n  function CallFunction(closure: AnalysisFunctionObject): void {\n    PrepareOrdinaryCall(closure);\n    FunctionDeclarationInstantiation(closure);\n    Evaluate(closure.ECMAScriptCode);\n    analysisContextStack.pop();\n  }\n\n  function PrepareOrdinaryCall(F: AnalysisFunctionObject): void {\n    const calleeContext = new AnalysisContext();\n    const localEnv = new AnalysisEnvironment(F.Environment);\n    calleeContext.VariableEnvironment = localEnv;\n    calleeContext.LexicalEnvironment = localEnv;\n    analysisContextStack.push(calleeContext);\n  }\n\n  function FunctionDeclarationInstantiation(\n    func: AnalysisFunctionObject\n  ): void {\n    const calleeContext = getRunningContext();\n    const code = func.ECMAScriptCode;\n    const formals = func.FormalParameters;\n    const hasParameterExpressions = containsExpression(formals);\n    const varDeclarations = collectScopedDeclarations(code, {\n      var: true,\n      topLevel: true,\n    });\n    const varNames = collectBoundNames(varDeclarations);\n\n    const env = calleeContext.LexicalEnvironment;\n    BoundNamesInstantiation(formals, env);\n\n    Evaluate(formals);\n\n    let varEnv: AnalysisEnvironment;\n    if (!hasParameterExpressions) {\n      // NOTE: Only a single Environment Record is needed for the parameters\n      // and top-level vars.\n      for (const n of varNames) {\n        env.CreateBinding(n);\n      }\n      varEnv = env;\n    } else {\n      // NOTE: A separate Environment Record is needed to ensure that closures\n      // created by expressions in the formal parameter list do not have\n      // visibility of declarations in the function body.\n      varEnv = new AnalysisEnvironment(env);\n      calleeContext.VariableEnvironment = varEnv;\n      for (const n of varNames) {\n        varEnv.CreateBinding(n);\n      }\n    }\n    const lexEnv = varEnv;\n    calleeContext.LexicalEnvironment = lexEnv;\n\n    const lexDeclarations = collectScopedDeclarations(code, {\n      var: false,\n      topLevel: true,\n    });\n    BoundNamesInstantiation(lexDeclarations, lexEnv);\n  }\n\n  function InstantiateOrdinaryFunctionExpression(\n    functionExpression: FunctionExpression\n  ): AnalysisFunctionObject {\n    const scope = getRunningContext().LexicalEnvironment;\n    if (!functionExpression.id) {\n      return OrdinaryFunctionCreate(functionExpression, scope);\n    }\n    const name = functionExpression.id.name;\n    const funcEnv = new AnalysisEnvironment(scope);\n    funcEnv.CreateBinding(name);\n    return OrdinaryFunctionCreate(functionExpression, funcEnv);\n  }\n\n  function OrdinaryFunctionCreate(\n    {\n      params,\n      body,\n    }: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression,\n    scope: AnalysisEnvironment\n  ): AnalysisFunctionObject {\n    return {\n      FormalParameters: params,\n      ECMAScriptCode: body.type === \"BlockStatement\" ? body.body : body,\n      Environment: scope,\n    };\n  }\n\n  Evaluate(rootAst);\n\n  return attemptToVisitGlobals;\n}\n"],"file":"precook.js"}

package/dist/cjs/precookFunction.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.precookFunction = precookFunction;
+
+var _parse = require("./parse");
+
+var _precook = require("./precook");
+
+function precookFunction(source, {
+  typescript,
+  ...restOptions
+} = {}) {
+  const func = (0, _parse.parseAsEstree)(source, {
+    typescript
+  });
+  const attemptToVisitGlobals = (0, _precook.precook)(func, restOptions);
+  return {
+    function: func,
+    attemptToVisitGlobals
+  };
+}
+//# sourceMappingURL=precookFunction.js.map

package/dist/cjs/precookFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/precookFunction.ts"],"names":["precookFunction","source","typescript","restOptions","func","attemptToVisitGlobals","function"],"mappings":";;;;;;;AACA;;AACA;;AAWO,SAASA,eAAT,CACLC,MADK,EAEL;AAAEC,EAAAA,UAAF;AAAc,KAAGC;AAAjB,IAAyD,EAFpD,EAGkB;AACvB,QAAMC,IAAI,GAAG,0BAAcH,MAAd,EAAsB;AAAEC,IAAAA;AAAF,GAAtB,CAAb;AACA,QAAMG,qBAAqB,GAAG,sBAAQD,IAAR,EAAcD,WAAd,CAA9B;AACA,SAAO;AACLG,IAAAA,QAAQ,EAAEF,IADL;AAELC,IAAAA;AAFK,GAAP;AAID","sourcesContent":["import { FunctionDeclaration } from \"@babel/types\";\nimport { parseAsEstree } from \"./parse\";\nimport { precook, PrecookOptions } from \"./precook\";\n\nexport interface PrecookFunctionOptions extends PrecookOptions {\n  typescript?: boolean;\n}\n\nexport interface PrecookFunctionResult {\n  function: FunctionDeclaration;\n  attemptToVisitGlobals: Set<string>;\n}\n\nexport function precookFunction(\n  source: string,\n  { typescript, ...restOptions }: PrecookFunctionOptions = {}\n): PrecookFunctionResult {\n  const func = parseAsEstree(source, { typescript });\n  const attemptToVisitGlobals = precook(func, restOptions);\n  return {\n    function: func,\n    attemptToVisitGlobals,\n  };\n}\n"],"file":"precookFunction.js"}

package/dist/cjs/preevaluate.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.preevaluate = preevaluate;
+exports.isEvaluable = isEvaluable;
+exports.shouldAllowRecursiveEvaluations = shouldAllowRecursiveEvaluations;
+
+var _parse = require("./parse");
+
+var _precook = require("./precook");
+
+// `raw` should always be asserted by `isEvaluable`.
+function preevaluate(raw, options) {
+  const source = raw.replace(/^\s*<%~?\s|\s%>\s*$/g, "");
+  const expression = (0, _parse.parseAsEstreeExpression)(source);
+  const attemptToVisitGlobals = (0, _precook.precook)(expression, { ...options,
+    expressionOnly: true
+  });
+  return {
+    expression,
+    attemptToVisitGlobals,
+    source
+  };
+}
+
+function isEvaluable(raw) {
+  return /^\s*<%~?\s/.test(raw) && /\s%>\s*$/.test(raw);
+}
+
+function shouldAllowRecursiveEvaluations(raw) {
+  return /^\s*<%~\s/.test(raw);
+}
+//# sourceMappingURL=preevaluate.js.map

package/dist/cjs/preevaluate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preevaluate.ts"],"names":["preevaluate","raw","options","source","replace","expression","attemptToVisitGlobals","expressionOnly","isEvaluable","test","shouldAllowRecursiveEvaluations"],"mappings":";;;;;;;;;AACA;;AACA;;AAaA;AACO,SAASA,WAAT,CACLC,GADK,EAELC,OAFK,EAGc;AACnB,QAAMC,MAAM,GAAGF,GAAG,CAACG,OAAJ,CAAY,sBAAZ,EAAoC,EAApC,CAAf;AACA,QAAMC,UAAU,GAAG,oCAAwBF,MAAxB,CAAnB;AACA,QAAMG,qBAAqB,GAAG,sBAAQD,UAAR,EAAoB,EAChD,GAAGH,OAD6C;AAEhDK,IAAAA,cAAc,EAAE;AAFgC,GAApB,CAA9B;AAIA,SAAO;AACLF,IAAAA,UADK;AAELC,IAAAA,qBAFK;AAGLH,IAAAA;AAHK,GAAP;AAKD;;AAEM,SAASK,WAAT,CAAqBP,GAArB,EAA2C;AAChD,SAAO,aAAaQ,IAAb,CAAkBR,GAAlB,KAA0B,WAAWQ,IAAX,CAAgBR,GAAhB,CAAjC;AACD;;AAEM,SAASS,+BAAT,CAAyCT,GAAzC,EAA+D;AACpE,SAAO,YAAYQ,IAAZ,CAAiBR,GAAjB,CAAP;AACD","sourcesContent":["import { Expression } from \"@babel/types\";\nimport { parseAsEstreeExpression } from \"./parse\";\nimport { precook } from \"./precook\";\nimport { EstreeVisitors } from \"./interfaces\";\n\nexport interface PreevaluateOptions {\n  visitors?: EstreeVisitors;\n}\n\nexport interface PreevaluateResult {\n  expression: Expression;\n  attemptToVisitGlobals: Set<string>;\n  source: string;\n}\n\n// `raw` should always be asserted by `isEvaluable`.\nexport function preevaluate(\n  raw: string,\n  options?: PreevaluateOptions\n): PreevaluateResult {\n  const source = raw.replace(/^\\s*<%~?\\s|\\s%>\\s*$/g, \"\");\n  const expression = parseAsEstreeExpression(source);\n  const attemptToVisitGlobals = precook(expression, {\n    ...options,\n    expressionOnly: true,\n  });\n  return {\n    expression,\n    attemptToVisitGlobals,\n    source,\n  };\n}\n\nexport function isEvaluable(raw: string): boolean {\n  return /^\\s*<%~?\\s/.test(raw) && /\\s%>\\s*$/.test(raw);\n}\n\nexport function shouldAllowRecursiveEvaluations(raw: string): boolean {\n  return /^\\s*<%~\\s/.test(raw);\n}\n"],"file":"preevaluate.js"}

package/dist/cjs/sanitize.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitize = sanitize;
+exports.isAllowedConstructor = isAllowedConstructor;
+
+// Ref https://github.com/tc39/proposal-global
+// In addition, the es6-shim had to switch from Function('return this')()
+// due to CSP concerns, such that the current check to handle browsers,
+// node, web workers, and frames is:
+// istanbul ignore next
+// eslint-disable-next-line @typescript-eslint/ban-types
+function getGlobal() {
+  // the only reliable means to get the global object is
+  // `Function('return this')()`
+  // However, this causes CSP violations in Chrome apps.
+  if (typeof self !== "undefined") {
+    return self;
+  }
+
+  if (typeof window !== "undefined") {
+    return window;
+  }
+
+  if (typeof global !== "undefined") {
+    return global;
+  }
+
+  throw new Error("unable to locate global object");
+}
+/**
+ * There are chances to construct a `Function` from a string, etc.
+ * ```
+ * ((a,b)=>a[b])(()=>1, 'constructor')('console.log(`yo`)')()
+ * ```
+ */
+
+
+const reservedObjects = new WeakSet([// `Function("...")` is considered *extremely vulnerable*.
+Function, // `Object.assign()` is considered vulnerable.
+Object, // `prototype` is considered vulnerable.
+Function.prototype, Object.prototype, // Global `window` is considered vulnerable, too.
+getGlobal()]);
+
+function sanitize(cooked) {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  if (reservedObjects.has(cooked)) {
+    throw new TypeError("Cannot access reserved objects such as `Function`.");
+  }
+}
+
+const allowedConstructors = new WeakSet([Array, Date, Map, Set, URLSearchParams, WeakMap, WeakSet]);
+
+function isAllowedConstructor(constructor) {
+  return allowedConstructors.has(constructor);
+}
+//# sourceMappingURL=sanitize.js.map

package/dist/cjs/sanitize.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/sanitize.ts"],"names":["getGlobal","self","window","global","Error","reservedObjects","WeakSet","Function","Object","prototype","sanitize","cooked","has","TypeError","allowedConstructors","Array","Date","Map","Set","URLSearchParams","WeakMap","isAllowedConstructor","constructor"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,SAAT,GAA6B;AAC3B;AACA;AACA;AACA,MAAI,OAAOC,IAAP,KAAgB,WAApB,EAAiC;AAC/B,WAAOA,IAAP;AACD;;AACD,MAAI,OAAOC,MAAP,KAAkB,WAAtB,EAAmC;AACjC,WAAOA,MAAP;AACD;;AACD,MAAI,OAAOC,MAAP,KAAkB,WAAtB,EAAmC;AACjC,WAAOA,MAAP;AACD;;AACD,QAAM,IAAIC,KAAJ,CAAU,gCAAV,CAAN;AACD;AAED;AACA;AACA;AACA;AACA;AACA;;;AACA,MAAMC,eAAe,GAAG,IAAIC,OAAJ,CAAY,CAClC;AACAC,QAFkC,EAGlC;AACAC,MAJkC,EAKlC;AACAD,QAAQ,CAACE,SANyB,EAOlCD,MAAM,CAACC,SAP2B,EAQlC;AACAT,SAAS,EATyB,CAAZ,CAAxB;;AAYO,SAASU,QAAT,CAAkBC,MAAlB,EAAyC;AAC9C;AACA,MAAIN,eAAe,CAACO,GAAhB,CAAoBD,MAApB,CAAJ,EAA2C;AACzC,UAAM,IAAIE,SAAJ,CAAc,oDAAd,CAAN;AACD;AACF;;AAED,MAAMC,mBAAmB,GAAG,IAAIR,OAAJ,CAAY,CACtCS,KADsC,EAEtCC,IAFsC,EAGtCC,GAHsC,EAItCC,GAJsC,EAKtCC,eALsC,EAMtCC,OANsC,EAOtCd,OAPsC,CAAZ,CAA5B;;AAUO,SAASe,oBAAT,CAA8BC,WAA9B,EAA6D;AAClE,SAAOR,mBAAmB,CAACF,GAApB,CAAwBU,WAAxB,CAAP;AACD","sourcesContent":["// Ref https://github.com/tc39/proposal-global\n// In addition, the es6-shim had to switch from Function('return this')()\n// due to CSP concerns, such that the current check to handle browsers,\n// node, web workers, and frames is:\n// istanbul ignore next\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction getGlobal(): object {\n  // the only reliable means to get the global object is\n  // `Function('return this')()`\n  // However, this causes CSP violations in Chrome apps.\n  if (typeof self !== \"undefined\") {\n    return self;\n  }\n  if (typeof window !== \"undefined\") {\n    return window;\n  }\n  if (typeof global !== \"undefined\") {\n    return global;\n  }\n  throw new Error(\"unable to locate global object\");\n}\n\n/**\n * There are chances to construct a `Function` from a string, etc.\n * ```\n * ((a,b)=>a[b])(()=>1, 'constructor')('console.log(`yo`)')()\n * ```\n */\nconst reservedObjects = new WeakSet([\n  // `Function(\"...\")` is considered *extremely vulnerable*.\n  Function,\n  // `Object.assign()` is considered vulnerable.\n  Object,\n  // `prototype` is considered vulnerable.\n  Function.prototype,\n  Object.prototype,\n  // Global `window` is considered vulnerable, too.\n  getGlobal(),\n]);\n\nexport function sanitize(cooked: unknown): void {\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  if (reservedObjects.has(cooked as object)) {\n    throw new TypeError(\"Cannot access reserved objects such as `Function`.\");\n  }\n}\n\nconst allowedConstructors = new WeakSet([\n  Array,\n  Date,\n  Map,\n  Set,\n  URLSearchParams,\n  WeakMap,\n  WeakSet,\n]);\n\nexport function isAllowedConstructor(constructor: unknown): boolean {\n  return allowedConstructors.has(constructor as ArrayConstructor);\n}\n"],"file":"sanitize.js"}