/**
 * 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
});
