@next-core/brick-utils 2.30.1 → 2.31.1

package/dist/index.bundle.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@next-core/pipes'), require('@babel/runtime/helpers/objectWithoutProperties'), require('js-yaml')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@next-core/pipes', '@babel/runtime/helpers/objectWithoutProperties', 'js-yaml'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global.pipes, global._objectWithoutProperties, global.yaml));
-})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, pipes, _objectWithoutProperties, yaml) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/asyncToGenerator'), require('lodash'), require('@babel/runtime/helpers/defineProperty'), require('@babel/runtime/helpers/objectSpread2'), require('@babel/runtime/helpers/objectWithoutProperties'), require('@next-core/pipes'), require('js-yaml')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/asyncToGenerator', 'lodash', '@babel/runtime/helpers/defineProperty', '@babel/runtime/helpers/objectSpread2', '@babel/runtime/helpers/objectWithoutProperties', '@next-core/pipes', 'js-yaml'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BrickUtils = {}, global._asyncToGenerator, global.lodash, global._defineProperty, global._objectSpread, global._objectWithoutProperties, global.pipes, global.yaml));
+})(this, (function (exports, _asyncToGenerator, lodash, _defineProperty, _objectSpread, _objectWithoutProperties, pipes, yaml) { 'use strict';
 
   function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -18391,7 +18391,72 @@
 
   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);
@@ -18437,6 +18502,7 @@
     var {
       expressionOnly,
       visitors,
+      withParent,
       hooks = {}
     } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var attemptToVisitGlobals = new Set();
@@ -18457,102 +18523,107 @@
       }
     }
 
-    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__default["default"](_objectSpread__default["default"]({}, 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":
@@ -18563,8 +18634,7 @@
           // Statements and assignments:
           switch (node.type) {
             case "AssignmentExpression":
-              Evaluate(node.right);
-              Evaluate(node.left);
+              EvaluateChildren(node, ["right", "left"], parent);
               return;
 
             case "BlockStatement":
@@ -18578,7 +18648,7 @@
                 var blockEnv = new AnalysisEnvironment(oldEnv);
                 BlockDeclarationInstantiation(node.body, blockEnv);
                 runningContext.LexicalEnvironment = blockEnv;
-                Evaluate(node.body);
+                EvaluateChildren(node, ["body"], parent);
                 runningContext.LexicalEnvironment = oldEnv;
                 return;
               }
@@ -18596,20 +18666,18 @@
                 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":
@@ -18628,7 +18696,7 @@
                   _runningContext2.LexicalEnvironment = newEnv;
                 }
 
-                Evaluate(node.right);
+                EvaluateChildren(node, ["right"], parent);
                 _runningContext2.LexicalEnvironment = _oldEnv2; // ForIn/OfBodyEvaluation
 
                 if (lexicalBinding) {
@@ -18637,8 +18705,7 @@
                   _runningContext2.LexicalEnvironment = iterationEnv;
                 }
 
-                Evaluate(node.left);
-                Evaluate(node.body);
+                EvaluateChildren(node, ["left", "body"], parent);
                 _runningContext2.LexicalEnvironment = _oldEnv2;
                 return;
               }
@@ -18659,10 +18726,7 @@
                   _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;
               }
@@ -18675,7 +18739,7 @@
 
                 _env.CreateBinding(fn);
 
-                CallFunction(fo);
+                CallFunction(fo, parent);
                 return;
               }
 
@@ -18683,30 +18747,27 @@
               {
                 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();
 
@@ -18716,36 +18777,32 @@
 
                 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, "`"));
         }
@@ -18775,10 +18832,16 @@
       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();
     }
 
@@ -18790,7 +18853,7 @@
       analysisContextStack.push(calleeContext);
     }
 
-    function FunctionDeclarationInstantiation(func) {
+    function FunctionDeclarationInstantiation(func, parent) {
       var calleeContext = getRunningContext();
       var code = func.ECMAScriptCode;
       var formals = func.FormalParameters;
@@ -18802,7 +18865,10 @@
       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) {
@@ -18847,19 +18913,16 @@
       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;
   }
 
@@ -18871,17 +18934,11 @@
       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;
     }
@@ -18937,93 +18994,100 @@
         }
       });
     } 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;
           }
 
         }
@@ -19033,49 +19097,6 @@
     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] : {},
@@ -19161,12 +19182,16 @@
     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));
+                }
               }
             }
 
@@ -19957,12 +19982,18 @@
     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);
+                    }
                   }
                 }
               }
@@ -20045,39 +20076,47 @@
 
   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
           }
         });
       }
@@ -20091,16 +20130,41 @@
 
       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) {
@@ -20771,23 +20835,35 @@
 
     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;
                 }
               }
             }
@@ -21085,6 +21161,7 @@
   }
 
   var TRACK_CONTEXT = "track context";
+  var CTX = "CTX";
   /**
    * Get tracking CTX for an evaluable expression in `track context` mode.
    *
@@ -21118,13 +21195,20 @@
       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);
+                }
               }
             }
           }
@@ -21181,6 +21265,8 @@
   exports.matchPath = matchPath;
   exports.normalizeBuilderNode = normalizeBuilderNode;
   exports.normalizeMenu = normalizeMenu;
+  exports.parseForAnalysis = parseForAnalysis;
+  exports.precook = precook;
   exports.precookFunction = precookFunction;
   exports.preevaluate = preevaluate;
   exports.prefetchScript = prefetchScript;
@@ -21202,6 +21288,7 @@
   exports.shouldAllowRecursiveEvaluations = shouldAllowRecursiveEvaluations;
   exports.smartDisplayForEvaluableString = smartDisplayForEvaluableString;
   exports.toPath = toPath;
+  exports.tokTypes = tokTypes_1;
   exports.trackContext = trackContext;
   exports.transform = transform;
   exports.transformAndInject = transformAndInject;