@shapeshift-labs/frontier-lang-compiler 0.2.103 → 0.2.105

package/dist/js-ts-semantic-merge-member-containers.js

@@ -0,0 +1,100 @@
+function normalizeKind(kind) {
+  const text = String(kind ?? '').toLowerCase();
+  if (text === 'interface') return 'interface';
+  if (text === 'type' || text === 'typealias' || text === 'type-alias') return 'type';
+  if (text === 'class') return 'class';
+  if (text === 'object' || text === 'object-literal') return 'object';
+  return undefined;
+}
+
+function findContainer(sourceText, region) {
+  const kind = normalizeKind(region.kind);
+  const pattern = containerPattern(kind, region.name);
+  const matches = [];
+  let match;
+  while ((match = pattern.exec(sourceText))) {
+    const openIndex = sourceText.indexOf('{', match.index);
+    if (openIndex < 0 || openIndex >= pattern.lastIndex) continue;
+    const closeIndex = findMatchingBrace(sourceText, openIndex);
+    if (closeIndex < 0) return { reasonCodes: ['unterminated-container'] };
+    matches.push({
+      kind,
+      name: region.name,
+      start: match.index,
+      openStart: openIndex,
+      bodyStart: openIndex + 1,
+      bodyEnd: closeIndex,
+      end: closeIndex + 1,
+      body: sourceText.slice(openIndex + 1, closeIndex)
+    });
+  }
+  if (!matches.length) return { reasonCodes: ['container-not-found'] };
+  if (matches.length > 1) return { reasonCodes: ['ambiguous-container'] };
+  return { reasonCodes: [], value: matches[0] };
+}
+
+function containerPattern(kind, name) {
+  const escapedName = escapeRegExp(name);
+  if (kind === 'interface') return new RegExp(`\\b(?:export\\s+)?interface\\s+${escapedName}\\b[^{};=]*\\{`, 'g');
+  if (kind === 'type') return new RegExp(`\\b(?:export\\s+)?type\\s+${escapedName}\\b\\s*=\\s*\\{`, 'g');
+  if (kind === 'class') return new RegExp(`\\b(?:export\\s+)?(?:default\\s+)?(?:abstract\\s+)?class\\s+${escapedName}\\b[^{};=]*\\{`, 'g');
+  return new RegExp(`\\b(?:export\\s+)?(?:const|let|var)\\s+${escapedName}\\b[^=;{}]*=\\s*\\{`, 'g');
+}
+
+function findMatchingBrace(sourceText, openIndex) {
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  for (let index = openIndex; index < sourceText.length; index += 1) {
+    const char = sourceText[index];
+    const next = sourceText[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{') depth += 1;
+    else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export {
+  findContainer,
+  normalizeKind
+};

package/dist/js-ts-semantic-merge-member-keys.js

@@ -0,0 +1,142 @@
+function memberKey(text, kind) {
+  if (kind === 'object') return objectMemberKey(text);
+  if (kind === 'class') return classMemberKey(text);
+  return typeMemberKey(text);
+}
+
+function objectMemberKey(text) {
+  const source = text.replace(/[;,]\s*$/, '').trim();
+  const methodSource = stripObjectMemberPrefixes(source);
+  const methodMatch = methodSource.match(/^(['"]?)([A-Za-z_$][\w$-]*)\1\s*(?:<[^({;]+>)?\s*\(/);
+  if (methodMatch) return { key: methodMatch[2], memberKind: 'method' };
+  const colon = topLevelColon(text);
+  if (colon >= 0) {
+    const key = propertyKey(text.slice(0, colon).trim());
+    return key ? { key, memberKind: 'property' } : undefined;
+  }
+  const shorthand = propertyKey(source);
+  return shorthand ? { key: shorthand, memberKind: 'property' } : undefined;
+}
+
+function typeMemberKey(text) {
+  const source = text.replace(/[;,]\s*$/, '').trim().replace(/^readonly\s+/, '');
+  const methodMatch = source.match(/^(['"]?)([A-Za-z_$][\w$-]*)\1\??\s*(?:<[^({;]+>)?\s*\(/);
+  if (methodMatch) return { key: methodMatch[2], memberKind: 'method' };
+  const colon = topLevelColon(source);
+  if (colon < 0) return undefined;
+  const key = propertyKey(source.slice(0, colon).trim().replace(/\?$/, '').trim());
+  return key ? { key, memberKind: 'property' } : undefined;
+}
+
+function classMemberKey(text) {
+  const stripped = stripClassMemberPrefixes(text.replace(/[;,]\s*$/, '').trim());
+  const source = stripped.source;
+  if (!source || source.startsWith('@') || /^static\s*\{/.test(source)) return undefined;
+  const constructorMatch = source.match(/^constructor\s*\(/);
+  if (constructorMatch) return { key: 'constructor', memberKind: 'constructor' };
+  const accessorMatch = source.match(/^(get|set)\s+(['"]?)(#?[A-Za-z_$][\w$-]*)\2\s*\(/);
+  if (accessorMatch) return { key: classMemberKeyName(accessorMatch[3], stripped.isStatic), memberKind: 'accessor' };
+  const methodMatch = source.match(/^(?:async\s+)?(['"]?)(#?[A-Za-z_$][\w$-]*)\1\s*(?:<[^({;]+>)?\s*\(/);
+  if (methodMatch) return { key: classMemberKeyName(methodMatch[2], stripped.isStatic), memberKind: 'method' };
+  const propertyMatch = source.match(/^(['"]?)(#?[A-Za-z_$][\w$-]*)\1[?!]?\s*(?::|=|$)/);
+  if (propertyMatch) return { key: classMemberKeyName(propertyMatch[2], stripped.isStatic), memberKind: 'property' };
+  return undefined;
+}
+
+function classMemberKeyName(name, isStatic) {
+  return isStatic ? `static.${name}` : name;
+}
+
+function stripObjectMemberPrefixes(source) {
+  return String(source ?? '').replace(/^(?:async|get|set)\s+/, '');
+}
+
+function stripClassMemberPrefixes(source) {
+  let output = String(source ?? '').trim();
+  let isStatic = false;
+  const prefixes = ['public', 'private', 'protected', 'abstract', 'override', 'declare', 'readonly', 'accessor'];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const prefix of prefixes) {
+      const pattern = new RegExp(`^${prefix}\\s+`);
+      if (pattern.test(output)) {
+        output = output.replace(pattern, '').trimStart();
+        changed = true;
+      }
+    }
+    if (/^static\s+/.test(output)) {
+      output = output.replace(/^static\s+/, '').trimStart();
+      isStatic = true;
+      changed = true;
+    }
+  }
+  return { source: output, isStatic };
+}
+
+function isTypeAliasConflictMember(text) {
+  return /^\|/.test(text) || /^&/.test(text);
+}
+
+function hasSpreadLikeMember(text) {
+  return stripLeadingMemberKeywords(text).startsWith('...');
+}
+
+function hasComputedMemberKey(text) {
+  return stripLeadingMemberKeywords(text).startsWith('[');
+}
+
+function stripLeadingMemberKeywords(text) {
+  let source = String(text ?? '').trim();
+  const prefixes = ['public', 'private', 'protected', 'abstract', 'override', 'declare', 'readonly', 'static', 'accessor', 'async', 'get', 'set'];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const prefix of prefixes) {
+      const pattern = new RegExp(`^${prefix}\\s+`);
+      if (pattern.test(source)) {
+        source = source.replace(pattern, '').trimStart();
+        changed = true;
+      }
+    }
+  }
+  return source;
+}
+
+function propertyKey(source) {
+  if (!source || source.startsWith('[')) return undefined;
+  const quoted = source.match(/^(['"])([^'"\\]+)\1$/);
+  if (quoted) return quoted[2];
+  const identifier = source.match(/^[A-Za-z_$][\w$-]*$/);
+  return identifier?.[0];
+}
+
+function topLevelColon(source) {
+  let quote;
+  let escaped = false;
+  let depth = 0;
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') depth += 1;
+    else if (char === '}' || char === ']' || char === ')') depth -= 1;
+    else if (char === ':' && depth === 0) return index;
+  }
+  return -1;
+}
+
+export {
+  hasComputedMemberKey,
+  hasSpreadLikeMember,
+  isTypeAliasConflictMember,
+  memberKey
+};

package/dist/js-ts-semantic-merge-member-segments.js

@@ -0,0 +1,185 @@
+import {
+  hasComputedMemberKey,
+  hasSpreadLikeMember,
+  isTypeAliasConflictMember,
+  memberKey
+} from './js-ts-semantic-merge-member-keys.js';
+import { uniqueStrings } from './js-ts-semantic-merge-member-utils.js';
+
+function parseMembers(body, kind) {
+  const reasonCodes = [];
+  const members = [];
+  for (const segment of splitMemberSegments(body, kind)) {
+    const trimmed = segment.text.trim();
+    if (!trimmed) continue;
+    if (hasSpreadLikeMember(trimmed)) {
+      reasonCodes.push('spread-like-member');
+      continue;
+    }
+    if (hasComputedMemberKey(trimmed)) {
+      reasonCodes.push('computed-key');
+      continue;
+    }
+    if (kind === 'type' && isTypeAliasConflictMember(trimmed)) {
+      reasonCodes.push('type-alias-conflict');
+      continue;
+    }
+    const parsed = memberKey(trimmed, kind);
+    if (!parsed?.key) {
+      reasonCodes.push(`unsupported-${kind}-member`);
+      continue;
+    }
+    members.push({ ...segment, ...parsed });
+  }
+  return { members, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function splitMemberSegments(body, kind) {
+  if (kind === 'class') return splitClassMemberSegments(body);
+  const entries = [];
+  const text = String(body ?? '');
+  let start = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') depth += 1;
+    else if (char === '}' || char === ']' || char === ')') depth -= 1;
+    const separator = kind === 'object' ? ',' : ';';
+    if (char === separator && depth === 0) {
+      entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+      start = index + 1;
+    }
+  }
+  entries.push({ text: text.slice(start), start, end: text.length });
+  return entries.filter((entry) => entry.text.trim());
+}
+
+function splitClassMemberSegments(body) {
+  const entries = [];
+  const text = String(body ?? '');
+  let start = 0;
+  let quote;
+  let escaped = false;
+  let blockComment = false;
+  let lineComment = false;
+  let depth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (lineComment) {
+      if (char === '\n' || char === '\r') lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '/' && next === '/') {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '/' && next === '*') {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{' || char === '[' || char === '(') {
+      depth += 1;
+      continue;
+    }
+    if (char === '}' || char === ']' || char === ')') {
+      depth -= 1;
+      if (depth === 0 && char === '}') {
+        const nextIndex = nextSignificantIndex(text, index + 1);
+        if (text[nextIndex] !== ';') {
+          entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+          start = index + 1;
+        }
+      }
+      continue;
+    }
+    if (char === ';' && depth === 0) {
+      entries.push({ text: text.slice(start, index + 1), start, end: index + 1 });
+      start = index + 1;
+    }
+  }
+  entries.push({ text: text.slice(start), start, end: text.length });
+  return entries.filter((entry) => entry.text.trim());
+}
+
+function nextSignificantIndex(text, offset) {
+  let index = offset;
+  while (index < text.length) {
+    if (/\s/.test(text[index])) {
+      index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '/') {
+      index += 2;
+      while (index < text.length && text[index] !== '\n' && text[index] !== '\r') index += 1;
+      continue;
+    }
+    if (text[index] === '/' && text[index + 1] === '*') {
+      index += 2;
+      while (index < text.length && !(text[index] === '*' && text[index + 1] === '/')) index += 1;
+      index += 2;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+
+export {
+  parseMembers
+};

package/dist/js-ts-semantic-merge-member-source.js

@@ -0,0 +1,82 @@
+import { findContainer } from './js-ts-semantic-merge-member-containers.js';
+import { uniqueStrings } from './js-ts-semantic-merge-member-utils.js';
+
+function canonicalizeSourceBodies(sourceText, preparedRegions, side) {
+  let output = sourceText;
+  const replacements = preparedRegions
+    .map((region) => ({ range: region[side], replacement: region.base.body }))
+    .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
+  for (const { range, replacement } of replacements) {
+    output = `${output.slice(0, range.bodyStart)}${replacement}${output.slice(range.bodyEnd)}`;
+  }
+  return output;
+}
+
+function applyMemberAdditions(headSourceText, preparedRegions) {
+  return applyPreparedMemberAdditions(headSourceText, preparedRegions, ['worker']).sourceText;
+}
+
+function applyPreparedMemberAdditions(sourceText, preparedRegions, sides = ['worker']) {
+  let output = sourceText;
+  const reasonCodes = [];
+  const replacements = preparedRegions
+    .map((region) => {
+      const match = findContainer(sourceText, region.policy);
+      if (match.reasonCodes.length) {
+        reasonCodes.push(...match.reasonCodes.map((reason) => `target-${reason}:${region.kind}:${region.name}`));
+        return undefined;
+      }
+      const members = sides.flatMap((side) => region[`${side}AddedMembers`] ?? []);
+      if (!members.length) return undefined;
+      return { range: match.value, replacement: appendMembersToBody(match.value.body, members) };
+    })
+    .filter(Boolean)
+    .sort((left, right) => right.range.bodyStart - left.range.bodyStart);
+  for (const { range, replacement } of replacements) {
+    output = `${output.slice(0, range.bodyStart)}${replacement}${output.slice(range.bodyEnd)}`;
+  }
+  return { sourceText: output, reasonCodes: uniqueStrings(reasonCodes) };
+}
+
+function appendMembersToBody(body, members) {
+  if (!members.length) return body;
+  const indent = inferMemberIndent(body) ?? inferMemberIndent(members.map((member) => member.text).join('\n')) ?? '  ';
+  const addedText = members.map((member) => normalizeMemberForInsertion(member.text, indent)).join('\n');
+  const trailing = body.match(/\s*$/)?.[0] ?? '';
+  const before = body.slice(0, body.length - trailing.length);
+  if (!before.trim()) {
+    const closingIndent = trailing.includes('\n') ? trailing.slice(trailing.lastIndexOf('\n') + 1) : '';
+    return `\n${addedText}\n${closingIndent}`;
+  }
+  return `${before}${before.endsWith('\n') ? '' : '\n'}${addedText}${trailing.includes('\n') ? trailing : `\n${trailing}`}`;
+}
+
+function inferMemberIndent(text) {
+  return String(text ?? '').match(/\n([ \t]*)\S/)?.[1];
+}
+
+function normalizeMemberForInsertion(text, indent) {
+  const lines = String(text ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+  while (lines.length && !lines[0].trim()) lines.shift();
+  while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+  const commonIndent = minimumIndent(lines);
+  return lines.map((line) => {
+    const normalized = commonIndent ? line.slice(Math.min(commonIndent, leadingWhitespace(line))) : line;
+    return normalized.trim() ? `${indent}${normalized}` : normalized;
+  }).join('\n');
+}
+
+function minimumIndent(lines) {
+  const indents = lines.filter((line) => line.trim()).map(leadingWhitespace);
+  return indents.length ? Math.min(...indents) : 0;
+}
+
+function leadingWhitespace(line) {
+  return line.match(/^[ \t]*/)?.[0].length ?? 0;
+}
+
+export {
+  applyMemberAdditions,
+  applyPreparedMemberAdditions,
+  canonicalizeSourceBodies
+};

package/dist/js-ts-semantic-merge-member-utils.js

@@ -0,0 +1,18 @@
+function normalizeMemberText(text) {
+  return String(text ?? '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .join('\n')
+    .trim();
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter(Boolean).map(String))];
+}
+
+export {
+  normalizeMemberText,
+  uniqueStrings
+};

package/dist/js-ts-semantic-merge-parse.js

@@ -0,0 +1,16 @@
+export {
+  findContainer,
+  normalizeKind
+} from './js-ts-semantic-merge-member-containers.js';
+export {
+  parseMembers
+} from './js-ts-semantic-merge-member-segments.js';
+export {
+  applyMemberAdditions,
+  applyPreparedMemberAdditions,
+  canonicalizeSourceBodies
+} from './js-ts-semantic-merge-member-source.js';
+export {
+  normalizeMemberText,
+  uniqueStrings
+} from './js-ts-semantic-merge-member-utils.js';

package/dist/js-ts-semantic-merge.js

@@ -0,0 +1,24 @@
+export {
+  JsTsSafeMergeConflictCodes,
+  JsTsSafeMergeGateIds,
+  JsTsSafeMergeStatuses,
+  safeMergeJsTsImportsAndDeclarations
+} from './js-ts-safe-merge.js';
+export {
+  safeMergeJsTsSource
+} from './js-ts-safe-merge-composed.js';
+export {
+  mergeJsTsSafeMemberAdditions,
+  safeMergeJsTsMembers
+} from './js-ts-safe-member-merge.js';
+export {
+  createJsTsSemanticMergeConflictExplanation,
+  createJsTsSemanticMergeGateResult,
+  JsTsSemanticMergeConflictClasses,
+  JsTsSemanticMergeGateStatuses
+} from './js-ts-semantic-merge-contracts.js';
+export {
+  createJsTsSemanticConflictSidecars,
+  JsTsSemanticConflictSidecarClasses,
+  summarizeJsTsSemanticConflictSidecars
+} from './js-ts-semantic-conflict-sidecars.js';

package/dist/lightweight-dependency-effects.js

@@ -0,0 +1,51 @@
+function lightweightEffectKinds(line) {
+  const kinds = [];
+  if (/\bawait\b|import\s*\(/.test(line)) kinds.push('async');
+  if (hasGlobalNetworkCall(line)) kinds.push('network');
+  if (/\b(localStorage|sessionStorage|indexedDB|caches|cookie)\b/.test(line)) kinds.push('storage');
+  if (hasGlobalSchedulerCall(line)) kinds.push('scheduler');
+  if (/\b(console|process|Deno|Bun)\s*\./.test(line)) kinds.push('host');
+  if (hasBrowserEffect(line)) kinds.push('browser');
+  return kinds;
+}
+
+function hasGlobalNetworkCall(line) {
+  return hasBareCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource'])
+    || hasGlobalPropertyCall(line, ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource']);
+}
+
+function hasGlobalSchedulerCall(line) {
+  const names = [
+    'setTimeout',
+    'setInterval',
+    'clearTimeout',
+    'clearInterval',
+    'requestAnimationFrame',
+    'cancelAnimationFrame',
+    'requestIdleCallback',
+    'cancelIdleCallback',
+    'queueMicrotask',
+    'setImmediate',
+    'clearImmediate'
+  ];
+  return hasBareCall(line, names) || hasGlobalPropertyCall(line, names);
+}
+
+function hasBrowserEffect(line) {
+  return /\b(document|window|navigator|location|history)\s*\./.test(line)
+    || hasGlobalConstructorCall(line, ['Worker', 'SharedWorker']);
+}
+
+function hasBareCall(line, names) {
+  return names.some((name) => new RegExp(`(?:^|[^\\w$.])${name}\\s*\\(`).test(line));
+}
+
+function hasGlobalPropertyCall(line, names) {
+  return names.some((name) => new RegExp(`\\b(?:window|globalThis|self)\\s*\\.\\s*${name}\\s*\\(`).test(line));
+}
+
+function hasGlobalConstructorCall(line, names) {
+  return names.some((name) => new RegExp(`(?:^|[^\\w$.])new\\s+(?:(?:window|globalThis|self)\\s*\\.\\s*)?${name}\\s*\\(`).test(line));
+}
+
+export { lightweightEffectKinds };

package/dist/lightweight-dependency-language.js

@@ -41,7 +41,7 @@ export function isDependencyIdentifier(value) {
 export function dependencyScanRanges(input, declarations, lines) {
   const ordered = [...(declarations ?? [])].sort((left, right) => (left.span?.startLine ?? 0) - (right.span?.startLine ?? 0));
   return ordered
-    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import')
+    .filter((declaration) => declaration?.symbolId && declaration.role !== 'import' && shouldScanDependencyDeclaration(input, declaration))
     .map((declaration, index) => ({
       declaration,
       startLine: declaration.span?.startLine ?? 1,
@@ -49,6 +49,17 @@ export function dependencyScanRanges(input, declarations, lines) {
     }));
 }
 
+function shouldScanDependencyDeclaration(input, declaration) {
+  if (!isJavaScriptLikeLanguage(input)) return true;
+  if (declaration.metadata?.signatureOnly || declaration.fields?.typeKind) return false;
+  if (/^Type(?:Alias|Method|Property|FunctionProperty)/.test(String(declaration?.kind ?? ''))) return false;
+  return !['interface', 'type'].includes(String(declaration?.symbolKind ?? '').toLowerCase());
+}
+
+function isJavaScriptLikeLanguage(input) {
+  return ['javascript', 'typescript'].includes(String(input?.language ?? '').toLowerCase());
+}
+
 export function maskDependencyLine(input, line, state) {
   const language = String(input.language ?? '').toLowerCase();
   const text = String(line ?? '');