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

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;
+}

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

@@ -1,8 +1,32 @@
-import{idFragment}from'../../native-import-utils.js';
-import{declarationRecord}from'./declarationRecord.js';
+import {
+  commonJsExpressionStatementEntries,
+  commonJsExportAssignmentEntries,
+  commonJsRequireVariableEntries
+} from './syntaxCommonJsModuleDeclarationEntries.js';
+import { dynamicImportExpressionMetadata } from './dynamicImportExpressionMetadata.js';
+import { hostModuleDependencyMetadata } from './importMetaUrlDependencyMetadata.js';
+import { moduleImportAttributeMetadata } from './moduleImportAttributeMetadata.js';
+import {
+  declarationName,
+  declarationTypeOnly,
+  exportBindingEntry,
+  exportModuleEntries,
+  identifierName,
+  importModuleEntries,
+  sourceValue
+} from './syntaxModuleEntryRecords.js';
+
+const UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER = '<dynamic-import>';
+
 export function syntaxModuleDeclarationEntries(node, nativeNodeId, input) {
   const kind = String(node.type ?? node.kind ?? '');
   if (kind === 'ImportDeclaration') return importDeclarationEntries(node, nativeNodeId, input);
+  if (kind === 'VariableDeclarator') return commonJsRequireVariableEntries(node, nativeNodeId, input);
+  if (kind === 'ExpressionStatement') return commonJsExpressionStatementEntries(node, nativeNodeId, input);
+  if (kind === 'AssignmentExpression') return commonJsExportAssignmentEntries(node, nativeNodeId, input);
+  if (kind === 'ImportExpression') return dynamicImportExpressionEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' && isDynamicImportCall(node)) return dynamicImportExpressionEntries(node, nativeNodeId, input);
+  if (kind === 'CallExpression' || kind === 'NewExpression') return hostModuleDependencyEntries(node, nativeNodeId, input);
   if (kind === 'ExportNamedDeclaration') return exportNamedDeclarationEntries(node, nativeNodeId, input);
   if (kind === 'ExportAllDeclaration') return exportAllDeclarationEntries(node, nativeNodeId, input);
   if (kind === 'ExportDefaultDeclaration') return exportDefaultDeclarationEntries(node, nativeNodeId, input);
@@ -17,10 +41,28 @@ function importDeclarationEntries(node, nativeNodeId, input) {
   return importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
     typeOnly,
     sideEffectOnly: bindings.length === 0,
-    importKind: bindings.length === 0 ? 'side-effect' : 'module'
+    importKind: bindings.length === 0 ? 'side-effect' : 'module',
+    ...moduleImportAttributeMetadata(node)
   });
 }
 
+function dynamicImportExpressionEntries(node, nativeNodeId, input) {
+  const importArgument = node.source ?? (node.arguments ?? [])[0];
+  if (!importArgument) return [];
+  const moduleSpecifier = sourceValue(importArgument) ?? UNKNOWN_DYNAMIC_IMPORT_MODULE_SPECIFIER;
+  return importModuleEntries(input, nativeNodeId, moduleSpecifier, [], {
+    importKind: 'dynamic-import',
+    dynamicImport: true,
+    ...dynamicImportExpressionMetadata(importArgument, moduleSpecifier),
+    ...moduleImportAttributeMetadata(node)
+  });
+}
+
+function hostModuleDependencyEntries(node, nativeNodeId, input) {
+  return hostModuleDependencyMetadata(node, { kind: String(node.type ?? node.kind ?? '') }).flatMap((dependency) =>
+    importModuleEntries(input, nativeNodeId, dependency.moduleSpecifier, [], dependency.metadata));
+}
+
 function exportNamedDeclarationEntries(node, nativeNodeId, input) {
   const moduleSpecifier = sourceValue(node.source);
   const typeOnly = node.exportKind === 'type';
@@ -32,12 +74,14 @@ function exportNamedDeclarationEntries(node, nativeNodeId, input) {
     ...(moduleSpecifier ? importModuleEntries(input, nativeNodeId, moduleSpecifier, reExportImportBindings(bindings), {
       typeOnly,
       reexport: true,
-      importKind: 'reexport'
+      importKind: 'reexport',
+      ...moduleImportAttributeMetadata(node)
     }) : []),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       reExport: Boolean(moduleSpecifier),
-      exportKind: typeOnly ? 'type-named' : 'named'
+      exportKind: typeOnly ? 'type-named' : 'named',
+      ...moduleImportAttributeMetadata(node)
     })
   ];
 }
@@ -62,13 +106,15 @@ function exportAllDeclarationEntries(node, nativeNodeId, input) {
       typeOnly,
       reexport: true,
       exportStar: !exportedName,
-      importKind: exportedName ? 'namespace-reexport' : 'reexport'
+      importKind: exportedName ? 'namespace-reexport' : 'reexport',
+      ...moduleImportAttributeMetadata(node)
     }),
     ...exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, {
       typeOnly,
       reExport: true,
       exportStar: !exportedName,
-      exportKind: exportedName ? 'namespace-reexport' : 'export-star'
+      exportKind: exportedName ? 'namespace-reexport' : 'export-star',
+      ...moduleImportAttributeMetadata(node)
     })
   ];
 }
@@ -151,129 +197,7 @@ function reExportImportBindings(bindings) {
   }));
 }
 
-function importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
-  return [{
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, moduleSpecifier, 'module', 'import'),
-      importPath: moduleSpecifier,
-      moduleSpecifier,
-      importKind: metadata.importKind,
-      isTypeOnly: metadata.typeOnly,
-      exportStar: metadata.exportStar,
-      metadata: moduleMetadata('syntax-import', bindings, metadata)
-    })
-  }, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
-}
-
-function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
-  return {
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, binding.localName, 'import', 'import'),
-      symbolId: `symbol:${input.language}:import:${idFragment(`${moduleSpecifier}:${binding.localName}:${binding.importedName}`)}`,
-      importPath: moduleSpecifier,
-      moduleSpecifier,
-      localName: binding.localName,
-      importedName: binding.importedName,
-      exportedName: binding.exportedName,
-      namespace: binding.namespace,
-      importKind: binding.importKind,
-      isTypeOnly: binding.isTypeOnly,
-      metadata: bindingMetadata('syntax-import-binding', moduleSpecifier, binding)
-    })
-  };
-}
-
-function exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
-  const statementName = metadata.exportStar
-    ? `* from ${moduleSpecifier}`
-    : moduleSpecifier ? `{${bindings.map((binding) => binding.exportedName).join(',')}} from ${moduleSpecifier}` : `{${bindings.map((binding) => binding.exportedName).join(',')}}`;
-  return [{
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, statementName, 'module', 'export'),
-      exportPath: moduleSpecifier,
-      moduleSpecifier,
-      exportKind: metadata.exportKind,
-      exportStar: metadata.exportStar,
-      isTypeOnly: metadata.typeOnly,
-      reExport: metadata.reExport,
-      publicContract: true,
-      metadata: moduleMetadata('syntax-export', bindings, metadata)
-    })
-  }, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding))];
-}
-
-function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding) {
-  return {
-    declaration: compactRecord({
-      ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
-      symbolId: `symbol:${input.language}:export:${idFragment(binding.exportedName)}`,
-      exportPath: moduleSpecifier,
-      moduleSpecifier,
-      localName: binding.localName,
-      importedName: binding.importedName,
-      exportedName: binding.exportedName,
-      namespace: binding.namespace,
-      exportKind: binding.exportKind,
-      isTypeOnly: binding.isTypeOnly,
-      reExport: binding.reExport,
-      publicContract: true,
-      metadata: bindingMetadata('syntax-export-binding', moduleSpecifier, binding, true)
-    })
-  };
-}
-
-function moduleMetadata(scan, bindings, metadata) {
-  return compactRecord({
-    scan,
-    moduleOnly: true,
-    bindingCount: bindings.length,
-    importKind: metadata.importKind,
-    exportKind: metadata.exportKind,
-    isTypeOnly: metadata.typeOnly,
-    typeOnly: metadata.typeOnly,
-    sideEffectOnly: metadata.sideEffectOnly,
-    reexport: metadata.reexport,
-    reExport: metadata.reExport,
-    exportStar: metadata.exportStar,
-    publicContract: metadata.reExport || metadata.exportKind
-  });
-}
-
-function bindingMetadata(scan, moduleSpecifier, binding, publicContract = false) {
-  return compactRecord({
-    scan,
-    moduleSpecifier,
-    importPath: moduleSpecifier,
-    exportPath: moduleSpecifier,
-    localName: binding.localName,
-    importedName: binding.importedName,
-    exportedName: binding.exportedName,
-    namespace: binding.namespace,
-    importKind: binding.importKind,
-    exportKind: binding.exportKind,
-    isTypeOnly: binding.isTypeOnly,
-    typeOnly: binding.isTypeOnly,
-    reExport: binding.reExport,
-    publicContract
-  });
-}
-
-function sourceValue(source) {
-  return typeof source?.value === 'string' ? source.value : undefined;
-}
-
-function identifierName(node) {
-  return typeof node?.name === 'string' ? node.name : typeof node?.value === 'string' ? node.value : undefined;
-}
-
-function declarationName(node) {
-  return identifierName(node?.id) ?? identifierName(node?.name);
-}
-
-function declarationTypeOnly(kind) {
-  return kind === 'TSInterfaceDeclaration' || kind === 'TSTypeAliasDeclaration' || kind === 'InterfaceDeclaration' || kind === 'TypeAliasDeclaration';
-}
-
-function compactRecord(record) {
-  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+function isDynamicImportCall(node) {
+  const calleeKind = String(node.callee?.type ?? node.callee?.kind ?? '');
+  return calleeKind === 'Import' || calleeKind === 'ImportKeyword' || identifierName(node.callee) === 'import';
 }

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

@@ -0,0 +1,160 @@
+import { idFragment } from '../../native-import-utils.js';
+import { declarationRecord } from './declarationRecord.js';
+
+export function importModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
+  return [{
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, moduleSpecifier, 'module', 'import'),
+      importPath: moduleSpecifier,
+      moduleSpecifier,
+      importKind: metadata.importKind,
+      isTypeOnly: metadata.typeOnly,
+      exportStar: metadata.exportStar,
+      metadata: moduleMetadata('syntax-import', bindings, metadata)
+    })
+  }, ...bindings.map((binding) => importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
+}
+
+export function importBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
+  return {
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, binding.localName, 'import', 'import'),
+      symbolId: `symbol:${input.language}:import:${idFragment(`${moduleSpecifier}:${binding.localName}:${binding.importedName}`)}`,
+      importPath: moduleSpecifier,
+      moduleSpecifier,
+      localName: binding.localName,
+      importedName: binding.importedName,
+      exportedName: binding.exportedName,
+      namespace: binding.namespace,
+      importKind: binding.importKind,
+      isTypeOnly: binding.isTypeOnly,
+      commonJs: binding.commonJs,
+      metadata: bindingMetadata('syntax-import-binding', moduleSpecifier, binding, false, metadata)
+    })
+  };
+}
+
+export function exportModuleEntries(input, nativeNodeId, moduleSpecifier, bindings, metadata) {
+  const statementName = metadata.exportStar
+    ? `* from ${moduleSpecifier}`
+    : moduleSpecifier ? `{${bindings.map((binding) => binding.exportedName).join(',')}} from ${moduleSpecifier}` : `{${bindings.map((binding) => binding.exportedName).join(',')}}`;
+  return [{
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, statementName, 'module', 'export'),
+      exportPath: moduleSpecifier,
+      moduleSpecifier,
+      exportKind: metadata.exportKind,
+      exportStar: metadata.exportStar,
+      isTypeOnly: metadata.typeOnly,
+      reExport: metadata.reExport,
+      publicContract: true,
+      metadata: moduleMetadata('syntax-export', bindings, metadata)
+    })
+  }, ...bindings.map((binding) => exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata))];
+}
+
+export function exportBindingEntry(input, nativeNodeId, moduleSpecifier, binding, metadata = {}) {
+  return {
+    declaration: compactRecord({
+      ...declarationRecord(input, nativeNodeId, binding.exportedName, 'export', 'export'),
+      symbolId: `symbol:${input.language}:export:${idFragment(binding.exportedName)}`,
+      exportPath: moduleSpecifier,
+      moduleSpecifier,
+      localName: binding.localName,
+      importedName: binding.importedName,
+      exportedName: binding.exportedName,
+      namespace: binding.namespace,
+      exportKind: binding.exportKind,
+      isTypeOnly: binding.isTypeOnly,
+      reExport: binding.reExport,
+      publicContract: true,
+      commonJs: binding.commonJs,
+      metadata: bindingMetadata('syntax-export-binding', moduleSpecifier, binding, true, metadata)
+    })
+  };
+}
+
+export function sourceValue(source) {
+  if (typeof source?.value === 'string') return source.value;
+  const kind = String(source?.type ?? source?.kind ?? '');
+  if (kind === 'TemplateLiteral' && (source.expressions ?? []).length === 0 && (source.quasis ?? []).length === 1) {
+    return source.quasis[0]?.value?.cooked ?? source.quasis[0]?.value?.raw;
+  }
+  return undefined;
+}
+
+export function identifierName(node) {
+  return typeof node?.name === 'string' ? node.name : typeof node?.value === 'string' ? node.value : undefined;
+}
+
+export function declarationName(node) {
+  return identifierName(node?.id) ?? identifierName(node?.name);
+}
+
+export function declarationTypeOnly(kind) {
+  return kind === 'TSInterfaceDeclaration' || kind === 'TSTypeAliasDeclaration' || kind === 'InterfaceDeclaration' || kind === 'TypeAliasDeclaration';
+}
+
+export function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function moduleMetadata(scan, bindings, metadata) {
+  return compactRecord({
+    scan,
+    moduleOnly: true,
+    bindingCount: bindings.length,
+    importKind: metadata.importKind,
+    exportKind: metadata.exportKind,
+    isTypeOnly: metadata.typeOnly,
+    typeOnly: metadata.typeOnly,
+    sideEffectOnly: metadata.sideEffectOnly,
+    dynamicImport: metadata.dynamicImport,
+    dynamicImportSpecifierKind: metadata.dynamicImportSpecifierKind,
+    dynamicImportExpressionText: metadata.dynamicImportExpressionText,
+    dynamicImportExpressionHash: metadata.dynamicImportExpressionHash,
+    dynamicImportStaticSpecifierEvidence: metadata.dynamicImportStaticSpecifierEvidence,
+    dynamicImportRuntimeResolutionClaim: metadata.dynamicImportRuntimeResolutionClaim,
+    dynamicImportResolutionProofRequired: metadata.dynamicImportResolutionProofRequired,
+    hostDependency: metadata.hostDependency,
+    hostDependencyKind: metadata.hostDependencyKind,
+    hostDependencyBase: metadata.hostDependencyBase,
+    hostDependencyExpressionText: metadata.hostDependencyExpressionText,
+    hostDependencyExpressionHash: metadata.hostDependencyExpressionHash,
+    hostDependencyStaticSpecifierEvidence: metadata.hostDependencyStaticSpecifierEvidence,
+    hostDependencyRuntimeResolutionClaim: metadata.hostDependencyRuntimeResolutionClaim,
+    hostDependencyResolutionProofRequired: metadata.hostDependencyResolutionProofRequired,
+    hasImportAttributes: metadata.hasImportAttributes,
+    importAttributeCount: metadata.importAttributeCount,
+    importAttributeKeys: metadata.importAttributeKeys,
+    importAttributeHash: metadata.importAttributeHash,
+    importAttributes: metadata.importAttributes,
+    commonJs: metadata.commonJs,
+    interopHelper: metadata.interopHelper,
+    reexport: metadata.reexport,
+    reExport: metadata.reExport,
+    exportStar: metadata.exportStar,
+    publicContract: metadata.reExport || metadata.exportKind
+  });
+}
+
+function bindingMetadata(scan, moduleSpecifier, binding, publicContract = false, metadata = {}) {
+  return compactRecord({
+    scan,
+    moduleSpecifier,
+    importPath: moduleSpecifier,
+    exportPath: moduleSpecifier,
+    localName: binding.localName,
+    importedName: binding.importedName,
+    exportedName: binding.exportedName,
+    namespace: binding.namespace,
+    importKind: binding.importKind,
+    exportKind: binding.exportKind,
+    isTypeOnly: binding.isTypeOnly,
+    typeOnly: binding.isTypeOnly,
+    reExport: binding.reExport,
+    publicContract, hasImportAttributes: metadata.hasImportAttributes, importAttributeCount: metadata.importAttributeCount, importAttributeKeys: metadata.importAttributeKeys, importAttributeHash: metadata.importAttributeHash, importAttributes: metadata.importAttributes,
+    commonJs: binding.commonJs,
+    interopHelper: binding.interopHelper ?? metadata.interopHelper
+  });
+}