@knighted/module 1.0.0-beta.5 → 1.0.0-rc.1

package/README.md

@@ -139,7 +139,6 @@ See [docs/esm-to-cjs.md](docs/esm-to-cjs.md) for deeper notes on live bindings,
 
 ## Roadmap
 
-- Remove `@knighted/specifier` and avoid double parsing.
 - Emit source maps and clearer diagnostics for transform choices.
 - Broaden fixtures covering live-binding and top-level await edge cases across Node versions.
 - Benchmark scope analysis choices: compare `periscopic`, `scope-analyzer`, and `eslint-scope` on fixtures and pick the final adapter.

package/dist/assignmentExpression.d.cts

@@ -0,0 +1,12 @@
+import MagicString from 'magic-string';
+import type { Node, AssignmentExpression } from 'oxc-parser';
+import type { FormatterOptions, ExportsMeta } from '../types.cjs';
+type AssignmentExpressionArg = {
+    node: AssignmentExpression;
+    parent: Node | null;
+    code: MagicString;
+    opts: FormatterOptions;
+    meta: ExportsMeta;
+};
+export declare const assignmentExpression: ({ node, parent: _parent, code: _code, opts, meta: _meta, }: AssignmentExpressionArg) => Promise<void>;
+export {};

package/dist/cjs/helpers/scope.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scopes = exports.scope = void 0;
+const scopes = exports.scopes = ['BlockStatement', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassDeclaration', 'ClassExpression', 'ClassBody', 'StaticBlock'];
+const scope = exports.scope = {
+  isScope(node) {
+    return scopes.includes(node.type);
+  }
+};

package/dist/cjs/lang.d.cts

@@ -1,4 +1,3 @@
-import type { Specifier } from '@knighted/specifier';
-type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
-declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+import type { ParserOptions } from 'oxc-parser';
+declare const getLangFromExt: (filename: string) => ParserOptions["lang"] | undefined;
 export { getLangFromExt };

package/dist/cjs/module.cjs

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.transform = void 0;
 var _nodePath = require("node:path");
 var _promises = require("node:fs/promises");
-var _specifier = require("@knighted/specifier");
+var _specifier = require("./specifier.cjs");
 var _parse = require("#parse");
 var _format = require("#format");
 var _lang = require("#utils/lang.js");

package/dist/cjs/scope.d.cts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

package/dist/cjs/specifier.cjs

@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.specifier = void 0;
+var _nodePath = require("node:path");
+var _promises = require("node:fs/promises");
+var _magicString = _interopRequireDefault(require("magic-string"));
+var _oxcParser = require("oxc-parser");
+var _walk = require("#walk");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const isStringLiteral = node => {
+  return node.type === 'Literal' && typeof node.value === 'string';
+};
+const isBinaryExpression = node => {
+  // Distinguish between BinaryExpression and PrivateInExpression
+  return node.type === 'BinaryExpression' && node.operator !== 'in';
+};
+const isCallExpression = node => {
+  return node.type === 'CallExpression' && node.callee !== undefined;
+};
+const formatSpecifiers = async (src, ast, cb) => {
+  const code = new _magicString.default(src);
+  const formatExpression = expression => {
+    const node = isCallExpression(expression) ? expression.arguments[0] : expression.source;
+    const {
+      type
+    } = node;
+    switch (type) {
+      case 'Literal':
+        {
+          if (isStringLiteral(node)) {
+            const {
+              start,
+              end,
+              value
+            } = node;
+            const updated = cb({
+              type: 'StringLiteral',
+              parent: expression,
+              node,
+              start,
+              end,
+              value
+            });
+            if (typeof updated === 'string') {
+              code.update(start + 1, end - 1, updated);
+            }
+          }
+          break;
+        }
+      case 'TemplateLiteral':
+        {
+          const {
+            start,
+            end
+          } = node;
+          const value = src.slice(start + 1, end - 1);
+          const updated = cb({
+            type: 'TemplateLiteral',
+            parent: expression,
+            node,
+            start,
+            end,
+            value
+          });
+          if (typeof updated === 'string') {
+            code.update(start + 1, end - 1, updated);
+          }
+          break;
+        }
+      case 'BinaryExpression':
+        {
+          if (isBinaryExpression(node)) {
+            const {
+              start,
+              end
+            } = node;
+            const value = src.slice(start, end);
+            const updated = cb({
+              type: 'BinaryExpression',
+              parent: expression,
+              node,
+              start,
+              end,
+              value
+            });
+            if (typeof updated === 'string') {
+              code.update(start, end, updated);
+            }
+          }
+          break;
+        }
+      case 'NewExpression':
+        {
+          if (node.callee.type === 'Identifier' && node.callee.name === 'String') {
+            const {
+              start,
+              end
+            } = node;
+            const value = src.slice(start, end);
+            const updated = cb({
+              type: 'NewExpression',
+              parent: expression,
+              node,
+              start,
+              end,
+              value
+            });
+            if (typeof updated === 'string') {
+              code.update(start, end, updated);
+            }
+          }
+          break;
+        }
+    }
+  };
+  await (0, _walk.walk)(ast.program, {
+    enter(node) {
+      if (node.type === 'ExpressionStatement') {
+        const {
+          expression
+        } = node;
+        if (expression.type === 'ImportExpression') {
+          formatExpression(expression);
+        }
+      }
+      if (node.type === 'CallExpression') {
+        // Handle require(), require.resolve(), import.meta.resolve()
+        if (node.callee.type === 'Identifier' && node.callee.name === 'require' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.object.name === 'require' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'MetaProperty' && node.callee.object.meta.name === 'import' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve') {
+          formatExpression(node);
+        }
+      }
+      if (node.type === 'ArrowFunctionExpression') {
+        const {
+          body
+        } = node;
+        if (body.type === 'ImportExpression') {
+          formatExpression(body);
+        }
+        if (body.type === 'CallExpression' && body.callee.type === 'Identifier' && body.callee.name === 'require') {
+          formatExpression(body);
+        }
+      }
+      if (node.type === 'MemberExpression' && node.object.type === 'ImportExpression' && node.property.type === 'Identifier' && node.property.name === 'then') {
+        formatExpression(node.object);
+      }
+      if (node.type === 'TSImportType') {
+        const source = node.source;
+        if (source && isStringLiteral(source)) {
+          const {
+            start,
+            end,
+            value
+          } = source;
+          const updated = cb({
+            type: 'StringLiteral',
+            node: source,
+            parent: node,
+            start,
+            end,
+            value
+          });
+          if (typeof updated === 'string') {
+            code.update(start + 1, end - 1, updated);
+          }
+        }
+      }
+      if (node.type === 'ImportDeclaration') {
+        const {
+          source
+        } = node;
+        const {
+          start,
+          end,
+          value
+        } = source;
+        const updated = cb({
+          type: 'StringLiteral',
+          node: source,
+          parent: node,
+          start,
+          end,
+          value
+        });
+        if (typeof updated === 'string') {
+          code.update(start + 1, end - 1, updated);
+        }
+      }
+      if (node.type === 'ExportNamedDeclaration' && node.source) {
+        const {
+          source
+        } = node;
+        const {
+          start,
+          end,
+          value
+        } = source;
+        const updated = cb({
+          type: 'StringLiteral',
+          node: source,
+          parent: node,
+          start,
+          end,
+          value
+        });
+        if (typeof updated === 'string') {
+          code.update(start + 1, end - 1, updated);
+        }
+      }
+      if (node.type === 'ExportAllDeclaration') {
+        const {
+          source
+        } = node;
+        const {
+          start,
+          end,
+          value
+        } = source;
+        const updated = cb({
+          type: 'StringLiteral',
+          node: source,
+          parent: node,
+          start,
+          end,
+          value
+        });
+        if (typeof updated === 'string') {
+          code.update(start + 1, end - 1, updated);
+        }
+      }
+    }
+  });
+  return code.toString();
+};
+const isValidFilename = async filename => {
+  let stats;
+  try {
+    stats = await (0, _promises.stat)(filename);
+  } catch {
+    return false;
+  }
+  if (!stats.isFile()) {
+    return false;
+  }
+  return true;
+};
+const specifier = exports.specifier = {
+  async update(path, callback) {
+    const filename = (0, _nodePath.resolve)(path);
+    const validated = await isValidFilename(filename);
+    if (!validated) {
+      throw new Error(`The provided path ${path} does not resolve to a file on disk.`);
+    }
+    const src = (await (0, _promises.readFile)(filename)).toString();
+    const ast = (0, _oxcParser.parseSync)(filename, src);
+    return await formatSpecifiers(src, ast, callback);
+  },
+  async updateSrc(src, lang, callback) {
+    const filename = lang === 'ts' ? 'file.ts' : lang === 'tsx' ? 'file.tsx' : lang === 'js' ? 'file.js' : 'file.jsx';
+    const ast = (0, _oxcParser.parseSync)(filename, src);
+    return await formatSpecifiers(src, ast, callback);
+  }
+};

package/dist/cjs/specifier.d.cts

@@ -0,0 +1,16 @@
+import type { ParserOptions, StringLiteral, TemplateLiteral, BinaryExpression, NewExpression, ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, TSImportType, ImportExpression, CallExpression } from 'oxc-parser';
+type Spec = {
+    type: 'StringLiteral' | 'TemplateLiteral' | 'BinaryExpression' | 'NewExpression';
+    node: StringLiteral | TemplateLiteral | BinaryExpression | NewExpression;
+    parent: CallExpression | ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression | TSImportType;
+    start: number;
+    end: number;
+    value: string;
+};
+type Callback = (spec: Spec) => string | void;
+declare const specifier: {
+    update(path: string, callback: Callback): Promise<string>;
+    updateSrc(src: string, lang: ParserOptions["lang"], callback: Callback): Promise<string>;
+};
+export { specifier };
+export type { Spec, Callback };

package/dist/cjs/utils/lang.cjs

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.getLangFromExt = void 0;
 var _nodePath = require("node:path");
 // Determine language from filename extension for specifier rewrite.
-
 const getLangFromExt = filename => {
   const ext = (0, _nodePath.extname)(filename).toLowerCase();
   if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {

package/dist/cjs/utils.cjs

@@ -3,27 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.requireMainRgx = exports.isValidUrl = exports.getLangFromExt = exports.exportsRename = exports.collectScopeIdentifiers = exports.collectModuleIdentifiers = exports.collectCjsExports = void 0;
-var _nodePath = require("node:path");
+exports.requireMainRgx = exports.isValidUrl = exports.exportsRename = exports.collectScopeIdentifiers = exports.collectModuleIdentifiers = exports.collectCjsExports = void 0;
 var _walk = require("./walk.cjs");
 var _identifier = require("./helpers/identifier.cjs");
 var _scopeNodes = require("./utils/scopeNodes.cjs");
-const getLangFromExt = filename => {
-  const ext = (0, _nodePath.extname)(filename).toLowerCase();
-  if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
-    return 'js';
-  }
-  if (ext === '.ts' || ext === '.mts' || ext === '.cts') {
-    return 'ts';
-  }
-  if (ext === '.tsx') {
-    return 'tsx';
-  }
-  if (ext === '.jsx') {
-    return 'jsx';
-  }
-};
-exports.getLangFromExt = getLangFromExt;
 const isValidUrl = url => {
   try {
     new URL(url);

package/dist/cjs/utils.d.cts

@@ -1,8 +1,5 @@
 import type { Node } from 'oxc-parser';
-import type { Specifier } from '@knighted/specifier';
 import type { IdentMeta, Scope, CjsExport } from './types.cjs';
-type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
-declare const getLangFromExt: (filename: string) => UpdateSrcLang;
 declare const isValidUrl: (url: string) => boolean;
 declare const exportsRename = "__exports";
 declare const requireMainRgx: RegExp;
@@ -23,4 +20,4 @@ declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
  * which are also valid module scope identifiers.
  */
 declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
-export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };
+export { isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/exports.d.cts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+import type { CjsExport } from '../types.cjs';
+declare const exportsRename = "__exports";
+declare const requireMainRgx: RegExp;
+declare const collectCjsExports: (ast: Node) => Promise<Map<string, CjsExport>>;
+export { exportsRename, requireMainRgx, collectCjsExports };

package/dist/expressionStatement.d.cts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { Node, ExpressionStatement } from 'oxc-parser';
+import type { FormatterOptions } from '../types.cjs';
+export declare const expressionStatement: (node: ExpressionStatement, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/format.d.cts

@@ -0,0 +1,9 @@
+import type { ParseResult } from 'oxc-parser';
+import type { FormatterOptions } from './types.cjs';
+/**
+ * Node added support for import.meta.main.
+ * Added in: v24.2.0, v22.18.0
+ * @see https://nodejs.org/api/esm.html#importmetamain
+ */
+declare const format: (src: string, ast: ParseResult, opts: FormatterOptions) => Promise<string>;
+export { format };

package/dist/formatters/assignmentExpression.d.ts

@@ -0,0 +1,12 @@
+import MagicString from 'magic-string';
+import type { Node, AssignmentExpression } from 'oxc-parser';
+import type { FormatterOptions, ExportsMeta } from '../types.js';
+type AssignmentExpressionArg = {
+    node: AssignmentExpression;
+    parent: Node | null;
+    code: MagicString;
+    opts: FormatterOptions;
+    meta: ExportsMeta;
+};
+export declare const assignmentExpression: ({ node, parent: _parent, code: _code, opts, meta: _meta, }: AssignmentExpressionArg) => Promise<void>;
+export {};

package/dist/formatters/expressionStatement.d.ts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { Node, ExpressionStatement } from 'oxc-parser';
+import type { FormatterOptions } from '../types.js';
+export declare const expressionStatement: (node: ExpressionStatement, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/formatters/identifier.d.ts

@@ -0,0 +1,12 @@
+import MagicString from 'magic-string';
+import type { Node, IdentifierName } from 'oxc-parser';
+import type { FormatterOptions, ExportsMeta } from '../types.js';
+type IdentifierArg = {
+    node: IdentifierName;
+    ancestors: Node[];
+    code: MagicString;
+    opts: FormatterOptions;
+    meta: ExportsMeta;
+};
+export declare const identifier: ({ node, ancestors, code, opts, meta }: IdentifierArg) => void;
+export {};

package/dist/formatters/memberExpression.d.ts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { MemberExpression, Node } from 'oxc-parser';
+import type { FormatterOptions } from '../types.js';
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/formatters/metaProperty.d.ts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { Node, MetaProperty } from 'oxc-parser';
+import type { FormatterOptions } from '../types.js';
+export declare const metaProperty: (node: MetaProperty, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/helpers/identifier.d.ts

@@ -0,0 +1,31 @@
+import type { Node, IdentifierName } from 'oxc-parser';
+/**
+ * Focus exclusively on IdentifierName type as it has the name property,
+ * which is what the identifer utilities are interested in.
+ *
+ * Explicitly ignore the TSThisParameter type as it is not a valid identifier name.
+ */
+declare const isIdentifierName: (node: Node) => node is IdentifierName;
+/**
+ * All methods receive the full set of ancestors, which
+ * specifically includes the node itself as the last element.
+ * The second to last element is the parent node, and so on.
+ * The first element is the root node.
+ */
+declare const identifier: {
+    isNamed: (node: Node) => node is IdentifierName;
+    isMetaProperty(ancestors: Node[]): boolean;
+    isModuleScope(ancestors: Node[], includeImports?: boolean): boolean;
+    isMemberExpressionRoot(ancestors: Node[]): boolean;
+    isDeclaration(ancestors: Node[]): boolean;
+    isClassOrFuncDeclarationId(ancestors: Node[]): boolean;
+    isVarDeclarationInGlobalScope(ancestors: Node[]): boolean;
+    isIife(ancestors: Node[]): boolean;
+    isFunctionExpressionId(ancestors: Node[]): boolean;
+    isExportSpecifierAlias(ancestors: Node[]): boolean;
+    isClassPropertyKey(ancestors: Node[]): boolean;
+    isMethodDefinitionKey(ancestors: Node[]): boolean;
+    isMemberKey(ancestors: Node[]): boolean;
+    isPropertyKey(ancestors: Node[]): boolean;
+};
+export { identifier, isIdentifierName };

package/dist/helpers/scope.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

package/dist/helpers/scope.js

@@ -0,0 +1,7 @@
+const scopes = ['BlockStatement', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassDeclaration', 'ClassExpression', 'ClassBody', 'StaticBlock'];
+const scope = {
+  isScope(node) {
+    return scopes.includes(node.type);
+  }
+};
+export { scopes, scope };

package/dist/identifier.d.cts

@@ -0,0 +1,31 @@
+import type { Node, IdentifierName } from 'oxc-parser';
+/**
+ * Focus exclusively on IdentifierName type as it has the name property,
+ * which is what the identifer utilities are interested in.
+ *
+ * Explicitly ignore the TSThisParameter type as it is not a valid identifier name.
+ */
+declare const isIdentifierName: (node: Node) => node is IdentifierName;
+/**
+ * All methods receive the full set of ancestors, which
+ * specifically includes the node itself as the last element.
+ * The second to last element is the parent node, and so on.
+ * The first element is the root node.
+ */
+declare const identifier: {
+    isNamed: (node: Node) => node is IdentifierName;
+    isMetaProperty(ancestors: Node[]): boolean;
+    isModuleScope(ancestors: Node[], includeImports?: boolean): boolean;
+    isMemberExpressionRoot(ancestors: Node[]): boolean;
+    isDeclaration(ancestors: Node[]): boolean;
+    isClassOrFuncDeclarationId(ancestors: Node[]): boolean;
+    isVarDeclarationInGlobalScope(ancestors: Node[]): boolean;
+    isIife(ancestors: Node[]): boolean;
+    isFunctionExpressionId(ancestors: Node[]): boolean;
+    isExportSpecifierAlias(ancestors: Node[]): boolean;
+    isClassPropertyKey(ancestors: Node[]): boolean;
+    isMethodDefinitionKey(ancestors: Node[]): boolean;
+    isMemberKey(ancestors: Node[]): boolean;
+    isPropertyKey(ancestors: Node[]): boolean;
+};
+export { identifier, isIdentifierName };

package/dist/identifiers.d.cts

@@ -0,0 +1,19 @@
+import type { Node } from 'oxc-parser';
+import type { IdentMeta, Scope } from '../types.cjs';
+declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
+/**
+ * Collects all module scope identifiers in the AST.
+ *
+ * Ignores identifiers that are in functions or classes.
+ * Ignores new scopes for StaticBlock nodes (can only reference static class members).
+ *
+ * Special case handling for these which create their own scopes,
+ * but are also valid module scope identifiers:
+ * - ClassDeclaration
+ * - FunctionDeclaration
+ *
+ * Special case handling for var inside BlockStatement
+ * which are also valid module scope identifiers.
+ */
+declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
+export { collectScopeIdentifiers, collectModuleIdentifiers };

package/dist/lang.d.cts

@@ -0,0 +1,3 @@
+import type { ParserOptions } from 'oxc-parser';
+declare const getLangFromExt: (filename: string) => ParserOptions["lang"] | undefined;
+export { getLangFromExt };

package/dist/lang.d.ts

@@ -1,4 +1,3 @@
-import type { Specifier } from '@knighted/specifier';
-type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
-declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+import type { ParserOptions } from 'oxc-parser';
+declare const getLangFromExt: (filename: string) => ParserOptions["lang"] | undefined;
 export { getLangFromExt };

package/dist/memberExpression.d.cts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { MemberExpression, Node } from 'oxc-parser';
+import type { FormatterOptions } from '../types.cjs';
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions, shadowed?: Set<string>) => void;

package/dist/metaProperty.d.cts

@@ -0,0 +1,4 @@
+import MagicString from 'magic-string';
+import type { Node, MetaProperty } from 'oxc-parser';
+import type { FormatterOptions } from '../types.cjs';
+export declare const metaProperty: (node: MetaProperty, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/module.d.cts

@@ -0,0 +1,3 @@
+import type { ModuleOptions } from './types.cjs';
+declare const transform: (filename: string, options?: ModuleOptions) => Promise<string>;
+export { transform };

package/dist/module.js

@@ -1,6 +1,6 @@
 import { resolve } from 'node:path';
 import { readFile, writeFile } from 'node:fs/promises';
-import { specifier } from '@knighted/specifier';
+import { specifier } from './specifier.js';
 import { parse } from '#parse';
 import { format } from '#format';
 import { getLangFromExt } from '#utils/lang.js';

package/dist/parse.d.cts

@@ -0,0 +1,2 @@
+declare const parse: (filename: string, code: string) => import("oxc-parser").ParseResult;
+export { parse };

package/dist/scope.d.cts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

package/dist/scope.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

package/dist/scopeNodes.d.cts

@@ -0,0 +1,2 @@
+declare const scopeNodes: string[];
+export { scopeNodes };

package/dist/specifier.d.cts

@@ -0,0 +1,16 @@
+import type { ParserOptions, StringLiteral, TemplateLiteral, BinaryExpression, NewExpression, ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, TSImportType, ImportExpression, CallExpression } from 'oxc-parser';
+type Spec = {
+    type: 'StringLiteral' | 'TemplateLiteral' | 'BinaryExpression' | 'NewExpression';
+    node: StringLiteral | TemplateLiteral | BinaryExpression | NewExpression;
+    parent: CallExpression | ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression | TSImportType;
+    start: number;
+    end: number;
+    value: string;
+};
+type Callback = (spec: Spec) => string | void;
+declare const specifier: {
+    update(path: string, callback: Callback): Promise<string>;
+    updateSrc(src: string, lang: ParserOptions["lang"], callback: Callback): Promise<string>;
+};
+export { specifier };
+export type { Spec, Callback };

package/dist/specifier.d.ts

@@ -0,0 +1,16 @@
+import type { ParserOptions, StringLiteral, TemplateLiteral, BinaryExpression, NewExpression, ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, TSImportType, ImportExpression, CallExpression } from 'oxc-parser';
+type Spec = {
+    type: 'StringLiteral' | 'TemplateLiteral' | 'BinaryExpression' | 'NewExpression';
+    node: StringLiteral | TemplateLiteral | BinaryExpression | NewExpression;
+    parent: CallExpression | ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression | TSImportType;
+    start: number;
+    end: number;
+    value: string;
+};
+type Callback = (spec: Spec) => string | void;
+declare const specifier: {
+    update(path: string, callback: Callback): Promise<string>;
+    updateSrc(src: string, lang: ParserOptions["lang"], callback: Callback): Promise<string>;
+};
+export { specifier };
+export type { Spec, Callback };

package/dist/specifier.js

@@ -0,0 +1,259 @@
+import { resolve } from 'node:path';
+import { stat, readFile } from 'node:fs/promises';
+import MagicString from 'magic-string';
+import { parseSync } from 'oxc-parser';
+import { walk } from '#walk';
+const isStringLiteral = node => {
+  return node.type === 'Literal' && typeof node.value === 'string';
+};
+const isBinaryExpression = node => {
+  // Distinguish between BinaryExpression and PrivateInExpression
+  return node.type === 'BinaryExpression' && node.operator !== 'in';
+};
+const isCallExpression = node => {
+  return node.type === 'CallExpression' && node.callee !== undefined;
+};
+const formatSpecifiers = async (src, ast, cb) => {
+  const code = new MagicString(src);
+  const formatExpression = expression => {
+    const node = isCallExpression(expression) ? expression.arguments[0] : expression.source;
+    const {
+      type
+    } = node;
+    switch (type) {
+      case 'Literal':
+        {
+          if (isStringLiteral(node)) {
+            const {
+              start,
+              end,
+              value
+            } = node;
+            const updated = cb({
+              type: 'StringLiteral',
+              parent: expression,
+              node,
+              start,
+              end,
+              value
+            });
+            if (typeof updated === 'string') {
+              code.update(start + 1, end - 1, updated);
+            }
+          }
+          break;
+        }
+      case 'TemplateLiteral':
+        {
+          const {
+            start,
+            end
+          } = node;
+          const value = src.slice(start + 1, end - 1);
+          const updated = cb({
+            type: 'TemplateLiteral',
+            parent: expression,
+            node,
+            start,
+            end,
+            value
+          });
+          if (typeof updated === 'string') {
+            code.update(start + 1, end - 1, updated);
+          }
+          break;
+        }
+      case 'BinaryExpression':
+        {
+          if (isBinaryExpression(node)) {
+            const {
+              start,
+              end
+            } = node;
+            const value = src.slice(start, end);
+            const updated = cb({
+              type: 'BinaryExpression',
+              parent: expression,
+              node,
+              start,
+              end,
+              value
+            });
+            if (typeof updated === 'string') {
+              code.update(start, end, updated);
+            }
+          }
+          break;
+        }
+      case 'NewExpression':
+        {
+          if (node.callee.type === 'Identifier' && node.callee.name === 'String') {
+            const {
+              start,
+              end
+            } = node;
+            const value = src.slice(start, end);
+            const updated = cb({
+              type: 'NewExpression',
+              parent: expression,
+              node,
+              start,
+              end,
+              value
+            });
+            if (typeof updated === 'string') {
+              code.update(start, end, updated);
+            }
+          }
+          break;
+        }
+    }
+  };
+  await walk(ast.program, {
+    enter(node) {
+      if (node.type === 'ExpressionStatement') {
+        const {
+          expression
+        } = node;
+        if (expression.type === 'ImportExpression') {
+          formatExpression(expression);
+        }
+      }
+      if (node.type === 'CallExpression') {
+        // Handle require(), require.resolve(), import.meta.resolve()
+        if (node.callee.type === 'Identifier' && node.callee.name === 'require' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.object.name === 'require' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'MetaProperty' && node.callee.object.meta.name === 'import' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve') {
+          formatExpression(node);
+        }
+      }
+      if (node.type === 'ArrowFunctionExpression') {
+        const {
+          body
+        } = node;
+        if (body.type === 'ImportExpression') {
+          formatExpression(body);
+        }
+        if (body.type === 'CallExpression' && body.callee.type === 'Identifier' && body.callee.name === 'require') {
+          formatExpression(body);
+        }
+      }
+      if (node.type === 'MemberExpression' && node.object.type === 'ImportExpression' && node.property.type === 'Identifier' && node.property.name === 'then') {
+        formatExpression(node.object);
+      }
+      if (node.type === 'TSImportType') {
+        const source = node.source;
+        if (source && isStringLiteral(source)) {
+          const {
+            start,
+            end,
+            value
+          } = source;
+          const updated = cb({
+            type: 'StringLiteral',
+            node: source,
+            parent: node,
+            start,
+            end,
+            value
+          });
+          if (typeof updated === 'string') {
+            code.update(start + 1, end - 1, updated);
+          }
+        }
+      }
+      if (node.type === 'ImportDeclaration') {
+        const {
+          source
+        } = node;
+        const {
+          start,
+          end,
+          value
+        } = source;
+        const updated = cb({
+          type: 'StringLiteral',
+          node: source,
+          parent: node,
+          start,
+          end,
+          value
+        });
+        if (typeof updated === 'string') {
+          code.update(start + 1, end - 1, updated);
+        }
+      }
+      if (node.type === 'ExportNamedDeclaration' && node.source) {
+        const {
+          source
+        } = node;
+        const {
+          start,
+          end,
+          value
+        } = source;
+        const updated = cb({
+          type: 'StringLiteral',
+          node: source,
+          parent: node,
+          start,
+          end,
+          value
+        });
+        if (typeof updated === 'string') {
+          code.update(start + 1, end - 1, updated);
+        }
+      }
+      if (node.type === 'ExportAllDeclaration') {
+        const {
+          source
+        } = node;
+        const {
+          start,
+          end,
+          value
+        } = source;
+        const updated = cb({
+          type: 'StringLiteral',
+          node: source,
+          parent: node,
+          start,
+          end,
+          value
+        });
+        if (typeof updated === 'string') {
+          code.update(start + 1, end - 1, updated);
+        }
+      }
+    }
+  });
+  return code.toString();
+};
+const isValidFilename = async filename => {
+  let stats;
+  try {
+    stats = await stat(filename);
+  } catch {
+    return false;
+  }
+  if (!stats.isFile()) {
+    return false;
+  }
+  return true;
+};
+const specifier = {
+  async update(path, callback) {
+    const filename = resolve(path);
+    const validated = await isValidFilename(filename);
+    if (!validated) {
+      throw new Error(`The provided path ${path} does not resolve to a file on disk.`);
+    }
+    const src = (await readFile(filename)).toString();
+    const ast = parseSync(filename, src);
+    return await formatSpecifiers(src, ast, callback);
+  },
+  async updateSrc(src, lang, callback) {
+    const filename = lang === 'ts' ? 'file.ts' : lang === 'tsx' ? 'file.tsx' : lang === 'js' ? 'file.js' : 'file.jsx';
+    const ast = parseSync(filename, src);
+    return await formatSpecifiers(src, ast, callback);
+  }
+};
+export { specifier };

package/dist/src/helpers/scope.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

package/dist/src/specifier.d.ts

@@ -0,0 +1,16 @@
+import type { ParserOptions, StringLiteral, TemplateLiteral, BinaryExpression, NewExpression, ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, TSImportType, ImportExpression, CallExpression } from 'oxc-parser';
+type Spec = {
+    type: 'StringLiteral' | 'TemplateLiteral' | 'BinaryExpression' | 'NewExpression';
+    node: StringLiteral | TemplateLiteral | BinaryExpression | NewExpression;
+    parent: CallExpression | ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression | TSImportType;
+    start: number;
+    end: number;
+    value: string;
+};
+type Callback = (spec: Spec) => string | void;
+declare const specifier: {
+    update(path: string, callback: Callback): Promise<string>;
+    updateSrc(src: string, lang: ParserOptions["lang"], callback: Callback): Promise<string>;
+};
+export { specifier };
+export type { Spec, Callback };

package/dist/src/utils/lang.d.ts

@@ -1,4 +1,3 @@
-import type { Specifier } from '@knighted/specifier';
-type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
-declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+import type { ParserOptions } from 'oxc-parser';
+declare const getLangFromExt: (filename: string) => ParserOptions["lang"] | undefined;
 export { getLangFromExt };

package/dist/src/utils.d.ts

@@ -1,8 +1,5 @@
 import type { Node } from 'oxc-parser';
-import type { Specifier } from '@knighted/specifier';
 import type { IdentMeta, Scope, CjsExport } from './types.js';
-type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
-declare const getLangFromExt: (filename: string) => UpdateSrcLang;
 declare const isValidUrl: (url: string) => boolean;
 declare const exportsRename = "__exports";
 declare const requireMainRgx: RegExp;
@@ -23,4 +20,4 @@ declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
  * which are also valid module scope identifiers.
  */
 declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
-export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };
+export { isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/types.d.cts

@@ -0,0 +1,44 @@
+import type { Node, Span, IdentifierName, IdentifierReference, BindingIdentifier, LabelIdentifier, TSIndexSignatureName } from 'oxc-parser';
+export type RewriteSpecifier = '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts' | ((value: string) => string | null | undefined);
+export type ModuleOptions = {
+    target: 'module' | 'commonjs';
+    sourceType?: 'auto' | 'module' | 'commonjs';
+    transformSyntax?: boolean;
+    liveBindings?: 'strict' | 'loose' | 'off';
+    rewriteSpecifier?: RewriteSpecifier;
+    dirFilename?: 'inject' | 'preserve' | 'error';
+    importMeta?: 'preserve' | 'shim' | 'error';
+    importMetaMain?: 'shim' | 'warn' | 'error';
+    requireSource?: 'builtin' | 'create-require';
+    cjsDefault?: 'module-exports' | 'auto' | 'none';
+    topLevelAwait?: 'error' | 'wrap' | 'preserve';
+    out?: string;
+    inPlace?: boolean;
+};
+export type SpannedNode = Node & Span;
+export type ExportsMeta = {
+    hasExportsBeenReassigned: boolean;
+    hasDefaultExportBeenReassigned: boolean;
+    hasDefaultExportBeenAssigned: boolean;
+    defaultExportValue: unknown;
+};
+export type CjsExport = {
+    key: string;
+    writes: SpannedNode[];
+    fromIdentifier?: string;
+    via: Set<'exports' | 'module.exports'>;
+    reassignments: SpannedNode[];
+    hasGetter?: boolean;
+};
+export type IdentMeta = {
+    declare: SpannedNode[];
+    read: SpannedNode[];
+};
+export type Scope = {
+    type: string;
+    name: string;
+    node: Node;
+    idents: Set<string>;
+};
+export type FormatterOptions = Omit<ModuleOptions, 'out' | 'inPlace'>;
+export type Identifier = IdentifierName | IdentifierReference | BindingIdentifier | LabelIdentifier | TSIndexSignatureName;

package/dist/url.d.cts

@@ -0,0 +1,2 @@
+declare const isValidUrl: (url: string) => boolean;
+export { isValidUrl };

package/dist/utils/lang.js

@@ -1,7 +1,5 @@
 import { extname } from 'node:path';
-
 // Determine language from filename extension for specifier rewrite.
-
 const getLangFromExt = filename => {
   const ext = extname(filename).toLowerCase();
   if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {

package/dist/utils.d.cts

@@ -0,0 +1,23 @@
+import type { Node } from 'oxc-parser';
+import type { IdentMeta, Scope, CjsExport } from './types.cjs';
+declare const isValidUrl: (url: string) => boolean;
+declare const exportsRename = "__exports";
+declare const requireMainRgx: RegExp;
+declare const collectCjsExports: (ast: Node) => Promise<Map<string, CjsExport>>;
+declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
+/**
+ * Collects all module scope identifiers in the AST.
+ *
+ * Ignores identifiers that are in functions or classes.
+ * Ignores new scopes for StaticBlock nodes (can only reference static class members).
+ *
+ * Special case handling for these which create their own scopes,
+ * but are also valid module scope identifiers:
+ * - ClassDeclaration
+ * - FunctionDeclaration
+ *
+ * Special case handling for var inside BlockStatement
+ * which are also valid module scope identifiers.
+ */
+declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
+export { isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/utils.d.ts

@@ -1,8 +1,5 @@
 import type { Node } from 'oxc-parser';
-import type { Specifier } from '@knighted/specifier';
 import type { IdentMeta, Scope, CjsExport } from './types.js';
-type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
-declare const getLangFromExt: (filename: string) => UpdateSrcLang;
 declare const isValidUrl: (url: string) => boolean;
 declare const exportsRename = "__exports";
 declare const requireMainRgx: RegExp;
@@ -23,4 +20,4 @@ declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
  * which are also valid module scope identifiers.
  */
 declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
-export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };
+export { isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/utils.js

@@ -1,22 +1,6 @@
-import { extname } from 'node:path';
 import { ancestorWalk } from './walk.js';
 import { identifier } from './helpers/identifier.js';
 import { scopeNodes } from './utils/scopeNodes.js';
-const getLangFromExt = filename => {
-  const ext = extname(filename).toLowerCase();
-  if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
-    return 'js';
-  }
-  if (ext === '.ts' || ext === '.mts' || ext === '.cts') {
-    return 'ts';
-  }
-  if (ext === '.tsx') {
-    return 'tsx';
-  }
-  if (ext === '.jsx') {
-    return 'jsx';
-  }
-};
 const isValidUrl = url => {
   try {
     new URL(url);
@@ -278,4 +262,4 @@ const collectModuleIdentifiers = async (ast, hoisting = true) => {
   });
   return identifiers;
 };
-export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx };
+export { isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx };

package/dist/walk.d.cts

@@ -0,0 +1,20 @@
+import type { Node } from 'oxc-parser';
+/**
+ * Using visitorKeys instead of oxc Visitor to keep
+ * an ancestor-aware enter/leave API with this.skip()
+ * without per-node method boilerplate.
+ */
+type AncestorContext = {
+    skip: () => void;
+};
+type AncestorVisitor = {
+    enter?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+};
+type WalkVisitor = {
+    enter?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+};
+declare const ancestorWalk: (node: Node, visitors: AncestorVisitor) => Promise<void>;
+declare const walk: (node: Node, visitors: WalkVisitor) => Promise<void>;
+export { ancestorWalk, walk };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/module",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-rc.1",
   "description": "Transforms differences between ES modules and CommonJS.",
   "type": "module",
   "main": "dist/module.js",
@@ -78,7 +78,6 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@knighted/specifier": "^2.0.9",
     "magic-string": "^0.30.21",
     "node-module-type": "^1.0.4",
     "oxc-parser": "^0.105.0",