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

package/dist/internal/index-impl/syntaxAstSourcePreservation.js

@@ -0,0 +1,273 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from '../../native-import-utils.js';
+import {
+  createPreservedSourceOwnershipAnchor,
+  preservedOwnershipAnchorKind,
+  preservedSourceSegmentRole
+} from '../../native-source-preservation-ownership.js';
+import { createNativeSourcePreservation } from './createNativeSourcePreservation.js';
+
+export function createSyntaxAstSourcePreservation(ast, input, options = {}) {
+  if (!ast || typeof input.sourceText !== 'string') return undefined;
+  const sourceText = input.sourceText;
+  const sourceHash = hashSemanticValue(sourceText);
+  const parserEvidence = `${options.parser ?? input.parser ?? 'syntax-ast'}-parser-token-comment-ranges`;
+  const tokensAndTrivia = syntaxAstTokensAndTrivia(ast, input, {
+    ...options,
+    parserEvidence,
+    sourceHash,
+    sourceText
+  });
+  if (!tokensAndTrivia?.exact) return undefined;
+  const adapterId = input.adapterId ?? options.adapterId ?? `${options.parser ?? input.parser ?? 'syntax'}-native-importer`;
+  return createNativeSourcePreservation({
+    language: input.language ?? options.language ?? 'javascript',
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    sourceText,
+    tokensAndTrivia,
+    includeTokens: options.includeTokens !== false,
+    includeTrivia: options.includeTrivia !== false,
+    parserTriviaEvidence: {
+      status: 'exact',
+      exactParserTrivia: true,
+      losslessCst: true,
+      sourceHash,
+      adapterId,
+      evidenceId: `${adapterId}:parser-token-comment:${idFragment(input.sourcePath ?? sourceHash)}`,
+      parserEvidence
+    },
+    metadata: {
+      parserTokenTriviaEvidence: parserEvidence,
+      parserTokenTriviaSource: options.astFormat ?? options.parser ?? 'syntax-ast'
+    }
+  });
+}
+
+function syntaxAstTokensAndTrivia(ast, input, options) {
+  const sourceText = options.sourceText;
+  const parserSegments = parserTokenCommentSegments(ast)
+    .map((entry, index) => segmentFromParserEntry(entry, index, input, options))
+    .filter(Boolean)
+    .sort((left, right) => left.span.start - right.span.start || left.span.end - right.span.end);
+  if (!parserSegments.length) return undefined;
+  const exact = parserSegmentsCoverSource(parserSegments, sourceText);
+  if (!exact) return { exact: false };
+  const whitespaceSegments = whitespaceTriviaSegments(parserSegments, input, options);
+  const allTrivia = [...parserSegments.filter((segment) => segment.role === 'trivia'), ...whitespaceSegments]
+    .sort((left, right) => left.span.start - right.span.start || left.span.end - right.span.end);
+  const tokens = limitRecords(parserSegments.filter((segment) => segment.role !== 'trivia'), options.maxTokens);
+  const trivia = limitRecords(allTrivia, options.maxTrivia);
+  return {
+    exact: true,
+    tokens: tokens.records,
+    trivia: trivia.records,
+    truncated: tokens.truncated || trivia.truncated,
+    parserEvidence: options.parserEvidence
+  };
+}
+
+function parserTokenCommentSegments(ast) {
+  return uniqueParserEntries([
+    ...arrayValue(ast.tokens),
+    ...arrayValue(ast.comments),
+    ...arrayValue(ast.program?.tokens),
+    ...arrayValue(ast.program?.comments)
+  ]);
+}
+
+function segmentFromParserEntry(entry, index, input, options) {
+  const range = sourceRange(entry);
+  if (!range || range.end <= range.start || range.end > options.sourceText.length) return undefined;
+  const text = options.sourceText.slice(range.start, range.end);
+  if (!parserEntrySourceTextMatches(entry, text)) return undefined;
+  const parserKind = parserEntryKind(entry);
+  const kind = entryIsComment(entry, text) ? preservedCommentKind(text) : syntaxTokenKind(parserKind, text, input.sourcePath);
+  return preservedParserSegment({
+    index,
+    kind,
+    text,
+    start: range.start,
+    end: range.end,
+    sourceHash: options.sourceHash,
+    sourcePath: input.sourcePath,
+    sourceText: options.sourceText,
+    parserEvidence: options.parserEvidence,
+    parserKind
+  });
+}
+
+function whitespaceTriviaSegments(parserSegments, input, options) {
+  const result = [];
+  let cursor = 0;
+  for (const segment of parserSegments) {
+    if (segment.span.start > cursor) {
+      result.push(...whitespaceSegmentsForText(options.sourceText.slice(cursor, segment.span.start), cursor, input, options, result.length));
+    }
+    cursor = Math.max(cursor, segment.span.end);
+  }
+  if (cursor < options.sourceText.length) {
+    result.push(...whitespaceSegmentsForText(options.sourceText.slice(cursor), cursor, input, options, result.length));
+  }
+  return result;
+}
+
+function whitespaceSegmentsForText(text, baseOffset, input, options, startIndex) {
+  const records = [];
+  const matches = text.matchAll(/\r\n|\r|\n|[ \t\v\f]+/g);
+  for (const match of matches) {
+    const start = baseOffset + match.index;
+    const end = start + match[0].length;
+    records.push(preservedParserSegment({
+      index: startIndex + records.length,
+      kind: /\r|\n/.test(match[0]) ? 'newline' : 'whitespace',
+      text: match[0],
+      start,
+      end,
+      sourceHash: options.sourceHash,
+      sourcePath: input.sourcePath,
+      sourceText: options.sourceText,
+      parserEvidence: options.parserEvidence,
+      parserKind: 'source-gap'
+    }));
+  }
+  return records;
+}
+
+function preservedParserSegment(input) {
+  const role = preservedSourceSegmentRole(input.kind);
+  const textHash = hashSemanticValue(input.text);
+  const span = {
+    sourceId: input.sourceHash,
+    path: input.sourcePath,
+    ...sourceSpanPositions(input.start, input.end, input.sourceText)
+  };
+  return {
+    id: `${input.kind}_${input.index + 1}_${idFragment(input.start)}`,
+    kind: input.kind,
+    role,
+    text: input.text,
+    textHash,
+    span,
+    ownershipAnchor: createPreservedSourceOwnershipAnchor({
+      kind: input.kind,
+      role,
+      text: input.text,
+      textHash,
+      sourcePath: input.sourcePath,
+      sourceHash: input.sourceHash,
+      span,
+      anchorKind: preservedOwnershipAnchorKind(input.kind, role),
+      parserEvidence: input.parserEvidence,
+      parserTriviaEvidence: {
+        status: 'exact',
+        exactParserTrivia: true,
+        losslessCst: true,
+        sourceHash: input.sourceHash,
+        parserEvidence: input.parserEvidence,
+        adapterId: 'syntax-ast'
+      }
+    }),
+    metadata: { parserKind: input.parserKind, parserEvidence: input.parserEvidence }
+  };
+}
+
+function parserSegmentsCoverSource(segments, sourceText) {
+  let cursor = 0;
+  for (const segment of segments) {
+    if (segment.span.start < cursor) return false;
+    if (!/^[\s]*$/.test(sourceText.slice(cursor, segment.span.start))) return false;
+    cursor = segment.span.end;
+  }
+  return /^[\s]*$/.test(sourceText.slice(cursor));
+}
+
+function sourceSpanPositions(start, end, sourceText) {
+  const beforeStart = String(sourceText ?? '').slice(0, start);
+  const beforeEnd = String(sourceText ?? '').slice(0, end);
+  const startLine = lineCount(beforeStart);
+  const endLine = lineCount(beforeEnd);
+  return {
+    start,
+    end,
+    startLine,
+    startColumn: start - lastLineStart(beforeStart) + 1,
+    endLine,
+    endColumn: end - lastLineStart(beforeEnd) + 1
+  };
+}
+
+function sourceRange(entry) {
+  if (Number.isFinite(entry?.start) && Number.isFinite(entry?.end)) return { start: entry.start, end: entry.end };
+  if (Array.isArray(entry?.range) && Number.isFinite(entry.range[0]) && Number.isFinite(entry.range[1])) {
+    return { start: entry.range[0], end: entry.range[1] };
+  }
+  return undefined;
+}
+
+function parserEntryKind(entry) {
+  const type = entry?.type;
+  if (typeof type === 'string') return type;
+  return type?.label ?? type?.keyword ?? type?.name ?? entry?.kind ?? 'Token';
+}
+
+function parserEntrySourceTextMatches(entry, text) {
+  const expected = entry?.raw ?? entry?.extra?.raw ?? entry?.text ?? entry?.source;
+  return typeof expected === 'string' ? expected === text : true;
+}
+
+function entryIsComment(entry, text) {
+  const kind = String(parserEntryKind(entry));
+  return kind.includes('Comment') || text.startsWith('//') || text.startsWith('/*');
+}
+
+function syntaxTokenKind(parserKind, text, sourcePath) {
+  const kind = String(parserKind);
+  if (kind === 'Identifier' || kind === 'name') return 'identifier';
+  if (kind === 'Keyword' || kind.endsWith('Keyword')) return 'keyword';
+  if (kind === 'String' || kind === 'StringLiteral' || kind === 'string') return 'string';
+  if (kind === 'Numeric' || kind === 'NumericLiteral' || kind === 'num') return 'number';
+  if (kind === 'RegularExpression' || kind === 'regexp') return 'regex-like';
+  if (kind.includes('Template') || text.startsWith('`')) return 'template';
+  if (kind.includes('JSX') || /\.(?:jsx|tsx)$/i.test(String(sourcePath ?? '')) && /^(?:<|<\/|\/>|>)$/.test(text)) return 'jsx';
+  if (/^[()[\]{};,]$/.test(text)) return 'punctuation';
+  if (/^[=+\-*/%&|^!<>?:.]+$/.test(text)) return 'operator';
+  return 'unknown';
+}
+
+function preservedCommentKind(text) {
+  const value = String(text ?? '');
+  if (/[#@]\s*sourceMappingURL=|[#@]\s*sourceURL=/.test(value)) return 'source-map-comment';
+  if (value.startsWith('/**') && value[3] !== '/') return 'jsdoc-comment';
+  if (value.startsWith('/*')) return 'block-comment';
+  return 'comment';
+}
+
+function limitRecords(records, maxValue) {
+  const max = Number.isFinite(maxValue) ? Math.max(0, maxValue) : 20000;
+  return { records: records.slice(0, max), truncated: records.length > max };
+}
+
+function uniqueParserEntries(entries) {
+  const seen = new Set();
+  return entries.filter((entry) => {
+    const range = sourceRange(entry);
+    if (!range) return false;
+    const key = `${range.start}:${range.end}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function arrayValue(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function lineCount(text) {
+  return text.split(/\r\n|\r|\n/).length;
+}
+
+function lastLineStart(text) {
+  return Math.max(text.lastIndexOf('\n') + 1, text.lastIndexOf('\r') + 1, 0);
+}

package/dist/internal/index-impl/syntaxCommonJsModuleDeclarationEntries.js

@@ -0,0 +1,297 @@
+import {
+  exportBindingEntry,
+  exportModuleEntries,
+  identifierName,
+  importModuleEntries,
+  sourceValue
+} from './syntaxModuleEntryRecords.js';
+
+export function commonJsRequireVariableEntries(node, nativeNodeId, input) {
+  const helper = commonJsInteropHelperRequireBinding(node);
+  if (helper) return importModuleEntries(input, nativeNodeId, helper.moduleSpecifier, [helper.binding], helper.metadata);
+  const moduleSpecifier = commonJsRequireModuleSpecifier(node.init);
+  if (!moduleSpecifier) return [];
+  const bindings = commonJsRequireBindings(node.id);
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
+    importKind: 'commonjs-require',
+    commonJs: true
+  });
+}
+
+export function commonJsRequireExpressionEntries(node, nativeNodeId, input) {
+  const moduleSpecifier = commonJsRequireModuleSpecifier(node.expression);
+  if (!moduleSpecifier) return [];
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, [], {
+    importKind: 'commonjs-require',
+    sideEffectOnly: true,
+    commonJs: true
+  });
+}
+
+export function commonJsExpressionStatementEntries(node, nativeNodeId, input) {
+  return [
+    ...commonJsRequireExpressionEntries(node, nativeNodeId, input),
+    ...commonJsExportStarExpressionEntries(node, nativeNodeId, input),
+    ...commonJsCreateBindingReExportExpressionEntries(node, nativeNodeId, input),
+    ...commonJsObjectAssignExportExpressionEntries(node, nativeNodeId, input),
+    ...commonJsDefinePropertiesExportExpressionEntries(node, nativeNodeId, input),
+    ...commonJsDefinePropertyExportExpressionEntries(node, nativeNodeId, input)
+  ];
+}
+
+export function commonJsExportAssignmentEntries(node, nativeNodeId, input) {
+  if (node.operator && node.operator !== '=') return [];
+  const target = commonJsExportTarget(node.left);
+  if (!target) return [];
+  if (target.exportedName === '__esModule') return [];
+  const assignment = exportBindingEntry(input, nativeNodeId, undefined, {
+    localName: expressionExportLocalName(node.right),
+    exportedName: target.exportedName,
+    exportKind: target.exportKind,
+    isTypeOnly: false,
+    commonJs: true
+  });
+  return [
+    assignment,
+    ...(target.exportedName === 'module.exports'
+      ? commonJsObjectExpressionExportBindings(node.right).map((binding) => exportBindingEntry(input, nativeNodeId, undefined, binding))
+      : [])
+  ];
+}
+
+function commonJsObjectAssignExportExpressionEntries(node, nativeNodeId, input) {
+  const call = node.expression;
+  const kind = String(call?.type ?? call?.kind ?? '');
+  if (kind !== 'CallExpression') return [];
+  const callee = memberExpressionParts(call.callee);
+  if (callee?.objectName !== 'Object' || callee.propertyName !== 'assign') return [];
+  if (!commonJsObjectAssignExportTarget((call.arguments ?? [])[0])) return [];
+  return commonJsObjectExpressionExportBindings((call.arguments ?? [])[1])
+    .map((binding) => exportBindingEntry(input, nativeNodeId, undefined, binding));
+}
+
+function commonJsExportStarExpressionEntries(node, nativeNodeId, input) {
+  const call = node.expression;
+  const kind = String(call?.type ?? call?.kind ?? '');
+  if (kind !== 'CallExpression' || commonJsHelperName(call.callee) !== '__exportStar') return [];
+  if (!commonJsObjectAssignExportTarget((call.arguments ?? [])[1])) return [];
+  const moduleSpecifier = commonJsRequireModuleSpecifier((call.arguments ?? [])[0]);
+  if (!moduleSpecifier) return [];
+  const metadata = { commonJs: true, reexport: true, reExport: true, exportStar: true, importKind: 'reexport', interopHelper: commonJsHelperName(call.callee) };
+  return [
+    ...importModuleEntries(input, nativeNodeId, moduleSpecifier, [], metadata),
+    ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, [], { ...metadata, exportKind: 'export-star' })
+  ];
+}
+
+function commonJsCreateBindingReExportExpressionEntries(node, nativeNodeId, input) {
+  const call = node.expression;
+  const kind = String(call?.type ?? call?.kind ?? '');
+  if (kind !== 'CallExpression' || commonJsHelperName(call.callee) !== '__createBinding') return [];
+  if (!commonJsObjectAssignExportTarget((call.arguments ?? [])[0])) return [];
+  const moduleSpecifier = commonJsRequireModuleSpecifier((call.arguments ?? [])[1]);
+  const importedName = sourceValue((call.arguments ?? [])[2]);
+  const exportedName = sourceValue((call.arguments ?? [])[3]) ?? importedName;
+  if (!moduleSpecifier || !importedName || !exportedName || exportedName === '__esModule') return [];
+  const binding = {
+    localName: exportedName,
+    importedName,
+    exportedName,
+    importKind: 'reexport',
+    exportKind: 'named',
+    isTypeOnly: false,
+    reExport: true,
+    commonJs: true
+  };
+  const metadata = { commonJs: true, reexport: true, reExport: true, importKind: 'reexport', interopHelper: commonJsHelperName(call.callee) };
+  return [
+    ...importModuleEntries(input, nativeNodeId, moduleSpecifier, [binding], metadata),
+    ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, [binding], { ...metadata, exportKind: 'named' })
+  ];
+}
+
+function commonJsDefinePropertyExportExpressionEntries(node, nativeNodeId, input) {
+  const call = node.expression;
+  const kind = String(call?.type ?? call?.kind ?? '');
+  if (kind !== 'CallExpression') return [];
+  const callee = memberExpressionParts(call.callee);
+  if (callee?.objectName !== 'Object' || callee.propertyName !== 'defineProperty') return [];
+  if (!commonJsObjectAssignExportTarget((call.arguments ?? [])[0])) return [];
+  const exportedName = sourceValue((call.arguments ?? [])[1]);
+  if (!exportedName || exportedName === '__esModule') return [];
+  return [exportBindingEntry(input, nativeNodeId, undefined, {
+    localName: commonJsDescriptorLocalName((call.arguments ?? [])[2]),
+    exportedName,
+    exportKind: 'commonjs-named',
+    isTypeOnly: false,
+    commonJs: true
+  })];
+}
+
+function commonJsDefinePropertiesExportExpressionEntries(node, nativeNodeId, input) {
+  const call = node.expression;
+  const kind = String(call?.type ?? call?.kind ?? '');
+  if (kind !== 'CallExpression') return [];
+  const callee = memberExpressionParts(call.callee);
+  if (callee?.objectName !== 'Object' || callee.propertyName !== 'defineProperties') return [];
+  if (!commonJsObjectAssignExportTarget((call.arguments ?? [])[0])) return [];
+  return commonJsDefinePropertiesExportBindings((call.arguments ?? [])[1])
+    .map((binding) => exportBindingEntry(input, nativeNodeId, undefined, binding));
+}
+
+function commonJsDefinePropertiesExportBindings(node) {
+  const kind = String(node?.type ?? node?.kind ?? '');
+  if (kind !== 'ObjectExpression') return [];
+  return (node.properties ?? []).map(commonJsDefinePropertiesExportBinding).filter(Boolean);
+}
+
+function commonJsDefinePropertiesExportBinding(property) {
+  const kind = String(property?.type ?? property?.kind ?? '');
+  if (kind === 'SpreadElement' || kind === 'SpreadProperty') return undefined;
+  const exportedName = property.computed ? sourceValue(property.key) : memberPropertyName(property.key);
+  if (!exportedName || exportedName === '__esModule') return undefined;
+  return {
+    localName: commonJsDescriptorLocalName(property.value),
+    exportedName,
+    exportKind: 'commonjs-named',
+    isTypeOnly: false,
+    commonJs: true
+  };
+}
+
+function commonJsObjectAssignExportTarget(node) {
+  if (identifierName(node) === 'exports') return true;
+  const member = memberExpressionParts(node);
+  return member?.objectName === 'module' && member.propertyName === 'exports';
+}
+
+function commonJsRequireModuleSpecifier(node) {
+  if (!isCommonJsRequireCall(node)) return undefined;
+  return sourceValue((node.arguments ?? [])[0]);
+}
+
+function isCommonJsRequireCall(node) {
+  const kind = String(node?.type ?? node?.kind ?? '');
+  return kind === 'CallExpression' && identifierName(node.callee) === 'require' && Array.isArray(node.arguments) && node.arguments.length > 0;
+}
+
+function commonJsRequireBindings(pattern) {
+  const localName = identifierName(pattern);
+  if (localName) return [{ localName, importedName: 'default', importKind: 'commonjs-require', commonJs: true }];
+  const kind = String(pattern?.type ?? pattern?.kind ?? '');
+  if (kind !== 'ObjectPattern') return [];
+  return (pattern.properties ?? []).map(commonJsDestructuredRequireBinding).filter(Boolean);
+}
+
+function commonJsInteropHelperRequireBinding(node) {
+  const localName = identifierName(node.id);
+  const init = node.init;
+  const kind = String(init?.type ?? init?.kind ?? '');
+  const helper = commonJsHelperName(init?.callee);
+  if (!localName || kind !== 'CallExpression' || (helper !== '__importStar' && helper !== '__importDefault')) return undefined;
+  const moduleSpecifier = commonJsRequireModuleSpecifier((init.arguments ?? [])[0]);
+  if (!moduleSpecifier) return undefined;
+  const binding = helper === '__importStar'
+    ? { localName, importedName: '*', namespace: localName, importKind: 'namespace', commonJs: true }
+    : { localName, importedName: 'default', importKind: 'default', commonJs: true };
+  return {
+    moduleSpecifier,
+    binding,
+    metadata: { importKind: binding.importKind, commonJs: true, interopHelper: helper }
+  };
+}
+
+function commonJsHelperName(node) {
+  const direct = identifierName(node);
+  return direct ?? memberExpressionParts(node)?.propertyName;
+}
+
+function commonJsDestructuredRequireBinding(property) {
+  const kind = String(property?.type ?? property?.kind ?? '');
+  if (kind === 'RestElement' || kind === 'RestProperty') return undefined;
+  const importedName = memberPropertyName(property.key);
+  const localName = identifierName(property.value) ?? identifierName(property.argument) ?? importedName;
+  if (!importedName || !localName) return undefined;
+  return { localName, importedName, importKind: 'commonjs-require', commonJs: true };
+}
+
+function commonJsExportTarget(node) {
+  const member = memberExpressionParts(node);
+  if (!member) return undefined;
+  if (member.objectName === 'module' && member.propertyName === 'exports') {
+    return { exportedName: 'module.exports', exportKind: 'assignment' };
+  }
+  if (member.objectName === 'exports') {
+    return { exportedName: member.propertyName, exportKind: 'commonjs-named' };
+  }
+  const nestedObject = memberExpressionParts(member.objectNode);
+  if (nestedObject?.objectName === 'module' && nestedObject.propertyName === 'exports') {
+    return { exportedName: member.propertyName, exportKind: 'commonjs-named' };
+  }
+  return undefined;
+}
+
+function commonJsObjectExpressionExportBindings(node) {
+  const kind = String(node?.type ?? node?.kind ?? '');
+  if (kind !== 'ObjectExpression') return [];
+  return (node.properties ?? []).map(commonJsObjectExpressionExportBinding).filter(Boolean);
+}
+
+function commonJsObjectExpressionExportBinding(property) {
+  const kind = String(property?.type ?? property?.kind ?? '');
+  if (kind === 'SpreadElement' || kind === 'SpreadProperty') return undefined;
+  const exportedName = property.computed ? sourceValue(property.key) : memberPropertyName(property.key);
+  if (!exportedName || exportedName === '__esModule') return undefined;
+  return {
+    localName: property.shorthand ? exportedName : expressionExportLocalName(property.value),
+    exportedName,
+    exportKind: 'commonjs-named',
+    isTypeOnly: false,
+    commonJs: true
+  };
+}
+
+function commonJsDescriptorLocalName(node) {
+  const kind = String(node?.type ?? node?.kind ?? '');
+  if (kind !== 'ObjectExpression') return undefined;
+  for (const property of node.properties ?? []) {
+    const key = property.computed ? sourceValue(property.key) : memberPropertyName(property.key);
+    if (key === 'value') return expressionExportLocalName(property.value);
+    if (key === 'get') return returnExpressionLocalName(property.value);
+  }
+  return undefined;
+}
+
+function returnExpressionLocalName(node) {
+  const kind = String(node?.type ?? node?.kind ?? '');
+  if (kind === 'ArrowFunctionExpression') return returnBlockExpressionLocalName(node.body) ?? expressionExportLocalName(node.body);
+  if (kind !== 'FunctionExpression' && kind !== 'FunctionDeclaration') return undefined;
+  return returnBlockExpressionLocalName(node.body);
+}
+
+function returnBlockExpressionLocalName(node) {
+  const kind = String(node?.type ?? node?.kind ?? '');
+  if (kind !== 'BlockStatement') return undefined;
+  const statement = (node.body ?? []).find((entry) => String(entry?.type ?? entry?.kind ?? '') === 'ReturnStatement');
+  return expressionExportLocalName(statement?.argument);
+}
+
+function memberExpressionParts(node) {
+  const kind = String(node?.type ?? node?.kind ?? '');
+  if (kind !== 'MemberExpression' && kind !== 'OptionalMemberExpression') return undefined;
+  const objectName = expressionExportLocalName(node.object);
+  const propertyName = node.computed ? sourceValue(node.property) : memberPropertyName(node.property);
+  if (!objectName || !propertyName) return undefined;
+  return { objectName, propertyName, objectNode: node.object };
+}
+
+function memberPropertyName(node) {
+  return identifierName(node);
+}
+
+function expressionExportLocalName(node) {
+  const name = identifierName(node);
+  if (name) return name;
+  const member = memberExpressionParts(node);
+  return member ? `${member.objectName}.${member.propertyName}` : undefined;
+}