@next-core/cook 1.0.1

package/dist/esm/precook.js

@@ -0,0 +1,435 @@
+import { hasOwnProperty } from "./hasOwnProperty";
+import { AnalysisContext, AnalysisEnvironment } from "./AnalysisContext";
+import { collectBoundNames, collectScopedDeclarations, containsExpression } from "./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.
+ */
+export function precook(rootAst, {
+  expressionOnly,
+  visitors
+} = {}) {
+  var attemptToVisitGlobals = new Set();
+  var analysisContextStack = [];
+  var rootEnv = new AnalysisEnvironment(null);
+  var rootContext = new AnalysisContext();
+  rootContext.VariableEnvironment = rootEnv;
+  rootContext.LexicalEnvironment = rootEnv;
+  analysisContextStack.push(rootContext);
+
+  function getRunningContext() {
+    return analysisContextStack[analysisContextStack.length - 1];
+  }
+
+  function visit(node) {
+    if (hasOwnProperty(visitors, node.type)) {
+      visitors[node.type](node);
+    }
+  }
+
+  function Evaluate(node) {
+    if (Array.isArray(node)) {
+      for (var 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 && hasOwnProperty(visitors, "__GlobalVariable")) {
+              visitors.__GlobalVariable(node);
+            }
+          }
+
+          return;
+
+        case "ArrayExpression":
+        case "ArrayPattern":
+          Evaluate(node.elements);
+          return;
+
+        case "ArrowFunctionExpression":
+          {
+            var env = getRunningContext().LexicalEnvironment;
+            var 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;
+              }
+
+              var runningContext = getRunningContext();
+              var oldEnv = runningContext.LexicalEnvironment;
+              var blockEnv = new 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":
+            {
+              var _runningContext = getRunningContext();
+
+              var _oldEnv = _runningContext.LexicalEnvironment;
+              var catchEnv = new 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
+              var lexicalBinding = node.left.type === "VariableDeclaration" && node.left.kind !== "var";
+
+              var _runningContext2 = getRunningContext();
+
+              var _oldEnv2 = _runningContext2.LexicalEnvironment;
+
+              if (lexicalBinding) {
+                var newEnv = new AnalysisEnvironment(_oldEnv2);
+                BoundNamesInstantiation(node.left, newEnv);
+                _runningContext2.LexicalEnvironment = newEnv;
+              }
+
+              Evaluate(node.right);
+              _runningContext2.LexicalEnvironment = _oldEnv2; // ForIn/OfBodyEvaluation
+
+              if (lexicalBinding) {
+                var iterationEnv = new AnalysisEnvironment(_oldEnv2);
+                BoundNamesInstantiation(node.left, iterationEnv);
+                _runningContext2.LexicalEnvironment = iterationEnv;
+              }
+
+              Evaluate(node.left);
+              Evaluate(node.body);
+              _runningContext2.LexicalEnvironment = _oldEnv2;
+              return;
+            }
+
+          case "ForStatement":
+            {
+              var _node$init;
+
+              var _lexicalBinding = ((_node$init = node.init) === null || _node$init === void 0 ? void 0 : _node$init.type) === "VariableDeclaration" && node.init.kind !== "var";
+
+              var _runningContext3 = getRunningContext();
+
+              var _oldEnv3 = _runningContext3.LexicalEnvironment;
+
+              if (_lexicalBinding) {
+                var loopEnv = new AnalysisEnvironment(_oldEnv3);
+                BoundNamesInstantiation(node.init, loopEnv);
+                _runningContext3.LexicalEnvironment = loopEnv;
+              }
+
+              Evaluate(node.init);
+              Evaluate(node.test);
+              Evaluate(node.body);
+              Evaluate(node.update);
+              _runningContext3.LexicalEnvironment = _oldEnv3;
+              return;
+            }
+
+          case "FunctionDeclaration":
+            {
+              var [fn] = collectBoundNames(node);
+              var _env = getRunningContext().LexicalEnvironment;
+              var fo = OrdinaryFunctionCreate(node, _env);
+
+              _env.CreateBinding(fn);
+
+              CallFunction(fo);
+              return;
+            }
+
+          case "FunctionExpression":
+            {
+              var _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);
+
+              var _runningContext4 = getRunningContext();
+
+              var _oldEnv4 = _runningContext4.LexicalEnvironment;
+
+              var _blockEnv = new AnalysisEnvironment(_oldEnv4);
+
+              BlockDeclarationInstantiation(node.cases, _blockEnv);
+              _runningContext4.LexicalEnvironment = _blockEnv;
+              Evaluate(node.cases);
+              _runningContext4.LexicalEnvironment = _oldEnv4;
+              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 && hasOwnProperty(visitors, "__UnknownNode")) {
+        visitors.__UnknownNode(node);
+      } else {
+        // eslint-disable-next-line no-console
+        console.warn("Unsupported node type `".concat(node.type, "`"));
+      }
+    }
+  }
+
+  function BoundNamesInstantiation(declarations, env) {
+    for (var name of collectBoundNames(declarations)) {
+      env.CreateBinding(name);
+    }
+  }
+
+  function ResolveBinding(name) {
+    var env = getRunningContext().LexicalEnvironment;
+    return GetIdentifierReference(env, name);
+  }
+
+  function GetIdentifierReference(env, name) {
+    return !!env && (env.HasBinding(name) || GetIdentifierReference(env.OuterEnv, name));
+  }
+
+  function BlockDeclarationInstantiation(code, env) {
+    var declarations = collectScopedDeclarations(code, {
+      var: false,
+      topLevel: false
+    });
+    BoundNamesInstantiation(declarations, env);
+  }
+
+  function CallFunction(closure) {
+    PrepareOrdinaryCall(closure);
+    FunctionDeclarationInstantiation(closure);
+    Evaluate(closure.ECMAScriptCode);
+    analysisContextStack.pop();
+  }
+
+  function PrepareOrdinaryCall(F) {
+    var calleeContext = new AnalysisContext();
+    var localEnv = new AnalysisEnvironment(F.Environment);
+    calleeContext.VariableEnvironment = localEnv;
+    calleeContext.LexicalEnvironment = localEnv;
+    analysisContextStack.push(calleeContext);
+  }
+
+  function FunctionDeclarationInstantiation(func) {
+    var calleeContext = getRunningContext();
+    var code = func.ECMAScriptCode;
+    var formals = func.FormalParameters;
+    var hasParameterExpressions = containsExpression(formals);
+    var varDeclarations = collectScopedDeclarations(code, {
+      var: true,
+      topLevel: true
+    });
+    var varNames = collectBoundNames(varDeclarations);
+    var env = calleeContext.LexicalEnvironment;
+    BoundNamesInstantiation(formals, env);
+    Evaluate(formals);
+    var varEnv;
+
+    if (!hasParameterExpressions) {
+      // NOTE: Only a single Environment Record is needed for the parameters
+      // and top-level vars.
+      for (var 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 AnalysisEnvironment(env);
+      calleeContext.VariableEnvironment = varEnv;
+
+      for (var _n of varNames) {
+        varEnv.CreateBinding(_n);
+      }
+    }
+
+    var lexEnv = varEnv;
+    calleeContext.LexicalEnvironment = lexEnv;
+    var lexDeclarations = collectScopedDeclarations(code, {
+      var: false,
+      topLevel: true
+    });
+    BoundNamesInstantiation(lexDeclarations, lexEnv);
+  }
+
+  function InstantiateOrdinaryFunctionExpression(functionExpression) {
+    var scope = getRunningContext().LexicalEnvironment;
+
+    if (!functionExpression.id) {
+      return OrdinaryFunctionCreate(functionExpression, scope);
+    }
+
+    var name = functionExpression.id.name;
+    var funcEnv = new 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/esm/precook.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/precook.ts"],"names":["hasOwnProperty","AnalysisContext","AnalysisEnvironment","collectBoundNames","collectScopedDeclarations","containsExpression","precook","rootAst","expressionOnly","visitors","attemptToVisitGlobals","Set","analysisContextStack","rootEnv","rootContext","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/esm/precookFunction.js

@@ -0,0 +1,20 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["typescript"];
+import { parseAsEstree } from "./parse";
+import { precook } from "./precook";
+export function precookFunction(source, _ref = {}) {
+  var {
+    typescript
+  } = _ref,
+      restOptions = _objectWithoutProperties(_ref, _excluded);
+
+  var func = parseAsEstree(source, {
+    typescript
+  });
+  var attemptToVisitGlobals = precook(func, restOptions);
+  return {
+    function: func,
+    attemptToVisitGlobals
+  };
+}
+//# sourceMappingURL=precookFunction.js.map

package/dist/esm/precookFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/precookFunction.ts"],"names":["parseAsEstree","precook","precookFunction","source","typescript","restOptions","func","attemptToVisitGlobals","function"],"mappings":";;AACA,SAASA,aAAT,QAA8B,SAA9B;AACA,SAASC,OAAT,QAAwC,WAAxC;AAWA,OAAO,SAASC,eAAT,CACLC,MADK,EAEL,OAAyD,EAFpD,EAGkB;AAAA,MADvB;AAAEC,IAAAA;AAAF,GACuB;AAAA,MADNC,WACM;;AACvB,MAAMC,IAAI,GAAGN,aAAa,CAACG,MAAD,EAAS;AAAEC,IAAAA;AAAF,GAAT,CAA1B;AACA,MAAMG,qBAAqB,GAAGN,OAAO,CAACK,IAAD,EAAOD,WAAP,CAArC;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/esm/preevaluate.js

@@ -0,0 +1,23 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import { parseAsEstreeExpression } from "./parse";
+import { precook } from "./precook";
+// `raw` should always be asserted by `isEvaluable`.
+export function preevaluate(raw, options) {
+  var source = raw.replace(/^\s*<%~?\s|\s%>\s*$/g, "");
+  var expression = parseAsEstreeExpression(source);
+  var attemptToVisitGlobals = precook(expression, _objectSpread(_objectSpread({}, options), {}, {
+    expressionOnly: true
+  }));
+  return {
+    expression,
+    attemptToVisitGlobals,
+    source
+  };
+}
+export function isEvaluable(raw) {
+  return /^\s*<%~?\s/.test(raw) && /\s%>\s*$/.test(raw);
+}
+export function shouldAllowRecursiveEvaluations(raw) {
+  return /^\s*<%~\s/.test(raw);
+}
+//# sourceMappingURL=preevaluate.js.map

package/dist/esm/preevaluate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/preevaluate.ts"],"names":["parseAsEstreeExpression","precook","preevaluate","raw","options","source","replace","expression","attemptToVisitGlobals","expressionOnly","isEvaluable","test","shouldAllowRecursiveEvaluations"],"mappings":";AACA,SAASA,uBAAT,QAAwC,SAAxC;AACA,SAASC,OAAT,QAAwB,WAAxB;AAaA;AACA,OAAO,SAASC,WAAT,CACLC,GADK,EAELC,OAFK,EAGc;AACnB,MAAMC,MAAM,GAAGF,GAAG,CAACG,OAAJ,CAAY,sBAAZ,EAAoC,EAApC,CAAf;AACA,MAAMC,UAAU,GAAGP,uBAAuB,CAACK,MAAD,CAA1C;AACA,MAAMG,qBAAqB,GAAGP,OAAO,CAACM,UAAD,kCAChCH,OADgC;AAEnCK,IAAAA,cAAc,EAAE;AAFmB,KAArC;AAIA,SAAO;AACLF,IAAAA,UADK;AAELC,IAAAA,qBAFK;AAGLH,IAAAA;AAHK,GAAP;AAKD;AAED,OAAO,SAASK,WAAT,CAAqBP,GAArB,EAA2C;AAChD,SAAO,aAAaQ,IAAb,CAAkBR,GAAlB,KAA0B,WAAWQ,IAAX,CAAgBR,GAAhB,CAAjC;AACD;AAED,OAAO,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/esm/sanitize.js

@@ -0,0 +1,48 @@
+// 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`)')()
+ * ```
+ */
+
+
+var 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()]);
+export 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`.");
+  }
+}
+var allowedConstructors = new WeakSet([Array, Date, Map, Set, URLSearchParams, WeakMap, WeakSet]);
+export function isAllowedConstructor(constructor) {
+  return allowedConstructors.has(constructor);
+}
+//# sourceMappingURL=sanitize.js.map

package/dist/esm/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,IAAMC,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;AAYA,OAAO,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,IAAMC,mBAAmB,GAAG,IAAIR,OAAJ,CAAY,CACtCS,KADsC,EAEtCC,IAFsC,EAGtCC,GAHsC,EAItCC,GAJsC,EAKtCC,eALsC,EAMtCC,OANsC,EAOtCd,OAPsC,CAAZ,CAA5B;AAUA,OAAO,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"}