@knighted/module 1.0.0-alpha.9 → 1.0.0-beta.1

package/dist/cjs/helpers/identifier.cjs

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIdentifierName = exports.identifier = void 0;
+var _periscopic = require("periscopic");
+/**
+ * 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.
+ */
+const isIdentifierName = node => {
+  return node.type === 'Identifier' && typeof node.name === 'string' && node.name !== 'this';
+};
+exports.isIdentifierName = isIdentifierName;
+const scopeCache = new WeakMap();
+const getScopeContext = program => {
+  const cached = scopeCache.get(program);
+  if (cached) {
+    return cached;
+  }
+  const {
+    scope
+  } = (0, _periscopic.analyze)(program);
+  const context = {
+    scope
+  };
+  scopeCache.set(program, context);
+  return context;
+};
+
+/**
+ * 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.
+ */
+const identifier = exports.identifier = {
+  isNamed: node => {
+    return isIdentifierName(node);
+  },
+  isMetaProperty(ancestors) {
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MetaProperty' || parent.type === 'MemberExpression' && parent.object.type === 'MetaProperty';
+  },
+  isModuleScope(ancestors, includeImports = false) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const program = ancestors[0];
+    if (!identifier.isNamed(node) || identifier.isMetaProperty(ancestors) || parent.type === 'LabeledStatement' || parent.type === 'BreakStatement' || parent.type === 'ContinueStatement') {
+      return false;
+    }
+    if (parent.type === 'ImportSpecifier' || parent.type === 'ImportDefaultSpecifier' || parent.type === 'ImportNamespaceSpecifier') {
+      return includeImports && parent.local.name === node.name;
+    }
+    if (parent.type === 'Property' && parent.key === node && !parent.computed) {
+      return false;
+    }
+    if (parent.type === 'MemberExpression' && parent.property === node && !parent.computed) {
+      return false;
+    }
+    const {
+      scope: rootScope
+    } = getScopeContext(program);
+    const owner = rootScope.find_owner(node.name);
+    if (!owner) {
+      return node.name === 'exports';
+    }
+    return owner === rootScope;
+  },
+  isMemberExpressionRoot(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const grandParent = ancestors[ancestors.length - 3];
+    return parent.type === 'MemberExpression' && parent.object === node && grandParent.type !== 'MemberExpression';
+  },
+  isDeclaration(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return (parent.type === 'VariableDeclarator' || parent.type === 'FunctionDeclaration' || parent.type === 'ClassDeclaration') && parent.id === node;
+  },
+  isClassOrFuncDeclarationId(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return (parent.type === 'ClassDeclaration' || parent.type === 'FunctionDeclaration') && parent.id === node && ancestors.length <= 3;
+  },
+  isVarDeclarationInGlobalScope(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const grandParent = ancestors[ancestors.length - 3];
+    const varBoundScopes = ['ClassDeclaration', 'ClassExpression', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
+    return parent.type === 'VariableDeclarator' && parent.id === node && grandParent.type === 'VariableDeclaration' && grandParent.kind === 'var' && ancestors.every(ancestor => {
+      return !varBoundScopes.includes(ancestor.type);
+    });
+  },
+  isIife(ancestors) {
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'FunctionExpression' && ancestors.some(ancestor => ancestor.type === 'ParenthesizedExpression');
+  },
+  isFunctionExpressionId(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'FunctionExpression' && parent.id === node;
+  },
+  isExportSpecifierAlias(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'ExportSpecifier' && parent.exported === node;
+  },
+  isClassPropertyKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'PropertyDefinition' && parent.key === node;
+  },
+  isMethodDefinitionKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MethodDefinition' && parent.key === node;
+  },
+  isMemberKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MemberExpression' && parent.property === node;
+  },
+  isPropertyKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'Property' && parent.key === node;
+  }
+};

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/identifier.d.cts

@@ -1,5 +1,31 @@
-import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { Identifier } from '@babel/types';
-import type { FormatterOptions } from '../types.cjs';
-export declare const identifier: (nodePath: NodePath<Identifier>, src: MagicString, options: FormatterOptions) => void;
+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/cjs/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/cjs/lang.d.cts

@@ -0,0 +1,4 @@
+import type { Specifier } from '@knighted/specifier';
+type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
+declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+export { getLangFromExt };

package/dist/cjs/memberExpression.d.cts

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

package/dist/cjs/metaProperty.d.cts

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

package/dist/cjs/module.cjs

@@ -7,28 +7,22 @@ exports.transform = void 0;
 var _nodePath = require("node:path");
 var _promises = require("node:fs/promises");
 var _specifier = require("@knighted/specifier");
-var _parse = require("./parse.cjs");
-var _format = require("./format.cjs");
+var _parse = require("#parse");
+var _format = require("#format");
+var _lang = require("#utils/lang.js");
 const defaultOptions = {
-  type: 'commonjs',
+  target: 'commonjs',
+  sourceType: 'auto',
+  transformSyntax: true,
+  liveBindings: 'strict',
+  rewriteSpecifier: undefined,
+  dirFilename: 'inject',
+  importMeta: 'shim',
+  requireSource: 'builtin',
+  cjsDefault: 'auto',
+  topLevelAwait: 'error',
   out: undefined,
-  modules: false,
-  specifier: undefined
-};
-const getLangFromExt = filename => {
-  const ext = (0, _nodePath.extname)(filename);
-  if (/\.js$/.test(ext)) {
-    return 'js';
-  }
-  if (/\.ts$/.test(ext)) {
-    return 'ts';
-  }
-  if (ext === '.tsx') {
-    return 'tsx';
-  }
-  if (ext === '.jsx') {
-    return 'jsx';
-  }
+  inPlace: false
 };
 const transform = async (filename, options = defaultOptions) => {
   const opts = {
@@ -37,24 +31,29 @@ const transform = async (filename, options = defaultOptions) => {
   };
   const file = (0, _nodePath.resolve)(filename);
   const code = (await (0, _promises.readFile)(file)).toString();
-  const ast = (0, _parse.parse)(code);
-  let source = (0, _format.format)(code, ast, opts).toString();
-  if (options.specifier) {
-    const code = await _specifier.specifier.updateSrc(source, getLangFromExt(filename), ({
+  const ast = (0, _parse.parse)(filename, code);
+  let source = await (0, _format.format)(code, ast, opts);
+  if (opts.rewriteSpecifier) {
+    const code = await _specifier.specifier.updateSrc(source, (0, _lang.getLangFromExt)(filename), ({
       value
     }) => {
+      if (typeof opts.rewriteSpecifier === 'function') {
+        return opts.rewriteSpecifier(value) ?? undefined;
+      }
+
       // Collapse any BinaryExpression or NewExpression to test for a relative specifier
       const collapsed = value.replace(/['"`+)\s]|new String\(/g, '');
       const relative = /^(?:\.|\.\.)\//;
       if (relative.test(collapsed)) {
         // $2 is for any closing quotation/parens around BE or NE
-        return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"`]*)?$/, `$1${options.specifier}$2`);
+        return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"]*)?$/, `$1${opts.rewriteSpecifier}$2`);
       }
     });
     source = code;
   }
-  if (opts.out) {
-    await (0, _promises.writeFile)((0, _nodePath.resolve)(opts.out), source);
+  const outputPath = opts.inPlace ? file : opts.out ? (0, _nodePath.resolve)(opts.out) : undefined;
+  if (outputPath) {
+    await (0, _promises.writeFile)(outputPath, source);
   }
   return source;
 };

package/dist/cjs/parse.cjs

@@ -4,19 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parse = void 0;
-var _parser = require("@babel/parser");
-const parse = (source, dts = false) => {
-  const ast = (0, _parser.parse)(source, {
-    sourceType: 'module',
-    allowAwaitOutsideFunction: true,
-    allowReturnOutsideFunction: true,
-    allowImportExportEverywhere: true,
-    plugins: ['jsx', ['importAttributes', {
-      deprecatedAssertSyntax: true
-    }], ['typescript', {
-      dts
-    }]]
-  });
-  return ast;
+var _oxcParser = require("oxc-parser");
+const parse = (filename, code) => {
+  return (0, _oxcParser.parseSync)(filename, code);
 };
 exports.parse = parse;

package/dist/cjs/parse.d.cts

@@ -1,2 +1,2 @@
-declare const parse: (source: string, dts?: boolean) => import("@babel/parser").ParseResult<import("@babel/types").File>;
+declare const parse: (filename: string, code: string) => import("oxc-parser").ParseResult;
 export { parse };

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/types.d.cts

@@ -1,7 +1,43 @@
+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 = {
-    type?: 'module' | 'commonjs';
-    modules?: boolean;
-    specifier?: '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts';
+    target: 'module' | 'commonjs';
+    sourceType?: 'auto' | 'module' | 'commonjs';
+    transformSyntax?: boolean;
+    liveBindings?: 'strict' | 'loose' | 'off';
+    rewriteSpecifier?: RewriteSpecifier;
+    dirFilename?: 'inject' | 'preserve' | 'error';
+    importMeta?: 'preserve' | 'shim' | 'error';
+    requireSource?: 'builtin' | 'create-require';
+    cjsDefault?: 'module-exports' | 'auto' | 'none';
+    topLevelAwait?: 'error' | 'wrap' | 'preserve';
     out?: string;
+    inPlace?: boolean;
 };
-export type FormatterOptions = Omit<ModuleOptions, 'out'> & Required<Pick<ModuleOptions, 'type'>>;
+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/cjs/url.d.cts

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

package/dist/cjs/utils/exports.cjs

@@ -0,0 +1,227 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireMainRgx = exports.exportsRename = exports.collectCjsExports = void 0;
+var _walk = require("#walk");
+const exportsRename = exports.exportsRename = '__exports';
+const requireMainRgx = exports.requireMainRgx = /(require\.main\s*===\s*module|module\s*===\s*require\.main)/g;
+const literalPropName = (prop, literals) => {
+  if (prop.type === 'Identifier') return literals?.get(prop.name)?.toString() ?? prop.name;
+  if (prop.type === 'Literal' && (typeof prop.value === 'string' || typeof prop.value === 'number')) {
+    return String(prop.value);
+  }
+  if (prop.type === 'TemplateLiteral' && prop.expressions.length === 0 && prop.quasis.length === 1) {
+    return prop.quasis[0].value.cooked ?? prop.quasis[0].value.raw;
+  }
+  return null;
+};
+const resolveExportTarget = (node, aliases, literals) => {
+  if (node.type === 'Identifier' && node.name === 'exports') {
+    return {
+      key: 'default',
+      via: 'exports'
+    };
+  }
+  if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'module' && node.property.type === 'Identifier' && node.property.name === 'exports') {
+    return {
+      key: 'default',
+      via: 'module.exports'
+    };
+  }
+  if (node.type !== 'MemberExpression') return null;
+  const base = node.object;
+  const prop = node.property;
+  const key = literalPropName(prop, literals);
+  if (!key) return null;
+  const baseVia = resolveBase(base, aliases);
+  if (!baseVia) return null;
+  if (baseVia === 'module.exports' && key === 'exports') {
+    return {
+      key: 'default',
+      via: 'module.exports'
+    };
+  }
+  return {
+    key,
+    via: baseVia
+  };
+};
+const resolveBase = (node, aliases) => {
+  if (node.type === 'Identifier') {
+    if (node.name === 'exports') return 'exports';
+    const alias = aliases.get(node.name);
+    if (alias) return alias;
+  }
+  if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'module' && node.property.type === 'Identifier' && node.property.name === 'exports') {
+    return 'module.exports';
+  }
+  return null;
+};
+const collectCjsExports = async ast => {
+  const exportsMap = new Map();
+  const localToExport = new Map();
+  const aliases = new Map();
+  const literals = new Map();
+  const addExport = (ref, node, rhs, options) => {
+    const entry = exportsMap.get(ref.key) ?? {
+      key: ref.key,
+      writes: [],
+      via: new Set(),
+      reassignments: []
+    };
+    entry.via.add(ref.via);
+    entry.writes.push(node);
+    if (options?.hasGetter) {
+      entry.hasGetter = true;
+    }
+    if (rhs) {
+      entry.fromIdentifier ??= rhs.name;
+      const set = localToExport.get(rhs.name) ?? new Set();
+      set.add(ref.key);
+      localToExport.set(rhs.name, set);
+    }
+    exportsMap.set(ref.key, entry);
+  };
+  await (0, _walk.ancestorWalk)(ast, {
+    enter(node) {
+      if (node.type === 'VariableDeclarator' && node.id.type === 'Identifier' && node.init) {
+        const via = resolveBase(node.init, aliases);
+        if (via) {
+          aliases.set(node.id.name, via);
+        }
+        if (node.init.type === 'Literal' && (typeof node.init.value === 'string' || typeof node.init.value === 'number')) {
+          literals.set(node.id.name, node.init.value);
+        }
+        if (node.init.type === 'TemplateLiteral' && node.init.expressions.length === 0 && node.init.quasis.length === 1) {
+          const cooked = node.init.quasis[0].value.cooked ?? node.init.quasis[0].value.raw;
+          literals.set(node.id.name, cooked);
+        }
+      }
+      if (node.type === 'AssignmentExpression') {
+        const target = resolveExportTarget(node.left, aliases, literals);
+        if (target) {
+          const rhsIdent = node.right.type === 'Identifier' ? node.right : undefined;
+          addExport(target, node, rhsIdent);
+          return;
+        }
+        if (node.left.type === 'Identifier') {
+          const keys = localToExport.get(node.left.name);
+          if (keys) {
+            keys.forEach(key => {
+              const entry = exportsMap.get(key);
+              if (entry) {
+                entry.reassignments.push(node);
+                exportsMap.set(key, entry);
+              }
+            });
+          }
+        }
+        if (node.left.type === 'ObjectPattern') {
+          for (const prop of node.left.properties) {
+            if (prop.type === 'Property' && prop.value.type === 'MemberExpression') {
+              const ref = resolveExportTarget(prop.value, aliases, literals);
+              if (ref) {
+                addExport(ref, node);
+              }
+            }
+          }
+        }
+      }
+      if (node.type === 'CallExpression') {
+        const callee = node.callee;
+
+        // Object.assign(exports, { foo: bar })
+        if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'Object' && callee.property.type === 'Identifier' && callee.property.name === 'assign' && node.arguments.length >= 2) {
+          const targetArg = node.arguments[0];
+          const ref = resolveBase(targetArg, aliases);
+          if (!ref) return;
+          for (let i = 1; i < node.arguments.length; i++) {
+            const arg = node.arguments[i];
+            if (arg.type === 'ObjectExpression') {
+              for (const prop of arg.properties) {
+                if (prop.type !== 'Property') continue;
+                const keyName = literalPropName(prop.key, literals);
+                if (!keyName) continue;
+                let rhsIdent;
+                if (prop.value.type === 'Identifier') {
+                  rhsIdent = prop.value;
+                }
+                addExport({
+                  key: keyName,
+                  via: ref
+                }, node, rhsIdent);
+              }
+            }
+          }
+        }
+
+        // Object.defineProperty(exports, 'foo', { value, get, set })
+        if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'Object' && callee.property.type === 'Identifier' && callee.property.name === 'defineProperty' && node.arguments.length >= 3) {
+          const target = resolveBase(node.arguments[0], aliases);
+          if (!target) return;
+          const keyName = literalPropName(node.arguments[1], literals);
+          if (!keyName) return;
+          const desc = node.arguments[2];
+          if (desc.type !== 'ObjectExpression') return;
+          let rhsIdent;
+          let hasGetter = false;
+          for (const prop of desc.properties) {
+            if (prop.type !== 'Property') continue;
+            if (prop.key.type !== 'Identifier') continue;
+            if (prop.key.name === 'value' && prop.value.type === 'Identifier') {
+              rhsIdent = prop.value;
+            }
+            if (prop.key.name === 'get' && prop.value.type === 'Identifier') {
+              hasGetter = true;
+            }
+            if (prop.key.name === 'set' && prop.value.type === 'Identifier') {
+              // Setter-only doesn’t create a readable export; ignore beyond marking write
+            }
+          }
+          addExport({
+            key: keyName,
+            via: target
+          }, node, rhsIdent, {
+            hasGetter
+          });
+        }
+
+        // Object.defineProperties(exports, { foo: { value: ... }, bar: { get: ... } })
+        if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'Object' && callee.property.type === 'Identifier' && callee.property.name === 'defineProperties' && node.arguments.length >= 2) {
+          const target = resolveBase(node.arguments[0], aliases);
+          if (!target) return;
+          const descMap = node.arguments[1];
+          if (descMap.type !== 'ObjectExpression') return;
+          for (const prop of descMap.properties) {
+            if (prop.type !== 'Property') continue;
+            const keyName = literalPropName(prop.key, literals);
+            if (!keyName) continue;
+            if (prop.value.type !== 'ObjectExpression') continue;
+            let rhsIdent;
+            let hasGetter = false;
+            for (const descProp of prop.value.properties) {
+              if (descProp.type !== 'Property') continue;
+              if (descProp.key.type !== 'Identifier') continue;
+              if (descProp.key.name === 'value' && descProp.value.type === 'Identifier') {
+                rhsIdent = descProp.value;
+              }
+              if (descProp.key.name === 'get' && descProp.value.type === 'Identifier') {
+                hasGetter = true;
+              }
+            }
+            addExport({
+              key: keyName,
+              via: target
+            }, node, rhsIdent, {
+              hasGetter
+            });
+          }
+        }
+      }
+    }
+  });
+  return exportsMap;
+};
+exports.collectCjsExports = collectCjsExports;