@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/dist/js-ts-semantic-scope-use-def-bindings.js

@@ -0,0 +1,287 @@
+import {
+  findMatchingParen,
+  identifierRegExp,
+  namespacesForDeclarationKind,
+  nextSignificantCharIndex,
+  typeNamespace,
+  uniqueBindings,
+  valueNamespace
+} from './js-ts-semantic-scope-use-def-utils.js';
+import {
+  findStatementBoundary,
+  hasTypeAliasAssignment,
+  nextIdentifierToken
+} from './js-ts-semantic-scope-use-def-scan.js';
+
+const bindingKeywordKinds = Object.freeze({
+  function: 'function',
+  class: 'class',
+  interface: 'interface',
+  type: 'type',
+  enum: 'enum',
+  namespace: 'namespace',
+  module: 'module'
+});
+
+function collectBindings(code, tokens, depthAt) {
+  const bindings = [];
+  collectImportBindings(code, bindings, depthAt);
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (bindingKeywordKinds[token.value]) {
+      collectDeclarationBinding(code, tokens, index, bindings, depthAt);
+      if (token.value === 'function') collectFunctionParameters(code, token, bindings, depthAt);
+    } else if (token.value === 'const' || token.value === 'let' || token.value === 'var') {
+      collectVariableBindings(code, token, bindings, depthAt);
+    } else if (token.value === 'catch') {
+      collectCatchBinding(code, token, bindings, depthAt);
+    }
+  }
+  collectArrowFunctionBindings(code, bindings, depthAt);
+  return uniqueBindings(bindings);
+}
+
+function collectDeclarationBinding(code, tokens, index, bindings, depthAt) {
+  const keyword = tokens[index];
+  const kind = bindingKeywordKinds[keyword.value];
+  const name = nextIdentifierToken(tokens, index + 1);
+  if (!name || !identifierRegExp.test(name.value)) return;
+  if (kind === 'type' && !hasTypeAliasAssignment(code, name.end)) return;
+  bindings.push({
+    kind,
+    name: name.value,
+    start: name.start,
+    end: name.end,
+    depth: depthAt[name.start] ?? 0,
+    namespaces: namespacesForDeclarationKind(kind)
+  });
+}
+
+function collectFunctionParameters(code, functionToken, bindings, depthAt) {
+  const open = code.indexOf('(', functionToken.end);
+  if (open === -1) return;
+  const close = findMatchingParen(code, open);
+  if (close === -1) return;
+  const bodyStart = nextSignificantCharIndex(code, close + 1);
+  if (bodyStart === -1 || code[bodyStart] !== '{') return;
+  collectParameterListBindings(code.slice(open + 1, close), open + 1, bindings, depthAt, 'param');
+}
+
+function collectVariableBindings(code, token, bindings, depthAt) {
+  const end = findStatementBoundary(code, token.end);
+  const text = code.slice(token.end, end);
+  const bindingDepth = depthAt[token.start] ?? 0;
+  for (const declarator of splitTopLevelComma(text, token.end)) {
+    collectVariableDeclaratorBinding(declarator.text, declarator.offset, token.value, bindings, depthAt, bindingDepth);
+  }
+}
+
+function collectVariableDeclaratorBinding(text, baseOffset, kind, bindings, depthAt, bindingDepth) {
+  const assignment = topLevelCharIndex(text, '=');
+  const pattern = assignment === -1 ? text : text.slice(0, assignment);
+  collectBindingPatternBindings(pattern, baseOffset, kind, bindings, depthAt, bindingDepth);
+}
+
+function collectBindingPatternBindings(text, baseOffset, kind, bindings, depthAt, bindingDepth) {
+  const start = firstSignificantIndex(text);
+  if (start === -1) return;
+  if (text.slice(start).startsWith('...')) {
+    collectBindingPatternBindings(text.slice(start + 3), baseOffset + start + 3, kind, bindings, depthAt, bindingDepth);
+    return;
+  }
+  const char = text[start];
+  if (char === '{') {
+    const end = findMatchingDelimiter(text, start, '{', '}');
+    if (end !== -1) collectObjectPatternBindings(text.slice(start + 1, end), baseOffset + start + 1, kind, bindings, depthAt, bindingDepth);
+    return;
+  }
+  if (char === '[') {
+    const end = findMatchingDelimiter(text, start, '[', ']');
+    if (end !== -1) collectArrayPatternBindings(text.slice(start + 1, end), baseOffset + start + 1, kind, bindings, depthAt, bindingDepth);
+    return;
+  }
+  collectIdentifierBinding(text, baseOffset, start, kind, bindings, depthAt, bindingDepth);
+}
+
+function collectObjectPatternBindings(text, baseOffset, kind, bindings, depthAt, bindingDepth) {
+  for (const property of splitTopLevelComma(text, baseOffset)) {
+    const start = firstSignificantIndex(property.text);
+    if (start === -1) continue;
+    if (property.text.slice(start).startsWith('...')) {
+      collectBindingPatternBindings(property.text.slice(start + 3), property.offset + start + 3, kind, bindings, depthAt, bindingDepth);
+      continue;
+    }
+    const colon = topLevelCharIndex(property.text, ':');
+    if (colon !== -1) {
+      collectBindingPatternBindings(property.text.slice(colon + 1), property.offset + colon + 1, kind, bindings, depthAt, bindingDepth);
+      continue;
+    }
+    collectIdentifierBinding(property.text, property.offset, start, kind, bindings, depthAt, bindingDepth);
+  }
+}
+
+function collectArrayPatternBindings(text, baseOffset, kind, bindings, depthAt, bindingDepth) {
+  for (const element of splitTopLevelComma(text, baseOffset)) {
+    const start = firstSignificantIndex(element.text);
+    if (start === -1) continue;
+    if (element.text.slice(start).startsWith('...')) {
+      collectBindingPatternBindings(element.text.slice(start + 3), element.offset + start + 3, kind, bindings, depthAt, bindingDepth);
+      continue;
+    }
+    collectBindingPatternBindings(element.text, element.offset, kind, bindings, depthAt, bindingDepth);
+  }
+}
+
+function collectIdentifierBinding(text, baseOffset, start, kind, bindings, depthAt, bindingDepth) {
+  const match = /^[A-Za-z_$][\w$]*/.exec(text.slice(start));
+  if (!match) return;
+  const name = match[0];
+  const offset = baseOffset + start;
+  bindings.push({
+    kind,
+    name,
+    start: offset,
+    end: offset + name.length,
+    depth: bindingDepth ?? depthAt[offset] ?? 0,
+    namespaces: [valueNamespace]
+  });
+}
+
+function splitTopLevelComma(text, baseOffset) {
+  const parts = [];
+  let start = 0;
+  const depth = { brace: 0, bracket: 0, paren: 0 };
+  for (let index = 0; index < text.length; index += 1) {
+    updateDelimiterDepth(depth, text[index]);
+    if (text[index] === ',' && depth.brace === 0 && depth.bracket === 0 && depth.paren === 0) {
+      parts.push({ text: text.slice(start, index), offset: baseOffset + start });
+      start = index + 1;
+    }
+  }
+  parts.push({ text: text.slice(start), offset: baseOffset + start });
+  return parts;
+}
+
+function topLevelCharIndex(text, target) {
+  const depth = { brace: 0, bracket: 0, paren: 0 };
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === target && depth.brace === 0 && depth.bracket === 0 && depth.paren === 0) return index;
+    updateDelimiterDepth(depth, text[index]);
+  }
+  return -1;
+}
+
+function findMatchingDelimiter(text, open, openChar, closeChar) {
+  let depth = 0;
+  for (let index = open; index < text.length; index += 1) {
+    if (text[index] === openChar) depth += 1;
+    else if (text[index] === closeChar) {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function updateDelimiterDepth(depth, char) {
+  if (char === '{') depth.brace += 1;
+  else if (char === '}') depth.brace = Math.max(0, depth.brace - 1);
+  else if (char === '[') depth.bracket += 1;
+  else if (char === ']') depth.bracket = Math.max(0, depth.bracket - 1);
+  else if (char === '(') depth.paren += 1;
+  else if (char === ')') depth.paren = Math.max(0, depth.paren - 1);
+}
+
+function firstSignificantIndex(text) {
+  for (let index = 0; index < text.length; index += 1) {
+    if (!/\s/.test(text[index])) return index;
+  }
+  return -1;
+}
+
+function collectCatchBinding(code, token, bindings, depthAt) {
+  const open = nextSignificantCharIndex(code, token.end);
+  if (open === -1 || code[open] !== '(') return;
+  const close = findMatchingParen(code, open);
+  if (close === -1) return;
+  const text = code.slice(open + 1, close).trim();
+  if (!identifierRegExp.test(text)) return;
+  const start = code.indexOf(text, open + 1);
+  bindings.push({ kind: 'catch', name: text, start, end: start + text.length, depth: (depthAt[start] ?? 0) + 1, namespaces: [valueNamespace] });
+}
+
+function collectImportBindings(code, bindings, depthAt) {
+  for (const match of code.matchAll(/\bimport\b[\s\S]*?(?:;|$)/g)) {
+    const text = match[0];
+    if (!/\bfrom\b/.test(text)) continue;
+    const typeOnly = /\bimport\s+type\b/.test(text);
+    const fromIndex = text.search(/\bfrom\b/);
+    const clause = text.slice('import'.length, fromIndex).trim().replace(/^type\b/, '').trim();
+    collectImportClauseBindings(clause, match.index + text.indexOf(clause), typeOnly, bindings, depthAt);
+  }
+}
+
+function collectImportClauseBindings(clause, baseOffset, typeOnly, bindings, depthAt) {
+  const namespace = clause.match(/\*\s+as\s+([A-Za-z_$][\w$]*)/);
+  if (namespace) {
+    bindings.push(importBinding(namespace[1], baseOffset + namespace.index + namespace[0].lastIndexOf(namespace[1]), typeOnly, depthAt));
+    return;
+  }
+  const namedStart = clause.indexOf('{');
+  if (namedStart === -1) {
+    const defaultName = clause.replace(/,.*/, '').trim();
+    if (identifierRegExp.test(defaultName)) bindings.push(importBinding(defaultName, baseOffset + clause.indexOf(defaultName), typeOnly, depthAt));
+    return;
+  }
+  const beforeNamed = clause.slice(0, namedStart).replace(/,$/, '').trim();
+  if (identifierRegExp.test(beforeNamed)) bindings.push(importBinding(beforeNamed, baseOffset + clause.indexOf(beforeNamed), typeOnly, depthAt));
+  const namedEnd = clause.indexOf('}', namedStart + 1);
+  if (namedEnd === -1) return;
+  let offset = baseOffset + namedStart + 1;
+  for (const rawPart of clause.slice(namedStart + 1, namedEnd).split(',')) {
+    const part = rawPart.trim();
+    const clean = part.replace(/^type\s+/, '').trim();
+    const local = clean.match(/\bas\s+([A-Za-z_$][\w$]*)$/)?.[1] ?? clean.match(/^([A-Za-z_$][\w$]*)/)?.[1];
+    if (local) bindings.push(importBinding(local, offset + rawPart.indexOf(local), typeOnly || part.startsWith('type '), depthAt));
+    offset += rawPart.length + 1;
+  }
+}
+
+function importBinding(name, start, typeOnly, depthAt) {
+  return {
+    kind: 'import',
+    name,
+    start,
+    end: start + name.length,
+    depth: depthAt[start] ?? 0,
+    namespaces: typeOnly ? [typeNamespace] : [valueNamespace, typeNamespace]
+  };
+}
+
+function collectArrowFunctionBindings(code, bindings, depthAt) {
+  for (const match of code.matchAll(/\(([^()]*)\)\s*=>/g)) {
+    collectParameterListBindings(match[1], match.index + 1, bindings, depthAt, 'param');
+  }
+  for (const match of code.matchAll(/\b([A-Za-z_$][\w$]*)\s*=>/g)) {
+    bindings.push({ kind: 'param', name: match[1], start: match.index, end: match.index + match[1].length, depth: (depthAt[match.index] ?? 0) + 1, namespaces: [valueNamespace] });
+  }
+}
+
+function collectParameterListBindings(text, baseOffset, bindings, depthAt, kind) {
+  for (const parameter of splitTopLevelComma(text, baseOffset)) {
+    const pattern = parameterBindingPattern(parameter.text);
+    const start = firstSignificantIndex(pattern);
+    if (start === -1) continue;
+    const bindingDepth = (depthAt[parameter.offset + start] ?? 0) + 1;
+    collectBindingPatternBindings(pattern, parameter.offset, kind, bindings, depthAt, bindingDepth);
+  }
+}
+
+function parameterBindingPattern(text) {
+  const typeAnnotation = topLevelCharIndex(text, ':');
+  const initializer = topLevelCharIndex(text, '=');
+  const end = [typeAnnotation, initializer].filter((index) => index !== -1).sort((left, right) => left - right)[0];
+  return end === undefined ? text : text.slice(0, end);
+}
+
+export { collectBindings };

package/dist/js-ts-semantic-scope-use-def-scan.js

@@ -0,0 +1,241 @@
+import { identifierTokenRegExp } from './js-ts-semantic-scope-use-def-utils.js';
+
+function maskNonCode(sourceText) {
+  const text = String(sourceText ?? '');
+  const chars = [...text];
+  let unsupportedTemplateLiteral = false;
+  const templateExpressionRanges = [];
+  for (let index = 0; index < chars.length; index += 1) {
+    const char = chars[index];
+    const next = chars[index + 1];
+    if (char === '/' && next === '/') {
+      index = maskUntilLineEnd(chars, index);
+    } else if (char === '/' && next === '*') {
+      index = maskBlockComment(chars, index);
+    } else if (char === '\'' || char === '"') {
+      index = maskQuotedString(chars, index, char);
+    } else if (char === '`') {
+      const result = maskTemplateLiteral(chars, text, index, templateExpressionRanges, templateTag(text, index));
+      unsupportedTemplateLiteral ||= result.unsupported;
+      index = result.index;
+    }
+  }
+  return { code: chars.join(''), unsupportedTemplateLiteral, templateExpressionRanges };
+}
+
+function tokenize(code) {
+  return [...code.matchAll(identifierTokenRegExp)]
+    .map((match) => ({ value: match[0], start: match.index, end: match.index + match[0].length }));
+}
+
+function createBraceDepthIndex(code) {
+  const depthAt = new Array(code.length + 1);
+  let depth = 0;
+  for (let index = 0; index <= code.length; index += 1) {
+    depthAt[index] = depth;
+    const char = code[index];
+    if (char === '{') depth += 1;
+    else if (char === '}') depth = Math.max(0, depth - 1);
+  }
+  return depthAt;
+}
+
+function isPropertyAccess(code, start) {
+  let index = start - 1;
+  while (index >= 0 && /\s/.test(code[index])) index -= 1;
+  return code[index] === '.' || code[index] === '#';
+}
+
+function findStatementBoundary(code, start) {
+  let depth = 0;
+  for (let index = start; index < code.length; index += 1) {
+    const char = code[index];
+    if (char === '(' || char === '[' || char === '{') depth += 1;
+    else if (char === ')' || char === ']' || char === '}') depth = Math.max(0, depth - 1);
+    else if ((char === ';' || char === '\n') && depth === 0) return index;
+  }
+  return code.length;
+}
+
+function nextIdentifierToken(tokens, startIndex) {
+  for (let index = startIndex; index < tokens.length; index += 1) {
+    if (!isDeclarationModifier(tokens[index].value)) return tokens[index];
+  }
+  return undefined;
+}
+
+function previousIdentifierToken(tokens, startIndex) {
+  for (let index = startIndex; index >= 0; index -= 1) return tokens[index];
+  return undefined;
+}
+
+function likelyTypeReference(code, tokens, index) {
+  const previous = previousIdentifierToken(tokens, index - 1)?.value;
+  if (previous === 'type' || previous === 'interface' || previous === 'implements' || previous === 'extends' || previous === 'as' || previous === 'satisfies') {
+    return true;
+  }
+  const before = code.slice(Math.max(0, tokens[index].start - 4), tokens[index].start);
+  return /[:<]\s*$/.test(before);
+}
+
+function hasTypeAliasAssignment(code, start) {
+  for (let index = start; index < code.length; index += 1) {
+    const char = code[index];
+    if (char === '=') return true;
+    if (char === ';' || char === '\n' || char === '{') return false;
+  }
+  return false;
+}
+
+function maskUntilLineEnd(chars, start) {
+  let index = start;
+  while (index < chars.length && chars[index] !== '\n') {
+    chars[index] = ' ';
+    index += 1;
+  }
+  return index - 1;
+}
+
+function maskBlockComment(chars, start) {
+  let index = start;
+  while (index < chars.length) {
+    const done = chars[index] === '*' && chars[index + 1] === '/';
+    if (chars[index] !== '\n') chars[index] = ' ';
+    if (done) {
+      chars[index + 1] = ' ';
+      return index + 1;
+    }
+    index += 1;
+  }
+  return chars.length - 1;
+}
+
+function maskQuotedString(chars, start, quote) {
+  let index = start;
+  chars[index] = ' ';
+  index += 1;
+  while (index < chars.length) {
+    const char = chars[index];
+    if (char === '\\') {
+      chars[index] = ' ';
+      if (chars[index + 1] && chars[index + 1] !== '\n') chars[index + 1] = ' ';
+      index += 2;
+      continue;
+    }
+    if (char === quote) {
+      chars[index] = ' ';
+      return index;
+    }
+    if (char !== '\n') chars[index] = ' ';
+    index += 1;
+  }
+  return chars.length - 1;
+}
+
+function maskTemplateLiteral(chars, sourceText, start, templateExpressionRanges, tag) {
+  const templateContext = templateRangeContext(start, tag);
+  let index = start;
+  chars[index] = ' ';
+  index += 1;
+  while (index < chars.length) {
+    const char = chars[index];
+    const next = chars[index + 1];
+    if (char === '\\') {
+      chars[index] = ' ';
+      if (chars[index + 1] && chars[index + 1] !== '\n') chars[index + 1] = ' ';
+      index += 2;
+      continue;
+    }
+    if (char === '`') {
+      chars[index] = ' ';
+      return { index, unsupported: false };
+    }
+    if (char === '$' && next === '{') {
+      const expressionStart = index + 2;
+      chars[index] = ' ';
+      chars[index + 1] = ' ';
+      const result = preserveTemplateExpression(chars, sourceText, expressionStart, templateExpressionRanges);
+      if (result.unsupported) return result;
+      templateExpressionRanges.push({ start: expressionStart, end: result.index, ...templateContext });
+      index = result.index + 1;
+      continue;
+    }
+    if (char !== '\n') chars[index] = ' ';
+    index += 1;
+  }
+  return { index: chars.length - 1, unsupported: true };
+}
+
+function templateRangeContext(templateStart, tag) {
+  return {
+    templateStart,
+    templateKind: tag ? 'tagged-template' : 'template-literal',
+    templateTagText: tag?.text,
+    templateTagRoot: tag?.root,
+    templateTagMemberName: tag?.memberName,
+    templateTagStart: tag?.start,
+    templateTagEnd: tag?.end
+  };
+}
+
+function templateTag(sourceText, start) {
+  const prefix = String(sourceText ?? '').slice(0, start);
+  const match = /([A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*)\s*$/.exec(prefix);
+  if (!match) return undefined;
+  const text = match[1].replace(/\s*\.\s*/g, '.');
+  const parts = text.split('.');
+  return { text, root: parts[0], memberName: parts.length > 1 ? parts[parts.length - 1] : undefined, start: match.index, end: match.index + match[1].length };
+}
+
+function preserveTemplateExpression(chars, sourceText, start, templateExpressionRanges) {
+  let depth = 0;
+  for (let index = start; index < chars.length; index += 1) {
+    const char = chars[index];
+    const next = chars[index + 1];
+    if (char === '/' && next === '/') {
+      index = maskUntilLineEnd(chars, index);
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      index = maskBlockComment(chars, index);
+      continue;
+    }
+    if (char === '\'' || char === '"') {
+      index = maskQuotedString(chars, index, char);
+      continue;
+    }
+    if (char === '`') {
+      const result = maskTemplateLiteral(chars, sourceText, index, templateExpressionRanges, templateTag(sourceText, index));
+      if (result.unsupported) return result;
+      index = result.index;
+      continue;
+    }
+    if (char === '{') {
+      depth += 1;
+      continue;
+    }
+    if (char !== '}') continue;
+    if (depth === 0) {
+      chars[index] = ' ';
+      return { index, unsupported: false };
+    }
+    depth -= 1;
+  }
+  return { index: chars.length - 1, unsupported: true };
+}
+
+function isDeclarationModifier(value) {
+  return value === 'export' || value === 'default' || value === 'declare' || value === 'abstract' || value === 'async';
+}
+
+export {
+  createBraceDepthIndex,
+  findStatementBoundary,
+  hasTypeAliasAssignment,
+  isPropertyAccess,
+  likelyTypeReference,
+  maskNonCode,
+  nextIdentifierToken,
+  previousIdentifierToken,
+  tokenize
+};

package/dist/js-ts-semantic-scope-use-def-utils.js

@@ -0,0 +1,132 @@
+const identifierRegExp = /^[A-Za-z_$][\w$]*$/;
+const identifierTokenRegExp = /[A-Za-z_$][\w$]*/g;
+const valueNamespace = 'value';
+const typeNamespace = 'type';
+
+const LexicalUseDefReasonCodes = Object.freeze({
+  noLiveReferences: 'lexical-use-def-no-live-references',
+  invalidIdentifier: 'lexical-scope-invalid-identifier',
+  templateLiteralUnsupported: 'lexical-scope-template-literal-unsupported',
+  liveReference: 'lexical-scope-live-reference',
+  closureReference: 'lexical-scope-closure-reference',
+  shadowedBinding: 'lexical-scope-shadowed-binding',
+  bindingConflict: 'lexical-scope-binding-conflict',
+  typeValueNamespaceConflict: 'lexical-scope-type-value-namespace-conflict',
+  namespaceComputedMemberUnsupported: 'lexical-scope-namespace-computed-member-unsupported',
+  namespaceMemberWriteUnsupported: 'lexical-scope-namespace-member-write-unsupported',
+  importAliasTargetUnresolved: 'lexical-scope-import-alias-target-unresolved'
+});
+
+const declarationNamespaceByKind = Object.freeze({
+  function: [valueNamespace],
+  variable: [valueNamespace],
+  class: [valueNamespace, typeNamespace],
+  enum: [valueNamespace, typeNamespace],
+  type: [typeNamespace],
+  interface: [typeNamespace],
+  module: [valueNamespace, typeNamespace],
+  namespace: [valueNamespace, typeNamespace]
+});
+
+function namespacesForDeclarationKind(kind) {
+  return declarationNamespaceByKind[kind] ?? [valueNamespace];
+}
+
+function namespacesForImportRemoval(input) {
+  return input.typeOnly ? [typeNamespace] : [valueNamespace, typeNamespace];
+}
+
+function normalizeNamespaces(value) {
+  const raw = Array.isArray(value) ? value : [value ?? valueNamespace];
+  const namespaces = uniqueStrings(raw
+    .map((item) => String(item))
+    .filter((item) => item === valueNamespace || item === typeNamespace));
+  return namespaces.length ? namespaces : [valueNamespace];
+}
+
+function namespaceOverlap(left, right) {
+  return left.some((namespace) => right.includes(namespace));
+}
+
+function normalizeRanges(ranges) {
+  return (ranges ?? []).filter((range) => Number.isInteger(range?.start) && Number.isInteger(range?.end));
+}
+
+function spanRange(entry) {
+  return Number.isInteger(entry?.start) && Number.isInteger(entry?.end)
+    ? { start: entry.start, end: entry.end }
+    : undefined;
+}
+
+function rangeAllowed(record, ranges) {
+  return ranges.some((range) => record.start >= range.start && record.end <= range.end);
+}
+
+function rangeKey(record) {
+  return `${record.start}:${record.end}`;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record ?? {}).filter(([, value]) => value !== undefined));
+}
+
+function uniqueStrings(values) {
+  return [...new Set((values ?? []).filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+function uniqueBindings(bindings) {
+  const seen = new Set();
+  const result = [];
+  for (const binding of bindings) {
+    const key = `${binding.kind}:${binding.name}:${binding.start}:${binding.end}:${binding.namespaces.join('|')}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(binding);
+  }
+  return result;
+}
+
+function lineNumber(sourceText, offset) {
+  return String(sourceText ?? '').slice(0, offset).split('\n').length;
+}
+
+function nextSignificantCharIndex(code, start) {
+  for (let index = start; index < code.length; index += 1) {
+    if (!/\s/.test(code[index])) return index;
+  }
+  return -1;
+}
+
+function findMatchingParen(code, open) {
+  let depth = 0;
+  for (let index = open; index < code.length; index += 1) {
+    if (code[index] === '(') depth += 1;
+    else if (code[index] === ')') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+export {
+  LexicalUseDefReasonCodes,
+  compactRecord,
+  findMatchingParen,
+  identifierRegExp,
+  identifierTokenRegExp,
+  lineNumber,
+  namespaceOverlap,
+  namespacesForDeclarationKind,
+  namespacesForImportRemoval,
+  nextSignificantCharIndex,
+  normalizeNamespaces,
+  normalizeRanges,
+  rangeAllowed,
+  rangeKey,
+  spanRange,
+  typeNamespace,
+  uniqueBindings,
+  uniqueStrings,
+  valueNamespace
+};