@nocobase/plugin-flow-engine 2.1.0-beta.9 → 2.2.0-alpha.1

package/dist/server/flow-surfaces/runjs-authoring/ast/bindings.js

@@ -0,0 +1,661 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bindings_exports = {};
+__export(bindings_exports, {
+  addParameterBindings: () => addParameterBindings,
+  addSourceBinding: () => addSourceBinding,
+  collectArrayBindingPatternNames: () => collectArrayBindingPatternNames,
+  collectArrowParameterBindingNames: () => collectArrowParameterBindingNames,
+  collectBindingPatternNames: () => collectBindingPatternNames,
+  collectDestructuredVariableBindingNames: () => collectDestructuredVariableBindingNames,
+  collectMethodParameterBindingNames: () => collectMethodParameterBindingNames,
+  collectObjectBindingPatternNames: () => collectObjectBindingPatternNames,
+  collectParameterBindingNames: () => collectParameterBindingNames,
+  collectSourceBindings: () => collectSourceBindings,
+  collectStringLiteralBindings: () => collectStringLiteralBindings,
+  dedupeIndexedEntries: () => dedupeIndexedEntries,
+  extractBindingPatternNames: () => extractBindingPatternNames,
+  findArrowBodyRange: () => findArrowBodyRange,
+  findAstAncestor: () => findAstAncestor,
+  findBraceBodyAfter: () => findBraceBodyAfter,
+  findFollowingBraceRange: () => findFollowingBraceRange,
+  findFollowingStatementRange: () => findFollowingStatementRange,
+  findForHeaderRangeContaining: () => findForHeaderRangeContaining,
+  findForScopeForDeclaration: () => findForScopeForDeclaration,
+  findInnermostRange: () => findInnermostRange,
+  findNamedFunctionOrClassExpressionRange: () => findNamedFunctionOrClassExpressionRange,
+  findSingleStatementEnd: () => findSingleStatementEnd,
+  findSourceBindingByDeclaration: () => findSourceBindingByDeclaration,
+  getAstBindingScopeRange: () => getAstBindingScopeRange,
+  getAstExecutionScopeRange: () => getAstExecutionScopeRange,
+  isAstAlwaysExecutedInCurrentExecutionScope: () => isAstAlwaysExecutedInCurrentExecutionScope,
+  isAstDefinitelyEnumerableComputedObjectKey: () => isAstDefinitelyEnumerableComputedObjectKey,
+  isAstDefinitelyEnumerableObjectProperty: () => isAstDefinitelyEnumerableObjectProperty,
+  isAstDefinitelyNonEmptyArrayElement: () => isAstDefinitelyNonEmptyArrayElement,
+  isAstDefinitelyNonEmptyForInSource: () => isAstDefinitelyNonEmptyForInSource,
+  isAstDefinitelyNonEmptyForOfSource: () => isAstDefinitelyNonEmptyForOfSource,
+  isAstFunctionLike: () => isAstFunctionLike,
+  isExpressionPrefixToken: () => isExpressionPrefixToken,
+  isNameBoundAtIndex: () => isNameBoundAtIndex,
+  isNamedFunctionOrClassExpression: () => isNamedFunctionOrClassExpression,
+  isSameAstRange: () => isSameAstRange,
+  isSourceAliasShadowedAtIndex: () => isSourceAliasShadowedAtIndex,
+  resolveBindingScope: () => resolveBindingScope,
+  unwrapAstChainExpression: () => unwrapAstChainExpression
+});
+module.exports = __toCommonJS(bindings_exports);
+var import_source = require("./source");
+function collectSourceBindings(masked, functionRanges, blockRanges, staticBlockRanges) {
+  const bindings = [];
+  for (const match of masked.matchAll(/\b(const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g)) {
+    const kind = match[1];
+    const matchIndex = match.index || 0;
+    if ((kind === "function" || kind === "class") && isNamedFunctionOrClassExpression(masked, matchIndex, kind)) {
+      const expressionRange = findNamedFunctionOrClassExpressionRange(masked, matchIndex, kind);
+      if (expressionRange) {
+        bindings.push({
+          name: match[2],
+          declarationStart: matchIndex,
+          start: expressionRange.start,
+          end: expressionRange.end
+        });
+      }
+      continue;
+    }
+    addSourceBinding(
+      bindings,
+      functionRanges,
+      blockRanges,
+      staticBlockRanges,
+      masked,
+      match[2],
+      matchIndex,
+      masked.length,
+      kind
+    );
+  }
+  collectDestructuredVariableBindingNames(masked, functionRanges, blockRanges, staticBlockRanges, bindings);
+  collectParameterBindingNames(masked, bindings);
+  return bindings;
+}
+function collectStringLiteralBindings(source, masked, bindings) {
+  const entries = [];
+  const commentMasked = (0, import_source.maskJavaScriptComments)(source);
+  for (const match of commentMasked.matchAll(/\bconst\s+([A-Za-z_$][\w$]*)\s*=\s*(['"`])/g)) {
+    const declarationIndex = match.index || 0;
+    const literalStart = declarationIndex + match[0].lastIndexOf(match[2]);
+    const statementEnd = findSingleStatementEnd(masked, declarationIndex);
+    const literal = (0, import_source.readCompleteStringLiteral)(source.slice(literalStart, statementEnd));
+    if (!literal) {
+      continue;
+    }
+    const binding = findSourceBindingByDeclaration(bindings, match[1], declarationIndex);
+    entries.push({
+      name: match[1],
+      value: literal.value,
+      declarationStart: declarationIndex,
+      start: declarationIndex,
+      end: (binding == null ? void 0 : binding.end) ?? masked.length
+    });
+  }
+  return entries;
+}
+function isNamedFunctionOrClassExpression(masked, keywordIndex, kind) {
+  let previous = (0, import_source.getPreviousSignificantTokenInfo)(masked, keywordIndex);
+  if (kind === "function" && (previous == null ? void 0 : previous.token) === "async") {
+    previous = (0, import_source.getPreviousSignificantTokenInfo)(masked, previous.start);
+  }
+  if (!previous) {
+    return false;
+  }
+  return isExpressionPrefixToken(previous.token);
+}
+function isExpressionPrefixToken(token) {
+  return [
+    "=",
+    "(",
+    "[",
+    ",",
+    ":",
+    "?",
+    "return",
+    "throw",
+    "yield",
+    "await",
+    "case",
+    "new",
+    "delete",
+    "void",
+    "typeof"
+  ].includes(token) || /^[!~+\-*%&|^<>]$/.test(token);
+}
+function findNamedFunctionOrClassExpressionRange(masked, keywordIndex, kind) {
+  if (kind === "function") {
+    const openParen = masked.indexOf("(", keywordIndex);
+    const closeParen = (0, import_source.findMatchingDelimiter)(masked, openParen);
+    const bodyRange = closeParen > openParen ? findBraceBodyAfter(masked, closeParen) : void 0;
+    return bodyRange ? { start: keywordIndex, end: bodyRange.end } : void 0;
+  }
+  const openBrace = masked.indexOf("{", keywordIndex);
+  const closeBrace = (0, import_source.findMatchingDelimiter)(masked, openBrace);
+  return closeBrace > openBrace ? { start: openBrace, end: closeBrace + 1 } : void 0;
+}
+function addSourceBinding(bindings, functionRanges, blockRanges, staticBlockRanges, masked, name, start, sourceEnd, kind) {
+  const scope = resolveBindingScope(masked, sourceEnd, start, kind, functionRanges, blockRanges, staticBlockRanges);
+  bindings.push({
+    name,
+    declarationStart: start,
+    start: scope.start,
+    end: scope.end
+  });
+}
+function resolveBindingScope(masked, sourceEnd, start, kind, functionRanges, blockRanges, staticBlockRanges) {
+  const forScope = ["const", "let", "class"].includes(kind) ? findForScopeForDeclaration(masked, start, blockRanges) : void 0;
+  if (forScope) {
+    return forScope;
+  }
+  if (["const", "let", "class"].includes(kind)) {
+    return findInnermostRange(start, blockRanges) || { start: 0, end: sourceEnd };
+  }
+  const functionScope = findInnermostRange(start, functionRanges);
+  if (functionScope) {
+    return functionScope;
+  }
+  const staticBlockScope = findInnermostRange(start, staticBlockRanges);
+  if (staticBlockScope) {
+    return staticBlockScope;
+  }
+  return { start: 0, end: sourceEnd };
+}
+function findForScopeForDeclaration(masked, start, blockRanges) {
+  const forHeader = findForHeaderRangeContaining(masked, start);
+  if (!forHeader) {
+    return void 0;
+  }
+  const bodyRange = findFollowingStatementRange(masked, forHeader.end, blockRanges);
+  return bodyRange ? { start: forHeader.start, end: bodyRange.end } : void 0;
+}
+function findForHeaderRangeContaining(masked, start) {
+  for (const match of masked.matchAll(/\bfor\s*(?:await\s*)?\(/g)) {
+    const openParen = masked.indexOf("(", match.index || 0);
+    const closeParen = (0, import_source.findMatchingDelimiter)(masked, openParen);
+    if (start > openParen && start < closeParen) {
+      return { start: openParen + 1, end: closeParen };
+    }
+  }
+  return void 0;
+}
+function findFollowingBraceRange(masked, afterIndex, blockRanges) {
+  let cursor = afterIndex + 1;
+  while (cursor < masked.length && /\s/.test(masked[cursor])) {
+    cursor += 1;
+  }
+  return masked[cursor] === "{" ? blockRanges.find((range) => range.start === cursor) : void 0;
+}
+function findFollowingStatementRange(masked, afterIndex, blockRanges) {
+  const braceRange = findFollowingBraceRange(masked, afterIndex, blockRanges);
+  if (braceRange) {
+    return braceRange;
+  }
+  let start = afterIndex + 1;
+  while (start < masked.length && /\s/.test(masked[start])) {
+    start += 1;
+  }
+  if (start >= masked.length) {
+    return void 0;
+  }
+  const end = findSingleStatementEnd(masked, start);
+  return end > start ? { start, end } : void 0;
+}
+function findSingleStatementEnd(masked, start) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  for (let index = start; index < masked.length; index += 1) {
+    const char = masked[index];
+    if (char === "(") {
+      parenDepth += 1;
+    } else if (char === ")" && parenDepth > 0) {
+      parenDepth -= 1;
+    } else if (char === "[") {
+      bracketDepth += 1;
+    } else if (char === "]" && bracketDepth > 0) {
+      bracketDepth -= 1;
+    } else if (char === "{") {
+      braceDepth += 1;
+    } else if (char === "}" && braceDepth > 0) {
+      braceDepth -= 1;
+    }
+    if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      if (char === ";") {
+        return index + 1;
+      }
+      if (char === "\n" || char === "\r") {
+        return index;
+      }
+    }
+  }
+  return masked.length;
+}
+function collectDestructuredVariableBindingNames(masked, functionRanges, blockRanges, staticBlockRanges, bindings) {
+  for (const match of masked.matchAll(/\b(const|let|var)\s*(\{|\[)/g)) {
+    const start = (match.index || 0) + match[0].length - 1;
+    const end = (0, import_source.findMatchingDelimiter)(masked, start);
+    if (end > start) {
+      extractBindingPatternNames(masked.slice(start, end + 1)).forEach((name) => {
+        addSourceBinding(
+          bindings,
+          functionRanges,
+          blockRanges,
+          staticBlockRanges,
+          masked,
+          name,
+          match.index || 0,
+          masked.length,
+          match[1]
+        );
+      });
+    }
+  }
+}
+function collectParameterBindingNames(masked, bindings) {
+  for (const match of masked.matchAll(/\bfunction\b[^(]*\(/g)) {
+    const openParen = masked.indexOf("(", match.index || 0);
+    const closeParen = (0, import_source.findMatchingDelimiter)(masked, openParen);
+    const bodyRange = findBraceBodyAfter(masked, closeParen);
+    if (closeParen > openParen && bodyRange) {
+      addParameterBindings(bindings, masked.slice(openParen + 1, closeParen), {
+        start: openParen + 1,
+        end: bodyRange.end
+      });
+    }
+  }
+  for (const match of masked.matchAll(/\bcatch\s*\(/g)) {
+    const openParen = masked.indexOf("(", match.index || 0);
+    const closeParen = (0, import_source.findMatchingDelimiter)(masked, openParen);
+    const bodyRange = findBraceBodyAfter(masked, closeParen);
+    if (closeParen > openParen && bodyRange) {
+      addParameterBindings(bindings, masked.slice(openParen + 1, closeParen), {
+        start: openParen + 1,
+        end: bodyRange.end
+      });
+    }
+  }
+  collectArrowParameterBindingNames(masked, bindings);
+  collectMethodParameterBindingNames(masked, bindings);
+}
+function collectArrowParameterBindingNames(masked, bindings) {
+  for (const match of masked.matchAll(/\(/g)) {
+    const openParen = match.index || 0;
+    const closeParen = (0, import_source.findMatchingDelimiter)(masked, openParen);
+    if (closeParen <= openParen) {
+      continue;
+    }
+    let cursor = closeParen + 1;
+    while (cursor < masked.length && /\s/.test(masked[cursor])) {
+      cursor += 1;
+    }
+    if (masked.slice(cursor, cursor + 2) !== "=>") {
+      continue;
+    }
+    const bodyRange = findArrowBodyRange(masked, cursor + 2);
+    if (bodyRange) {
+      addParameterBindings(bindings, masked.slice(openParen + 1, closeParen), {
+        start: openParen + 1,
+        end: bodyRange.end
+      });
+    }
+  }
+  for (const match of masked.matchAll(/\b([A-Za-z_$][\w$]*)\s*=>/g)) {
+    const arrowIndex = (match.index || 0) + match[0].lastIndexOf("=>");
+    const bodyRange = findArrowBodyRange(masked, arrowIndex + 2);
+    if (bodyRange) {
+      bindings.push({
+        name: match[1],
+        declarationStart: match.index || 0,
+        start: match.index || 0,
+        end: bodyRange.end
+      });
+    }
+  }
+}
+function collectMethodParameterBindingNames(masked, bindings) {
+  (0, import_source.collectMethodCandidates)(masked).forEach((candidate) => {
+    addParameterBindings(bindings, masked.slice(candidate.paramsStart, candidate.paramsEnd), {
+      start: candidate.paramsStart,
+      end: candidate.bodyRange.end
+    });
+  });
+}
+function findBraceBodyAfter(masked, afterIndex) {
+  let cursor = afterIndex + 1;
+  while (cursor < masked.length && /\s/.test(masked[cursor])) {
+    cursor += 1;
+  }
+  if (masked[cursor] !== "{") {
+    return void 0;
+  }
+  const closeBrace = (0, import_source.findMatchingDelimiter)(masked, cursor);
+  return closeBrace > cursor ? { start: cursor, end: closeBrace + 1 } : void 0;
+}
+function findArrowBodyRange(masked, afterArrowIndex) {
+  let start = afterArrowIndex;
+  while (start < masked.length && /\s/.test(masked[start])) {
+    start += 1;
+  }
+  if (masked[start] === "{") {
+    const closeBrace = (0, import_source.findMatchingDelimiter)(masked, start);
+    return closeBrace > start ? { start, end: closeBrace + 1 } : void 0;
+  }
+  const end = (0, import_source.findArrowExpressionEnd)(masked, start);
+  return end > start ? { start, end } : void 0;
+}
+function addParameterBindings(bindings, params, range) {
+  (0, import_source.splitTopLevel)(params, ",").forEach((param) => {
+    extractBindingPatternNames(param).forEach((name) => {
+      bindings.push({ name, declarationStart: range.start, ...range });
+    });
+  });
+}
+function extractBindingPatternNames(pattern) {
+  const names = /* @__PURE__ */ new Set();
+  collectBindingPatternNames(pattern, names);
+  return [...names];
+}
+function collectBindingPatternNames(pattern, names) {
+  const trimmed = (0, import_source.trimBindingElement)(pattern);
+  if (!trimmed) {
+    return;
+  }
+  if (trimmed.startsWith("{")) {
+    collectObjectBindingPatternNames(trimmed, names);
+    return;
+  }
+  if (trimmed.startsWith("[")) {
+    collectArrayBindingPatternNames(trimmed, names);
+    return;
+  }
+  const match = trimmed.match(/^([A-Za-z_$][\w$]*)\b/);
+  if (match) {
+    names.add(match[1]);
+  }
+}
+function collectObjectBindingPatternNames(pattern, names) {
+  const body = (0, import_source.stripEnclosure)(pattern, "{", "}");
+  (0, import_source.splitTopLevel)(body, ",").forEach((element) => {
+    const trimmed = element.trim();
+    if (!trimmed) {
+      return;
+    }
+    if (trimmed.startsWith("...")) {
+      collectBindingPatternNames(trimmed.slice(3), names);
+      return;
+    }
+    const colon = (0, import_source.findTopLevelChar)(trimmed, ":");
+    collectBindingPatternNames(colon >= 0 ? trimmed.slice(colon + 1) : trimmed, names);
+  });
+}
+function collectArrayBindingPatternNames(pattern, names) {
+  (0, import_source.splitTopLevel)((0, import_source.stripEnclosure)(pattern, "[", "]"), ",").forEach(
+    (element) => collectBindingPatternNames(element, names)
+  );
+}
+function findInnermostRange(index, ranges) {
+  return ranges.filter((range) => index >= range.start && index < range.end).sort((left, right) => left.end - left.start - (right.end - right.start))[0];
+}
+function isNameBoundAtIndex(bindings, name, index) {
+  return bindings.some((binding) => binding.name === name && index >= binding.start && index < binding.end);
+}
+function findSourceBindingByDeclaration(bindings, name, declarationStart) {
+  return bindings.find((entry) => entry.name === name && (entry.declarationStart ?? entry.start) === declarationStart);
+}
+function isSameAstRange(left, right) {
+  return left.start === right.start && left.end === right.end;
+}
+function isSourceAliasShadowedAtIndex(alias, bindings, index) {
+  const aliasDeclarationStart = alias.declarationStart ?? alias.start;
+  return bindings.some(
+    (binding) => binding.name === alias.name && index >= binding.start && index < binding.end && (binding.declarationStart ?? binding.start) !== aliasDeclarationStart
+  );
+}
+function isAstDefinitelyNonEmptyForInSource(node) {
+  const unwrapped = unwrapAstChainExpression(node);
+  if (!unwrapped) {
+    return false;
+  }
+  if (unwrapped.type === "ObjectExpression") {
+    return (unwrapped.properties || []).some(isAstDefinitelyEnumerableObjectProperty);
+  }
+  return false;
+}
+function isAstDefinitelyNonEmptyForOfSource(node) {
+  const unwrapped = unwrapAstChainExpression(node);
+  if (!unwrapped) {
+    return false;
+  }
+  if (unwrapped.type === "ArrayExpression") {
+    return (unwrapped.elements || []).some(isAstDefinitelyNonEmptyArrayElement);
+  }
+  return false;
+}
+function isAstDefinitelyNonEmptyArrayElement(element) {
+  if (!element) {
+    return true;
+  }
+  if (element.type === "SpreadElement") {
+    return isAstDefinitelyNonEmptyForOfSource(element.argument);
+  }
+  return true;
+}
+function isAstDefinitelyEnumerableObjectProperty(property) {
+  if (!property || property.type === "SpreadElement" || property.type !== "Property") {
+    return false;
+  }
+  if (property.computed) {
+    return isAstDefinitelyEnumerableComputedObjectKey(property.key);
+  }
+  const key = property.key;
+  const isProtoSetter = !property.method && !property.shorthand && (property.kind || "init") === "init" && ((key == null ? void 0 : key.type) === "Identifier" && key.name === "__proto__" || (key == null ? void 0 : key.type) === "Literal" && key.value === "__proto__");
+  if (isProtoSetter) {
+    return false;
+  }
+  if ((key == null ? void 0 : key.type) === "Identifier") {
+    return true;
+  }
+  if ((key == null ? void 0 : key.type) === "Literal") {
+    return true;
+  }
+  return true;
+}
+function isAstDefinitelyEnumerableComputedObjectKey(key) {
+  const unwrapped = unwrapAstChainExpression(key);
+  if (!unwrapped) {
+    return false;
+  }
+  if (unwrapped.type === "Literal") {
+    return typeof unwrapped.value === "string" || typeof unwrapped.value === "number" || typeof unwrapped.value === "boolean" || typeof unwrapped.value === "bigint" || unwrapped.value === null;
+  }
+  if (unwrapped.type === "TemplateLiteral") {
+    return (unwrapped.expressions || []).length === 0;
+  }
+  return false;
+}
+function findAstAncestor(ancestors, type) {
+  var _a;
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    if (((_a = ancestors[index]) == null ? void 0 : _a.type) === type) {
+      return ancestors[index];
+    }
+  }
+  return void 0;
+}
+function getAstExecutionScopeRange(ancestors, sourceLength) {
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const node = ancestors[index];
+    if (!node) {
+      continue;
+    }
+    if (node.type === "Program" || node.type === "StaticBlock" || isAstFunctionLike(node)) {
+      return {
+        start: typeof node.start === "number" ? node.start : 0,
+        end: typeof node.end === "number" ? node.end : sourceLength
+      };
+    }
+  }
+  return { start: 0, end: sourceLength };
+}
+function isAstAlwaysExecutedInCurrentExecutionScope(ancestors) {
+  const conditionalAncestorTypes = /* @__PURE__ */ new Set([
+    "ConditionalExpression",
+    "DoWhileStatement",
+    "ForStatement",
+    "IfStatement",
+    "LogicalExpression",
+    "SwitchCase",
+    "SwitchStatement",
+    "WhileStatement",
+    "WithStatement"
+  ]);
+  const currentNodeIndex = ancestors.length - 1;
+  for (let index = currentNodeIndex - 1; index >= 0; index -= 1) {
+    const node = ancestors[index];
+    if (!node) {
+      continue;
+    }
+    if (node.type === "Program" || node.type === "StaticBlock" || isAstFunctionLike(node)) {
+      return true;
+    }
+    if (node.type === "ForInStatement" && !isAstDefinitelyNonEmptyForInSource(node.right)) {
+      return false;
+    }
+    if (node.type === "ForOfStatement" && !isAstDefinitelyNonEmptyForOfSource(node.right)) {
+      return false;
+    }
+    if (node.type === "CatchClause") {
+      return false;
+    }
+    if (node.type === "TryStatement") {
+      const child = ancestors[index + 1];
+      if (child !== node.block && child !== node.finalizer) {
+        return false;
+      }
+      continue;
+    }
+    if (conditionalAncestorTypes.has(node.type)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getAstBindingScopeRange(ancestors, sourceLength, functionScoped = false) {
+  for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+    const node = ancestors[index];
+    if (!node || node.type === "VariableDeclarator" || node.type === "VariableDeclaration") {
+      continue;
+    }
+    if (functionScoped) {
+      if (node.type === "Program" || node.type === "StaticBlock" || isAstFunctionLike(node)) {
+        return {
+          start: typeof node.start === "number" ? node.start : 0,
+          end: typeof node.end === "number" ? node.end : sourceLength
+        };
+      }
+      continue;
+    }
+    if (node.type === "Program" || node.type === "BlockStatement" || node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "SwitchStatement" || node.type === "StaticBlock" || isAstFunctionLike(node)) {
+      return {
+        start: typeof node.start === "number" ? node.start : 0,
+        end: typeof node.end === "number" ? node.end : sourceLength
+      };
+    }
+  }
+  return { start: 0, end: sourceLength };
+}
+function isAstFunctionLike(node) {
+  return !!node && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
+}
+function dedupeIndexedEntries(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    const key = `${entry.index}:${entry.match || ""}:${entry.capability || ""}:${entry.component || ""}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+function unwrapAstChainExpression(node) {
+  let current = node;
+  while ((current == null ? void 0 : current.type) === "ChainExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addParameterBindings,
+  addSourceBinding,
+  collectArrayBindingPatternNames,
+  collectArrowParameterBindingNames,
+  collectBindingPatternNames,
+  collectDestructuredVariableBindingNames,
+  collectMethodParameterBindingNames,
+  collectObjectBindingPatternNames,
+  collectParameterBindingNames,
+  collectSourceBindings,
+  collectStringLiteralBindings,
+  dedupeIndexedEntries,
+  extractBindingPatternNames,
+  findArrowBodyRange,
+  findAstAncestor,
+  findBraceBodyAfter,
+  findFollowingBraceRange,
+  findFollowingStatementRange,
+  findForHeaderRangeContaining,
+  findForScopeForDeclaration,
+  findInnermostRange,
+  findNamedFunctionOrClassExpressionRange,
+  findSingleStatementEnd,
+  findSourceBindingByDeclaration,
+  getAstBindingScopeRange,
+  getAstExecutionScopeRange,
+  isAstAlwaysExecutedInCurrentExecutionScope,
+  isAstDefinitelyEnumerableComputedObjectKey,
+  isAstDefinitelyEnumerableObjectProperty,
+  isAstDefinitelyNonEmptyArrayElement,
+  isAstDefinitelyNonEmptyForInSource,
+  isAstDefinitelyNonEmptyForOfSource,
+  isAstFunctionLike,
+  isExpressionPrefixToken,
+  isNameBoundAtIndex,
+  isNamedFunctionOrClassExpression,
+  isSameAstRange,
+  isSourceAliasShadowedAtIndex,
+  resolveBindingScope,
+  unwrapAstChainExpression
+});

package/dist/server/flow-surfaces/runjs-authoring/ast/execution.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { AstCapabilityAlias, AstIdentifierBinding, AstIdentifierWrite, SourceRange } from '../internal-types';
+export declare function collectAstIdentifierWritesFromAst(ast: any, source: string): AstIdentifierWrite[];
+export declare function getAstWriteExecutionContext(ancestors: any[], sourceLength: number): {
+    alwaysRunsInExecutionScope: boolean;
+    executionScope: SourceRange;
+};
+export declare function findAstInnermostSynchronousIifeFunctionAncestorIndex(ancestors: any[]): number;
+export declare function getAstLoopPatternTarget(left: any): any;
+export declare function isAstForOfLoopVariableDeclaratorWithSourceTargets<T extends AstCapabilityAlias>(node: any, ancestors: any[], aliases: T[], identifierBindings: AstIdentifierBinding[]): boolean;
+export declare function hasAstForOfSourceTargets<T extends AstCapabilityAlias>(sourceNode: any, aliases: T[], identifierBindings: AstIdentifierBinding[]): boolean;
+export declare function collectAstForOfSourceTargets<T extends AstCapabilityAlias>(sourceNode: any, aliases: T[], identifierBindings: AstIdentifierBinding[], visit: (sourceTarget: any) => void): void;
+export declare function collectAstForOfSourceTargetElementMembers<T extends AstCapabilityAlias>(sourceTarget: any, aliases: T[], identifierBindings: AstIdentifierBinding[]): Set<string>;