@next-core/brick-utils 2.30.2 → 2.31.2

package/dist/index.esm.js

@@ -2,9 +2,9 @@ import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
 import { uniq, get, cloneDeep, set, isEmpty, escapeRegExp } from 'lodash';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import { processPipes, utils } from '@next-core/pipes';
 export { pipes } from '@next-core/pipes';
-import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import yaml from 'js-yaml';
 
 var cache$1 = new Map();
@@ -18386,7 +18386,72 @@ function getParserClass(pluginsFromOptions) {
 
 var parse_1 = lib.parse = parse$1;
 var parseExpression_1 = lib.parseExpression = parseExpression;
-lib.tokTypes = tokTypes;
+var tokTypes_1 = lib.tokTypes = tokTypes;
+
+function parseAsEstreeExpression(source) {
+  return parseExpression_1(source, {
+    plugins: ["estree", ["pipelineOperator", {
+      proposal: "minimal"
+    }]],
+    attachComment: false
+  });
+}
+function parseAsEstree(source) {
+  var {
+    typescript
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var file = parse_1(source, {
+    plugins: ["estree", typescript && "typescript"].filter(Boolean),
+    strictMode: true,
+    attachComment: false
+  });
+  var body = file.program.body;
+  var jsNodes = typescript ? [] : body;
+
+  if (typescript) {
+    for (var node of body) {
+      if (node.type.startsWith("TS")) {
+        if (/Enum|Import|Export/.test(node.type)) {
+          throw new SyntaxError("Unsupported TypeScript syntax: ".concat(node.type));
+        }
+      } else {
+        jsNodes.push(node);
+      }
+    }
+  }
+
+  if (jsNodes.length === 0) {
+    throw new SyntaxError("Function declaration not found");
+  }
+
+  if (jsNodes.length > 1 || jsNodes[0].type !== "FunctionDeclaration") {
+    throw new SyntaxError("Expect a single function declaration at top level, but received: ".concat(jsNodes.map(node => "\"".concat(node.type, "\"")).join(", ")));
+  }
+
+  return jsNodes[0];
+}
+/** For next-core internal or devtools usage only. */
+
+function parseForAnalysis(source) {
+  var {
+    typescript,
+    tokens
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  try {
+    return parse_1(source, {
+      plugins: ["estree", typescript && "typescript"].filter(Boolean),
+      strictMode: true,
+      attachComment: false,
+      // Allow export/import declarations to make analyser handle errors.
+      sourceType: "unambiguous",
+      tokens
+    });
+  } catch (e) {
+    // Return no errors if parse failed.
+    return null;
+  }
+}
 
 function hasOwnProperty(object, property) {
   return Object.prototype.hasOwnProperty.call(object, property);
@@ -18432,6 +18497,7 @@ function precook(rootAst) {
   var {
     expressionOnly,
     visitors,
+    withParent,
     hooks = {}
   } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var attemptToVisitGlobals = new Set();
@@ -18452,102 +18518,107 @@ function precook(rootAst) {
     }
   }
 
-  function Evaluate(node) {
+  function EvaluateChildren(node, keys, parent) {
+    for (var key of keys) {
+      Evaluate(node[key], parent === null || parent === void 0 ? void 0 : parent.concat({
+        node,
+        key
+      }));
+    }
+  }
+
+  function Evaluate(node, parent) {
     if (Array.isArray(node)) {
-      for (var n of node) {
-        Evaluate(n);
-      }
+      node.forEach((n, index) => {
+        Evaluate(n, parent ? parent.slice(0, -1).concat(_objectSpread(_objectSpread({}, parent[parent.length - 1]), {}, {
+          index
+        })) : parent);
+      });
     } else if (node) {
-      var _hooks$beforeVisit; // `node` maybe `null` in some cases.
+      var _hooks$beforeVisit, _hooks$beforeVisitUnk; // `node` maybe `null` in some cases.
 
 
-      (_hooks$beforeVisit = hooks.beforeVisit) === null || _hooks$beforeVisit === void 0 ? void 0 : _hooks$beforeVisit.call(hooks, node);
+      (_hooks$beforeVisit = hooks.beforeVisit) === null || _hooks$beforeVisit === void 0 ? void 0 : _hooks$beforeVisit.call(hooks, node, parent);
       visitors && visit(node); // Expressions:
 
       switch (node.type) {
         case "Identifier":
           if (!ResolveBinding(node.name)) {
-            attemptToVisitGlobals.add(node.name);
+            var _hooks$beforeVisitGlo;
 
-            if (visitors && hasOwnProperty(visitors, "__GlobalVariable")) {
-              visitors.__GlobalVariable(node);
-            }
+            (_hooks$beforeVisitGlo = hooks.beforeVisitGlobal) === null || _hooks$beforeVisitGlo === void 0 ? void 0 : _hooks$beforeVisitGlo.call(hooks, node, parent);
+            attemptToVisitGlobals.add(node.name);
           }
 
           return;
 
         case "ArrayExpression":
         case "ArrayPattern":
-          Evaluate(node.elements);
+          EvaluateChildren(node, ["elements"], parent);
           return;
 
         case "ArrowFunctionExpression":
           {
             var env = getRunningContext().LexicalEnvironment;
             var closure = OrdinaryFunctionCreate(node, env);
-            CallFunction(closure);
+            CallFunction(closure, parent);
             return;
           }
 
         case "AssignmentPattern":
         case "BinaryExpression":
         case "LogicalExpression":
-          Evaluate(node.left);
-          Evaluate(node.right);
+          EvaluateChildren(node, ["left", "right"], parent);
           return;
 
         case "CallExpression":
         case "NewExpression":
-          Evaluate(node.callee);
-          Evaluate(node.arguments);
+          EvaluateChildren(node, ["callee", "arguments"], parent);
           return;
 
         case "ChainExpression":
-          Evaluate(node.expression);
+          EvaluateChildren(node, ["expression"], parent);
           return;
 
         case "ConditionalExpression":
-          Evaluate(node.test);
-          Evaluate(node.consequent);
-          Evaluate(node.alternate);
+          EvaluateChildren(node, ["test", "consequent", "alternate"], parent);
           return;
 
         case "MemberExpression":
-          Evaluate(node.object);
+          EvaluateChildren(node, ["object"], parent);
 
           if (node.computed) {
-            Evaluate(node.property);
+            EvaluateChildren(node, ["property"], parent);
           }
 
           return;
 
         case "ObjectExpression":
         case "ObjectPattern":
-          Evaluate(node.properties);
+          EvaluateChildren(node, ["properties"], parent);
           return;
 
         case "Property":
           if (node.computed) {
-            Evaluate(node.key);
+            EvaluateChildren(node, ["key"], parent);
           }
 
-          Evaluate(node.value);
+          EvaluateChildren(node, ["value"], parent);
           return;
 
         case "RestElement":
         case "SpreadElement":
         case "UnaryExpression":
-          Evaluate(node.argument);
+          EvaluateChildren(node, ["argument"], parent);
           return;
 
         case "SequenceExpression":
         case "TemplateLiteral":
-          Evaluate(node.expressions);
+          EvaluateChildren(node, ["expressions"], parent);
           return;
 
         case "TaggedTemplateExpression":
-          Evaluate(node.tag);
-          Evaluate(node.quasi);
+          EvaluateChildren(node, ["tag", "quasi"], parent);
           return;
 
         case "Literal":
@@ -18558,8 +18629,7 @@ function precook(rootAst) {
         // Statements and assignments:
         switch (node.type) {
           case "AssignmentExpression":
-            Evaluate(node.right);
-            Evaluate(node.left);
+            EvaluateChildren(node, ["right", "left"], parent);
             return;
 
           case "BlockStatement":
@@ -18573,7 +18643,7 @@ function precook(rootAst) {
               var blockEnv = new AnalysisEnvironment(oldEnv);
               BlockDeclarationInstantiation(node.body, blockEnv);
               runningContext.LexicalEnvironment = blockEnv;
-              Evaluate(node.body);
+              EvaluateChildren(node, ["body"], parent);
               runningContext.LexicalEnvironment = oldEnv;
               return;
             }
@@ -18591,20 +18661,18 @@ function precook(rootAst) {
               var catchEnv = new AnalysisEnvironment(_oldEnv);
               BoundNamesInstantiation(node.param, catchEnv);
               _runningContext.LexicalEnvironment = catchEnv;
-              Evaluate(node.param);
-              Evaluate(node.body);
+              EvaluateChildren(node, ["param", "body"], parent);
               _runningContext.LexicalEnvironment = _oldEnv;
               return;
             }
 
           case "DoWhileStatement":
-            Evaluate(node.body);
-            Evaluate(node.test);
+            EvaluateChildren(node, ["body", "test"], parent);
             return;
 
           case "ExpressionStatement":
           case "TSAsExpression":
-            Evaluate(node.expression);
+            EvaluateChildren(node, ["expression"], parent);
             return;
 
           case "ForInStatement":
@@ -18623,7 +18691,7 @@ function precook(rootAst) {
                 _runningContext2.LexicalEnvironment = newEnv;
               }
 
-              Evaluate(node.right);
+              EvaluateChildren(node, ["right"], parent);
               _runningContext2.LexicalEnvironment = _oldEnv2; // ForIn/OfBodyEvaluation
 
               if (lexicalBinding) {
@@ -18632,8 +18700,7 @@ function precook(rootAst) {
                 _runningContext2.LexicalEnvironment = iterationEnv;
               }
 
-              Evaluate(node.left);
-              Evaluate(node.body);
+              EvaluateChildren(node, ["left", "body"], parent);
               _runningContext2.LexicalEnvironment = _oldEnv2;
               return;
             }
@@ -18654,10 +18721,7 @@ function precook(rootAst) {
                 _runningContext3.LexicalEnvironment = loopEnv;
               }
 
-              Evaluate(node.init);
-              Evaluate(node.test);
-              Evaluate(node.body);
-              Evaluate(node.update);
+              EvaluateChildren(node, ["init", "test", "body", "update"], parent);
               _runningContext3.LexicalEnvironment = _oldEnv3;
               return;
             }
@@ -18670,7 +18734,7 @@ function precook(rootAst) {
 
               _env.CreateBinding(fn);
 
-              CallFunction(fo);
+              CallFunction(fo, parent);
               return;
             }
 
@@ -18678,30 +18742,27 @@ function precook(rootAst) {
             {
               var _closure = InstantiateOrdinaryFunctionExpression(node);
 
-              CallFunction(_closure);
+              CallFunction(_closure, parent);
               return;
             }
 
           case "IfStatement":
-            Evaluate(node.test);
-            Evaluate(node.consequent);
-            Evaluate(node.alternate);
+            EvaluateChildren(node, ["test", "consequent", "alternate"], parent);
             return;
 
           case "ReturnStatement":
           case "ThrowStatement":
           case "UpdateExpression":
-            Evaluate(node.argument);
+            EvaluateChildren(node, ["argument"], parent);
             return;
 
           case "SwitchCase":
-            Evaluate(node.test);
-            Evaluate(node.consequent);
+            EvaluateChildren(node, ["test", "consequent"], parent);
             return;
 
           case "SwitchStatement":
             {
-              Evaluate(node.discriminant);
+              EvaluateChildren(node, ["discriminant"], parent);
 
               var _runningContext4 = getRunningContext();
 
@@ -18711,36 +18772,32 @@ function precook(rootAst) {
 
               BlockDeclarationInstantiation(node.cases, _blockEnv);
               _runningContext4.LexicalEnvironment = _blockEnv;
-              Evaluate(node.cases);
+              EvaluateChildren(node, ["cases"], parent);
               _runningContext4.LexicalEnvironment = _oldEnv4;
               return;
             }
 
           case "TryStatement":
-            Evaluate(node.block);
-            Evaluate(node.handler);
-            Evaluate(node.finalizer);
+            EvaluateChildren(node, ["block", "handler", "finalizer"], parent);
             return;
 
           case "VariableDeclaration":
-            Evaluate(node.declarations);
+            EvaluateChildren(node, ["declarations"], parent);
             return;
 
           case "VariableDeclarator":
-            Evaluate(node.id);
-            Evaluate(node.init);
+            EvaluateChildren(node, ["id", "init"], parent);
             return;
 
           case "WhileStatement":
-            Evaluate(node.test);
-            Evaluate(node.body);
+            EvaluateChildren(node, ["test", "body"], parent);
             return;
         }
       }
 
-      if (visitors && hasOwnProperty(visitors, "__UnknownNode")) {
-        visitors.__UnknownNode(node);
-      } else {
+      var silent = (_hooks$beforeVisitUnk = hooks.beforeVisitUnknown) === null || _hooks$beforeVisitUnk === void 0 ? void 0 : _hooks$beforeVisitUnk.call(hooks, node, parent);
+
+      if (!silent) {
         // eslint-disable-next-line no-console
         console.warn("Unsupported node type `".concat(node.type, "`"));
       }
@@ -18770,10 +18827,16 @@ function precook(rootAst) {
     BoundNamesInstantiation(declarations, env);
   }
 
-  function CallFunction(closure) {
+  function CallFunction(closure, parent) {
     PrepareOrdinaryCall(closure);
-    FunctionDeclarationInstantiation(closure);
-    Evaluate(closure.ECMAScriptCode);
+    FunctionDeclarationInstantiation(closure, parent);
+    Evaluate(closure.ECMAScriptCode, parent === null || parent === void 0 ? void 0 : parent.concat({
+      node: closure.Function,
+      key: "body"
+    }).concat(closure.Function.body.type === "BlockStatement" ? {
+      node: closure.Function.body,
+      key: "body"
+    } : []));
     analysisContextStack.pop();
   }
 
@@ -18785,7 +18848,7 @@ function precook(rootAst) {
     analysisContextStack.push(calleeContext);
   }
 
-  function FunctionDeclarationInstantiation(func) {
+  function FunctionDeclarationInstantiation(func, parent) {
     var calleeContext = getRunningContext();
     var code = func.ECMAScriptCode;
     var formals = func.FormalParameters;
@@ -18797,7 +18860,10 @@ function precook(rootAst) {
     var varNames = collectBoundNames(varDeclarations);
     var env = calleeContext.LexicalEnvironment;
     BoundNamesInstantiation(formals, env);
-    Evaluate(formals);
+    Evaluate(formals, parent === null || parent === void 0 ? void 0 : parent.concat({
+      node: func.Function,
+      key: "params"
+    }));
     var varEnv;
 
     if (!hasParameterExpressions) {
@@ -18842,19 +18908,16 @@ function precook(rootAst) {
     return OrdinaryFunctionCreate(functionExpression, funcEnv);
   }
 
-  function OrdinaryFunctionCreate(_ref, scope) {
-    var {
-      params,
-      body
-    } = _ref;
+  function OrdinaryFunctionCreate(func, scope) {
     return {
-      FormalParameters: params,
-      ECMAScriptCode: body.type === "BlockStatement" ? body.body : body,
+      Function: func,
+      FormalParameters: func.params,
+      ECMAScriptCode: func.body.type === "BlockStatement" ? func.body.body : func.body,
       Environment: scope
     };
   }
 
-  Evaluate(rootAst);
+  Evaluate(rootAst, withParent ? [] : undefined);
   return attemptToVisitGlobals;
 }
 
@@ -18866,17 +18929,11 @@ function lint(source) {
     rules
   } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var errors = [];
-  var file;
+  var file = typeof source === "string" ? parseForAnalysis(source, {
+    typescript
+  }) : source;
 
-  try {
-    file = parse_1(source, {
-      plugins: ["estree", typescript && "typescript"].filter(Boolean),
-      strictMode: true,
-      attachComment: false,
-      // Allow export/import declarations to make linter handle errors.
-      sourceType: "unambiguous"
-    });
-  } catch (e) {
+  if (!file) {
     // Return no errors if parse failed.
     return errors;
   }
@@ -18932,93 +18989,100 @@ function lint(source) {
       }
     });
   } else {
-    var FunctionVisitor = node => {
-      if (node.async || node.generator) {
-        errors.push({
-          type: "SyntaxError",
-          message: "".concat(node.async ? "Async" : "Generator", " function is not allowed"),
-          loc: node.loc
-        });
-      }
-    };
-
     precook(func, {
-      visitors: {
-        ArrowFunctionExpression: FunctionVisitor,
-        FunctionDeclaration: FunctionVisitor,
-        FunctionExpression: FunctionVisitor,
-
-        Literal(node) {
-          if (node.regex) {
-            if (node.value === null) {
-              errors.push({
-                type: "SyntaxError",
-                message: "Invalid regular expression",
-                loc: node.loc
-              });
-            } else if (node.regex.flags.includes("u")) {
-              errors.push({
-                type: "SyntaxError",
-                message: "Unsupported unicode flag in regular expression",
-                loc: node.loc
-              });
-            }
-          }
-        },
-
-        ObjectExpression(node) {
-          for (var prop of node.properties) {
-            if (prop.type === "Property") {
-              if (prop.kind !== "init") {
+      hooks: {
+        beforeVisit(node) {
+          switch (node.type) {
+            case "ArrowFunctionExpression":
+            case "FunctionDeclaration":
+            case "FunctionExpression":
+              if (node.async || node.generator) {
                 errors.push({
                   type: "SyntaxError",
-                  message: "Unsupported object getter/setter property",
-                  loc: prop.loc
+                  message: "".concat(node.async ? "Async" : "Generator", " function is not allowed"),
+                  loc: node.loc
                 });
-              } else if (!prop.computed && prop.key.type === "Identifier" && prop.key.name === "__proto__") {
+              }
+
+              break;
+
+            case "Literal":
+              if (node.regex) {
+                if (node.value === null) {
+                  errors.push({
+                    type: "SyntaxError",
+                    message: "Invalid regular expression",
+                    loc: node.loc
+                  });
+                } else if (node.regex.flags.includes("u")) {
+                  errors.push({
+                    type: "SyntaxError",
+                    message: "Unsupported unicode flag in regular expression",
+                    loc: node.loc
+                  });
+                }
+              }
+
+              break;
+
+            case "ObjectExpression":
+              for (var prop of node.properties) {
+                if (prop.type === "Property") {
+                  if (prop.kind !== "init") {
+                    errors.push({
+                      type: "SyntaxError",
+                      message: "Unsupported object getter/setter property",
+                      loc: prop.loc
+                    });
+                  } else if (!prop.computed && prop.key.type === "Identifier" && prop.key.name === "__proto__") {
+                    errors.push({
+                      type: "TypeError",
+                      message: "Setting '__proto__' property is not allowed",
+                      loc: prop.key.loc
+                    });
+                  }
+                }
+              }
+
+              break;
+
+            case "VariableDeclaration":
+              if (node.kind === "var" && rules !== null && rules !== void 0 && rules.noVar) {
                 errors.push({
-                  type: "TypeError",
-                  message: "Setting '__proto__' property is not allowed",
-                  loc: prop.key.loc
+                  type: "SyntaxError",
+                  message: "Var declaration is not recommended, use `let` or `const` instead",
+                  loc: {
+                    start: node.loc.start,
+                    end: {
+                      line: node.loc.end.line,
+                      // Only decorate the "var".
+                      column: node.loc.start.column + 3
+                    }
+                  }
                 });
               }
-            }
+
+              break;
           }
         },
 
-        VariableDeclaration(node) {
-          if (node.kind === "var" && rules !== null && rules !== void 0 && rules.noVar) {
+        beforeVisitGlobal(node) {
+          if (node.name === "arguments") {
             errors.push({
               type: "SyntaxError",
-              message: "Var declaration is not recommended, use `let` or `const` instead",
-              loc: {
-                start: node.loc.start,
-                end: {
-                  line: node.loc.end.line,
-                  // Only decorate the "var".
-                  column: node.loc.start.column + 3
-                }
-              }
+              message: "Use the rest parameters instead of 'arguments'",
+              loc: node.loc
             });
           }
         },
 
-        __UnknownNode(node) {
+        beforeVisitUnknown(node) {
           errors.push({
             type: "SyntaxError",
             message: "Unsupported syntax: `".concat(node.type, "`"),
             loc: node.loc
           });
-        },
-
-        __GlobalVariable(node) {
-          if (node.name === "arguments") {
-            errors.push({
-              type: "SyntaxError",
-              message: "Use the rest parameters instead of 'arguments'",
-              loc: node.loc
-            });
-          }
+          return true;
         }
 
       }
@@ -19028,49 +19092,6 @@ function lint(source) {
   return errors;
 }
 
-function parseAsEstreeExpression(source) {
-  return parseExpression_1(source, {
-    plugins: ["estree", ["pipelineOperator", {
-      proposal: "minimal"
-    }]],
-    attachComment: false
-  });
-}
-function parseAsEstree(source) {
-  var {
-    typescript
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var file = parse_1(source, {
-    plugins: ["estree", typescript && "typescript"].filter(Boolean),
-    strictMode: true,
-    attachComment: false
-  });
-  var body = file.program.body;
-  var jsNodes = typescript ? [] : body;
-
-  if (typescript) {
-    for (var node of body) {
-      if (node.type.startsWith("TS")) {
-        if (/Enum|Import|Export/.test(node.type)) {
-          throw new SyntaxError("Unsupported TypeScript syntax: ".concat(node.type));
-        }
-      } else {
-        jsNodes.push(node);
-      }
-    }
-  }
-
-  if (jsNodes.length === 0) {
-    throw new SyntaxError("Function declaration not found");
-  }
-
-  if (jsNodes.length > 1 || jsNodes[0].type !== "FunctionDeclaration") {
-    throw new SyntaxError("Expect a single function declaration at top level, but received: ".concat(jsNodes.map(node => "\"".concat(node.type, "\"")).join(", ")));
-  }
-
-  return jsNodes[0];
-}
-
 var _excluded = ["typescript"];
 function precookFunction(source) {
   var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
@@ -19156,12 +19177,16 @@ function collectProcessors(data, collection) {
   if (typeof data === "string") {
     if (data.includes(PROCESSORS) && isEvaluable(data)) {
       preevaluate(data, {
-        visitors: {
-          MemberExpression(node) {
-            var accessNamespace = node.object;
-
-            if (!node.computed && node.property.type === "Identifier" && accessNamespace.type === "MemberExpression" && !accessNamespace.computed && accessNamespace.object.type === "Identifier" && accessNamespace.object.name === PROCESSORS && accessNamespace.property.type === "Identifier") {
-              collection.push("".concat(accessNamespace.property.name, ".").concat(node.property.name));
+        withParent: true,
+        hooks: {
+          beforeVisitGlobal(node, parent) {
+            if (node.name === PROCESSORS) {
+              var memberParent = parent[parent.length - 1];
+              var outerMemberParent = parent[parent.length - 2];
+
+              if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object" && !memberParent.node.computed && memberParent.node.property.type === "Identifier" && (outerMemberParent === null || outerMemberParent === void 0 ? void 0 : outerMemberParent.node.type) === "MemberExpression" && outerMemberParent.key === "object" && !outerMemberParent.node.computed && outerMemberParent.node.property.type === "Identifier") {
+                collection.push("".concat(memberParent.node.property.name, ".").concat(outerMemberParent.node.property.name));
+              }
             }
           }
 
@@ -19952,12 +19977,18 @@ function collectPermissionActions(data, collection) {
   if (typeof data === "string") {
     if (data.includes(PERMISSIONS) && isEvaluable(data)) {
       preevaluate(data, {
-        visitors: {
-          CallExpression(node) {
-            if (node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === PERMISSIONS && !node.callee.computed && node.callee.property.type === "Identifier" && node.callee.property.name === check) {
-              for (var arg of node.arguments) {
-                if (arg.type === "Literal" && typeof arg.value === "string") {
-                  collection.add(arg.value);
+        withParent: true,
+        hooks: {
+          beforeVisitGlobal(node, parent) {
+            if (node.name === PERMISSIONS) {
+              var memberParent = parent[parent.length - 1];
+              var callParent = parent[parent.length - 2];
+
+              if ((callParent === null || callParent === void 0 ? void 0 : callParent.node.type) === "CallExpression" && (callParent === null || callParent === void 0 ? void 0 : callParent.key) === "callee" && (memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object" && !memberParent.node.computed && memberParent.node.property.type === "Identifier" && memberParent.node.property.name === check) {
+                for (var arg of callParent.node.arguments) {
+                  if (arg.type === "Literal" && typeof arg.value === "string") {
+                    collection.add(arg.value);
+                  }
                 }
               }
             }
@@ -20040,39 +20071,47 @@ function collectRouteAliasInRouteConfs(routes, collection) {
 
 var I18N = "I18N";
 function scanI18NInStoryboard(storyboard) {
-  // Notice: `menus` may contain evaluations of I18N too.
-  return scanI18NInAny([storyboard.routes, storyboard.meta && [storyboard.meta.customTemplates, storyboard.meta.menus]]);
+  var _storyboard$meta;
+
+  var collection = new Map();
+  var beforeVisitGlobal = beforeVisitGlobalFactory(collection); // Notice: `menus` may contain evaluations of I18N too.
+
+  var {
+    customTemplates,
+    menus,
+    functions
+  } = (_storyboard$meta = storyboard.meta) !== null && _storyboard$meta !== void 0 ? _storyboard$meta : {};
+  collectI18N([storyboard.routes, customTemplates, menus], beforeVisitGlobal);
+
+  if (Array.isArray(functions)) {
+    for (var fn of functions) {
+      precookFunction(fn.source, {
+        typescript: fn.typescript,
+        withParent: true,
+        hooks: {
+          beforeVisitGlobal
+        }
+      });
+    }
+  }
+
+  return collection;
 }
 function scanI18NInAny(data) {
   var collection = new Map();
-  collectI18N(data, collection);
+  collectI18N(data, beforeVisitGlobalFactory(collection));
   return collection;
 }
 
-function collectI18N(data, collection) {
+function collectI18N(data, beforeVisitGlobal) {
   var memo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakSet();
 
   if (typeof data === "string") {
     if (data.includes(I18N) && isEvaluable(data)) {
       preevaluate(data, {
-        visitors: {
-          CallExpression(node) {
-            var [keyNode, defaultNode] = node.arguments;
-
-            if (node.callee.type === "Identifier" && node.callee.name === I18N && keyNode && keyNode.type === "Literal" && typeof keyNode.value === "string") {
-              var valueSet = collection.get(keyNode.value);
-
-              if (!valueSet) {
-                valueSet = new Set();
-                collection.set(keyNode.value, valueSet);
-              }
-
-              if (defaultNode && defaultNode.type === "Literal" && typeof defaultNode.value === "string") {
-                valueSet.add(defaultNode.value);
-              }
-            }
-          }
-
+        withParent: true,
+        hooks: {
+          beforeVisitGlobal
         }
       });
     }
@@ -20086,16 +20125,41 @@ function collectI18N(data, collection) {
 
     if (Array.isArray(data)) {
       for (var item of data) {
-        collectI18N(item, collection, memo);
+        collectI18N(item, beforeVisitGlobal, memo);
       }
     } else {
       for (var _item of Object.values(data)) {
-        collectI18N(_item, collection, memo);
+        collectI18N(_item, beforeVisitGlobal, memo);
       }
     }
   }
 }
 
+function beforeVisitGlobalFactory(collection) {
+  return function beforeVisitGlobal(node, parent) {
+    if (node.name === I18N) {
+      var callParent = parent[parent.length - 1];
+
+      if ((callParent === null || callParent === void 0 ? void 0 : callParent.node.type) === "CallExpression" && callParent.key === "callee") {
+        var [keyNode, defaultNode] = callParent.node.arguments;
+
+        if (keyNode && keyNode.type === "Literal" && typeof keyNode.value === "string") {
+          var valueSet = collection.get(keyNode.value);
+
+          if (!valueSet) {
+            valueSet = new Set();
+            collection.set(keyNode.value, valueSet);
+          }
+
+          if (defaultNode && defaultNode.type === "Literal" && typeof defaultNode.value === "string") {
+            valueSet.add(defaultNode.value);
+          }
+        }
+      }
+    }
+  };
+}
+
 var LexicalStatus;
 
 (function (LexicalStatus) {
@@ -20766,23 +20830,35 @@ function getDependencyMapOfContext(contextConfs) {
 
   return depsMap;
 }
-var CTX = "CTX";
+var CTX$1 = "CTX";
 
 function collectContexts(data, stats) {
   var memo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new WeakSet();
 
   if (typeof data === "string") {
-    if (data.includes(CTX) && isEvaluable(data)) {
+    if (data.includes(CTX$1) && isEvaluable(data)) {
       preevaluate(data, {
-        visitors: {
-          MemberExpression(node) {
-            if (node.object.type === "Identifier" && node.object.name === CTX) {
-              if (!node.computed && node.property.type === "Identifier") {
-                if (!stats.dependencies.includes(node.property.name)) {
-                  stats.dependencies.push(node.property.name);
+        withParent: true,
+        hooks: {
+          beforeVisitGlobal(node, parent) {
+            if (node.name === CTX$1) {
+              var memberParent = parent[parent.length - 1];
+
+              if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
+                var memberNode = memberParent.node;
+                var dep;
+
+                if (!memberNode.computed && memberNode.property.type === "Identifier") {
+                  dep = memberNode.property.name;
+                } else if (memberNode.computed && memberNode.property.type === "Literal" && typeof memberNode.property.value === "string") {
+                  dep = memberNode.property.value;
+                } else {
+                  stats.includesComputed = true;
+                }
+
+                if (dep !== undefined && !stats.dependencies.includes(dep)) {
+                  stats.dependencies.push(dep);
                 }
-              } else {
-                stats.includesComputed = true;
               }
             }
           }
@@ -21080,6 +21156,7 @@ function deepFreeze(object) {
 }
 
 var TRACK_CONTEXT = "track context";
+var CTX = "CTX";
 /**
  * Get tracking CTX for an evaluable expression in `track context` mode.
  *
@@ -21113,13 +21190,20 @@ function trackContext(raw) {
     var {
       expression
     } = preevaluate(raw, {
-      visitors: {
-        MemberExpression(node) {
-          if (node.object.type === "Identifier" && node.object.name === "CTX") {
-            if (!node.computed && node.property.type === "Identifier") {
-              contexts.add(node.property.name);
-            } else if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
-              contexts.add(node.property.value);
+      withParent: true,
+      hooks: {
+        beforeVisitGlobal(node, parent) {
+          if (node.name === CTX) {
+            var memberParent = parent[parent.length - 1];
+
+            if ((memberParent === null || memberParent === void 0 ? void 0 : memberParent.node.type) === "MemberExpression" && memberParent.key === "object") {
+              var memberNode = memberParent.node;
+
+              if (!memberNode.computed && memberNode.property.type === "Identifier") {
+                contexts.add(memberNode.property.name);
+              } else if (memberNode.computed && memberNode.property.type === "Literal" && typeof memberNode.property.value === "string") {
+                contexts.add(memberNode.property.value);
+              }
             }
           }
         }
@@ -21141,5 +21225,5 @@ function trackContext(raw) {
   return false;
 }
 
-export { JsonStorage, PrecookFunctionVisitor, PrecookVisitor, asyncProcessBrick, asyncProcessStoryboard, computeRealRoutePath, convertValueByPrecision, cook, createProviderClass, deepFreeze, formatValue, getDependencyMapOfContext, getDepsOfTemplates, getDllAndDepsByResource, getDllAndDepsOfBricks, getDllAndDepsOfStoryboard, getTemplateDepsOfStoryboard, hasOwnProperty$1 as hasOwnProperty, inject, isBrickNode, isCustomTemplateNode, isEvaluable, isObject, isRouteNode, isSnippetNode, lint, loadScript, mapCustomApisToNameAndNamespace, matchPath, normalizeBuilderNode, normalizeMenu, precookFunction, preevaluate, prefetchScript, resolveContextConcurrently, restoreDynamicTemplates, scanBricksInBrickConf, scanBricksInStoryboard, scanCustomApisInStoryboard, scanI18NInAny, scanI18NInStoryboard, scanPermissionActionsInAny, scanPermissionActionsInStoryboard, scanProcessorsInAny, scanProcessorsInStoryboard, scanRouteAliasInStoryboard, scanStoryboard, scanTemplatesInBrick, scanTemplatesInStoryboard, shouldAllowRecursiveEvaluations, smartDisplayForEvaluableString, toPath, trackContext, transform, transformAndInject };
+export { JsonStorage, PrecookFunctionVisitor, PrecookVisitor, asyncProcessBrick, asyncProcessStoryboard, computeRealRoutePath, convertValueByPrecision, cook, createProviderClass, deepFreeze, formatValue, getDependencyMapOfContext, getDepsOfTemplates, getDllAndDepsByResource, getDllAndDepsOfBricks, getDllAndDepsOfStoryboard, getTemplateDepsOfStoryboard, hasOwnProperty$1 as hasOwnProperty, inject, isBrickNode, isCustomTemplateNode, isEvaluable, isObject, isRouteNode, isSnippetNode, lint, loadScript, mapCustomApisToNameAndNamespace, matchPath, normalizeBuilderNode, normalizeMenu, parseForAnalysis, precook, precookFunction, preevaluate, prefetchScript, resolveContextConcurrently, restoreDynamicTemplates, scanBricksInBrickConf, scanBricksInStoryboard, scanCustomApisInStoryboard, scanI18NInAny, scanI18NInStoryboard, scanPermissionActionsInAny, scanPermissionActionsInStoryboard, scanProcessorsInAny, scanProcessorsInStoryboard, scanRouteAliasInStoryboard, scanStoryboard, scanTemplatesInBrick, scanTemplatesInStoryboard, shouldAllowRecursiveEvaluations, smartDisplayForEvaluableString, toPath, tokTypes_1 as tokTypes, trackContext, transform, transformAndInject };
 //# sourceMappingURL=index.esm.js.map