@hakobu/hakobu 1.0.0

package/lib-es5/esm-transformer.js

@@ -0,0 +1,378 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformESMtoCJS = exports.rewriteMjsRequirePaths = void 0;
+const babel = __importStar(require("@babel/parser"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const esbuild = __importStar(require("esbuild"));
+const log_1 = require("./log");
+const common_1 = require("./common");
+/**
+ * Wrapper for top-level await support
+ * Wraps code in an async IIFE to allow top-level await in CommonJS
+ */
+const ASYNC_IIFE_WRAPPER = {
+    prefix: '(async () => {\n',
+    suffix: '\n})()',
+};
+/**
+ * Check if code contains import.meta usage
+ *
+ * @param code - The ESM source code to check
+ * @returns true if import.meta is used, false otherwise
+ */
+function hasImportMeta(code) {
+    try {
+        const ast = babel.parse(code, {
+            sourceType: 'module',
+            plugins: [],
+        });
+        if (!ast) {
+            return false;
+        }
+        let found = false;
+        (0, traverse_1.default)(ast, {
+            // Detect import.meta usage
+            MetaProperty(path) {
+                if (path.node.meta.name === 'import' &&
+                    path.node.property.name === 'meta') {
+                    found = true;
+                    path.stop(); // Stop traversal once found
+                }
+            },
+        });
+        return found;
+    }
+    catch (_error) {
+        // If we can't parse, assume no import.meta
+        return false;
+    }
+}
+/**
+ * Detect ESM features that require special handling or cannot be transformed
+ * These include:
+ * - Top-level await (can be handled with async IIFE wrapper)
+ *
+ * Note: import.meta is now supported via polyfills and is no longer in the unsupported list
+ *
+ * @param code - The ESM source code to check
+ * @param filename - The filename for error reporting
+ * @returns Object with arrays of features requiring special handling
+ */
+function detectESMFeatures(code, filename) {
+    try {
+        const ast = babel.parse(code, {
+            sourceType: 'module',
+            plugins: [],
+        });
+        if (!ast) {
+            return null;
+        }
+        const topLevelAwait = [];
+        const unsupportedFeatures = [];
+        (0, traverse_1.default)(ast, {
+            // Detect top-level await - can be handled with async IIFE wrapper
+            AwaitExpression(path) {
+                // Check if await is at top level (not inside a function)
+                let parent = path.parentPath;
+                let isTopLevel = true;
+                while (parent) {
+                    if (parent.isFunctionDeclaration() ||
+                        parent.isFunctionExpression() ||
+                        parent.isArrowFunctionExpression() ||
+                        parent.isObjectMethod() ||
+                        parent.isClassMethod()) {
+                        isTopLevel = false;
+                        break;
+                    }
+                    parent = parent.parentPath;
+                }
+                if (isTopLevel) {
+                    topLevelAwait.push({
+                        feature: 'top-level await',
+                        line: path.node.loc?.start.line ?? null,
+                        column: path.node.loc?.start.column ?? null,
+                    });
+                }
+            },
+            // Detect for-await-of at top level - can be handled with async IIFE wrapper
+            ForOfStatement(path) {
+                if (path.node.await) {
+                    let parent = path.parentPath;
+                    let isTopLevel = true;
+                    while (parent) {
+                        if (parent.isFunctionDeclaration() ||
+                            parent.isFunctionExpression() ||
+                            parent.isArrowFunctionExpression() ||
+                            parent.isObjectMethod() ||
+                            parent.isClassMethod()) {
+                            isTopLevel = false;
+                            break;
+                        }
+                        parent = parent.parentPath;
+                    }
+                    if (isTopLevel) {
+                        topLevelAwait.push({
+                            feature: 'top-level for-await-of',
+                            line: path.node.loc?.start.line ?? null,
+                            column: path.node.loc?.start.column ?? null,
+                        });
+                    }
+                }
+            },
+        });
+        return { topLevelAwait, unsupportedFeatures };
+    }
+    catch (error) {
+        // If we can't parse, return null to let the transform attempt proceed
+        log_1.log.debug(`Could not parse ${filename} to detect ESM features: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Replace esbuild's empty import_meta object with a proper implementation
+ *
+ * When esbuild transforms ESM to CJS, it converts `import.meta` to a `const import_meta = {}`.
+ * This function replaces that empty object with a proper implementation of import.meta properties.
+ *
+ * Shims provided:
+ * - import.meta.url: File URL of the current module
+ * - import.meta.dirname: Directory path of the current module (Node.js 20.11+)
+ * - import.meta.filename: File path of the current module (Node.js 20.11+)
+ *
+ * Based on approach from tsup and esbuild discussions
+ * @see https://github.com/egoist/tsup/blob/main/assets/cjs_shims.js
+ * @see https://github.com/evanw/esbuild/issues/3839
+ *
+ * @param code - The transformed CJS code from esbuild
+ * @returns Code with import_meta properly implemented
+ */
+function replaceImportMetaObject(code) {
+    // esbuild generates: const import_meta = {};
+    // We need to replace this with a proper implementation
+    // Note: We use getters to ensure values are computed at runtime in the correct context
+    const shimImplementation = `const import_meta = {
+  get url() {
+    return require('url').pathToFileURL(__filename).href;
+  },
+  get dirname() {
+    return __dirname;
+  },
+  get filename() {
+    return __filename;
+  }
+};`;
+    // Replace esbuild's empty import_meta object with our implementation
+    // Match: const import_meta = {};
+    return code.replace(/const import_meta\s*=\s*\{\s*\};/, shimImplementation);
+}
+/**
+ * Rewrite relative `.mjs` require paths to `.js` in CJS output
+ *
+ * When esbuild transforms ESM to CJS, it converts `import './foo.mjs'` to `require('./foo.mjs')`.
+ * Since the packer renames `.mjs` files to `.js` in the snapshot, the require paths must be
+ * updated to match. This handles the rewriting at build time.
+ *
+ * @param code - The CJS code after esbuild transformation
+ * @returns Code with relative .mjs require paths rewritten to .js
+ */
+function rewriteMjsRequirePaths(code) {
+    // Match require("./path.mjs") or require('../path.mjs') with relative paths only
+    return code.replace(/require\((["'])(\.\.?\/[^"']*?)\.mjs\1\)/g, 'require($1$2.js$1)');
+}
+exports.rewriteMjsRequirePaths = rewriteMjsRequirePaths;
+/**
+ * Transform ESM code to CommonJS using esbuild
+ * This allows ESM modules to be compiled to bytecode via vm.Script
+ * Uses Babel parser for detecting unsupported ESM features, then esbuild for fast transformation
+ *
+ * @param code - The ESM source code to transform
+ * @param filename - The filename for error reporting
+ * @returns Object with transformed code and success flag
+ */
+function transformESMtoCJS(code, filename) {
+    // Skip files that are unlikely to be JavaScript (e.g., .d.ts, .json, .css)
+    // to avoid Babel parse errors
+    if ((0, common_1.unlikelyJavascript)(filename)) {
+        return {
+            code,
+            isTransformed: false,
+        };
+    }
+    // First, check for ESM features that need special handling
+    const esmFeatures = detectESMFeatures(code, filename);
+    // Handle truly unsupported features (import.meta)
+    if (esmFeatures &&
+        esmFeatures.unsupportedFeatures &&
+        esmFeatures.unsupportedFeatures.length > 0) {
+        const featureList = esmFeatures.unsupportedFeatures
+            .map((f) => {
+            const location = f.line !== null ? ` at line ${f.line}` : '';
+            return `  - ${f.feature}${location}`;
+        })
+            .join('\n');
+        const errorMessage = [
+            `Cannot transform ESM module ${filename} to CommonJS:`,
+            `The following ESM features have no CommonJS equivalent:`,
+            featureList,
+            '',
+            'These features are not supported when compiling to bytecode.',
+            'Consider one of the following:',
+            '  1. Refactor to avoid these features',
+            '  2. Use --no-bytecode flag to keep the module as source code',
+            '  3. Mark the package as public to distribute with sources',
+        ].join('\n');
+        log_1.log.warn(errorMessage);
+        // Return untransformed code rather than throwing
+        // This allows the file to be included as content instead of bytecode
+        return {
+            code,
+            isTransformed: false,
+        };
+    }
+    // Check if we need to wrap in async IIFE for top-level await
+    const hasTopLevelAwait = esmFeatures &&
+        esmFeatures.topLevelAwait &&
+        esmFeatures.topLevelAwait.length > 0;
+    let codeToTransform = code;
+    // If top-level await is detected, we need to wrap in async IIFE
+    // But we must handle imports and exports specially
+    if (hasTopLevelAwait) {
+        try {
+            // Parse the code to check for exports and collect imports
+            const ast = babel.parse(code, {
+                sourceType: 'module',
+                plugins: [],
+            });
+            let hasExports = false;
+            const codeLines = code.split('\n');
+            const importLineIndices = new Set();
+            (0, traverse_1.default)(ast, {
+                ExportNamedDeclaration() {
+                    hasExports = true;
+                },
+                ExportDefaultDeclaration() {
+                    hasExports = true;
+                },
+                ExportAllDeclaration() {
+                    hasExports = true;
+                },
+                ImportDeclaration(path) {
+                    // Track import statements by line number
+                    const { loc } = path.node;
+                    if (loc) {
+                        const { start, end } = loc;
+                        for (let i = start.line; i <= end.line; i += 1) {
+                            importLineIndices.add(i - 1); // Convert to 0-based index
+                        }
+                    }
+                },
+            });
+            if (hasExports) {
+                // If the file has exports, we can't wrap it in an IIFE
+                // because exports need to be synchronous and at the top level.
+                log_1.log.warn(`Module ${filename} has both top-level await and export statements. ` +
+                    `This combination cannot be safely transformed to CommonJS in pkg's ESM transformer. ` +
+                    `The original source code will be used as-is; depending on the package visibility and build configuration, ` +
+                    `bytecode compilation may fail and the module may need to be loaded from source or be skipped.`);
+                return {
+                    code,
+                    isTransformed: false,
+                };
+            }
+            // If there are imports, extract them to keep outside the async IIFE
+            if (importLineIndices.size > 0) {
+                const imports = [];
+                const rest = [];
+                codeLines.forEach((line, index) => {
+                    if (importLineIndices.has(index)) {
+                        imports.push(line);
+                    }
+                    else {
+                        rest.push(line);
+                    }
+                });
+                // Reconstruct: imports at top, then async IIFE wrapping the rest
+                codeToTransform = `${imports.join('\n')}\n${ASYNC_IIFE_WRAPPER.prefix}${rest.join('\n')}${ASYNC_IIFE_WRAPPER.suffix}`;
+                log_1.log.debug(`Wrapping ${filename} in async IIFE with imports extracted to top level`);
+            }
+            else {
+                // No imports, wrap everything
+                codeToTransform =
+                    ASYNC_IIFE_WRAPPER.prefix + code + ASYNC_IIFE_WRAPPER.suffix;
+                log_1.log.debug(`Wrapping ${filename} in async IIFE to support top-level await`);
+            }
+        }
+        catch (parseError) {
+            // If we can't parse, wrap everything and hope for the best
+            codeToTransform =
+                ASYNC_IIFE_WRAPPER.prefix + code + ASYNC_IIFE_WRAPPER.suffix;
+            log_1.log.warn(`Could not parse ${filename} to detect exports/imports (${parseError instanceof Error ? parseError.message : String(parseError)}). ` +
+                `Wrapping entire code in async IIFE - this may fail if the module has export or import statements.`);
+        }
+    }
+    // Check if code uses import.meta before transformation
+    const usesImportMeta = hasImportMeta(code);
+    try {
+        // Build esbuild options
+        const esbuildOptions = {
+            loader: 'js',
+            format: 'cjs',
+            target: 'node20',
+            sourcemap: false,
+            minify: false,
+            keepNames: true,
+        };
+        const result = esbuild.transformSync(codeToTransform, esbuildOptions);
+        if (!result || !result.code) {
+            log_1.log.warn(`esbuild transform returned no code for ${filename}`);
+            return {
+                code,
+                isTransformed: false,
+            };
+        }
+        // Inject import.meta shims after esbuild transformation if needed
+        let finalCode = result.code;
+        if (usesImportMeta) {
+            finalCode = replaceImportMetaObject(finalCode);
+        }
+        return {
+            code: finalCode,
+            isTransformed: true,
+        };
+    }
+    catch (error) {
+        log_1.log.warn(`Failed to transform ESM to CJS for ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            code,
+            isTransformed: false,
+        };
+    }
+}
+exports.transformESMtoCJS = transformESMtoCJS;
+//# sourceMappingURL=esm-transformer.js.map

package/lib-es5/exports-resolver.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Node-compatible package.json exports/imports map resolution.
+ *
+ * Implements the PACKAGE_EXPORTS_RESOLVE and PACKAGE_IMPORTS_RESOLVE
+ * algorithms from the Node.js ESM specification, adapted for snapshot
+ * resolution.
+ *
+ * Reference: https://nodejs.org/api/esm.html#resolver-algorithm-specification
+ *
+ * Supported:
+ *   - String exports: "exports": "./lib/index.js"
+ *   - Object exports with "." key: "exports": { ".": "./lib/index.js" }
+ *   - Subpath exports: "exports": { "./utils": "./lib/utils.js" }
+ *   - Conditional exports: { "import": "...", "require": "...", "default": "..." }
+ *   - Nested conditions: { ".": { "import": "...", "require": "..." } }
+ *   - Pattern exports: "exports": { "./*": "./lib/*.js" }
+ *   - Package imports (#-prefixed): "imports": { "#utils": "./src/utils.js" }
+ *
+ * Not yet supported:
+ *   - Array fallback targets: ["./a.js", "./b.js"]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveImports = exports.resolveExports = exports.CJS_CONDITIONS = exports.ESM_CONDITIONS = void 0;
+// ─────────────────────────────────────────────────────────────────────
+// Conditions
+// ─────────────────────────────────────────────────────────────────────
+/**
+ * Default condition set for ESM resolution.
+ * Order matters — first match wins.
+ */
+exports.ESM_CONDITIONS = ['import', 'node', 'default'];
+/**
+ * Default condition set for CJS resolution.
+ */
+exports.CJS_CONDITIONS = ['require', 'node', 'default'];
+// ─────────────────────────────────────────────────────────────────────
+// Exports resolution
+// ─────────────────────────────────────────────────────────────────────
+/**
+ * Resolve a subpath against a package's exports map.
+ *
+ * @param exports - The raw "exports" value from package.json
+ * @param subpath - The subpath to resolve (e.g., "." or "./utils")
+ * @param conditions - Condition names to match (e.g., ["import", "node", "default"])
+ * @returns Resolved relative path (e.g., "./lib/index.js") or null
+ */
+function resolveExports(exports, subpath, conditions) {
+    if (exports === null || exports === undefined)
+        return null;
+    // Simple string: "exports": "./lib/index.js"
+    // Only matches subpath "."
+    if (typeof exports === 'string') {
+        return subpath === '.' ? exports : null;
+    }
+    // Array fallback — not yet supported
+    if (Array.isArray(exports)) {
+        // Try each in order, return first valid
+        for (const target of exports) {
+            if (typeof target === 'string')
+                return subpath === '.' ? target : null;
+        }
+        return null;
+    }
+    if (typeof exports !== 'object')
+        return null;
+    const map = exports;
+    const keys = Object.keys(map);
+    // Check if this is a conditions object or a subpath map.
+    // A conditions object has keys that don't start with "."
+    // A subpath map has keys that start with "."
+    const isConditionsObject = keys.length > 0 && !keys[0].startsWith('.');
+    if (isConditionsObject) {
+        // This is a conditions object at the top level.
+        // Only valid for subpath "."
+        if (subpath !== '.')
+            return null;
+        return resolveConditions(map, conditions);
+    }
+    // Subpath map: { ".": ..., "./utils": ..., "./*": ... }
+    // Look for exact match first
+    if (subpath in map) {
+        return resolveTarget(map[subpath], conditions);
+    }
+    // Pattern matching: "./*" or "./lib/*"
+    for (const key of keys) {
+        if (!key.includes('*'))
+            continue;
+        const pattern = key;
+        const starIndex = pattern.indexOf('*');
+        const prefix = pattern.slice(0, starIndex);
+        const suffix = pattern.slice(starIndex + 1);
+        if (subpath.startsWith(prefix) && (suffix === '' || subpath.endsWith(suffix))) {
+            const matched = suffix
+                ? subpath.slice(prefix.length, subpath.length - suffix.length)
+                : subpath.slice(prefix.length);
+            const target = resolveTarget(map[key], conditions);
+            if (target && typeof target === 'string') {
+                return target.replace('*', matched);
+            }
+        }
+    }
+    return null;
+}
+exports.resolveExports = resolveExports;
+// ─────────────────────────────────────────────────────────────────────
+// Imports resolution
+// ─────────────────────────────────────────────────────────────────────
+/**
+ * Resolve a #-prefixed specifier against a package's imports map.
+ *
+ * @param imports - The raw "imports" value from package.json
+ * @param specifier - The full #-prefixed specifier (e.g., "#utils")
+ * @param conditions - Condition names to match
+ * @returns Resolved relative path or null
+ */
+function resolveImports(imports, specifier, conditions) {
+    if (!imports || typeof imports !== 'object')
+        return null;
+    if (!specifier.startsWith('#'))
+        return null;
+    const map = imports;
+    // Exact match
+    if (specifier in map) {
+        return resolveTarget(map[specifier], conditions);
+    }
+    // Pattern match: "#utils/*"
+    for (const key of Object.keys(map)) {
+        if (!key.includes('*'))
+            continue;
+        const starIndex = key.indexOf('*');
+        const prefix = key.slice(0, starIndex);
+        const suffix = key.slice(starIndex + 1);
+        if (specifier.startsWith(prefix) && (suffix === '' || specifier.endsWith(suffix))) {
+            const matched = suffix
+                ? specifier.slice(prefix.length, specifier.length - suffix.length)
+                : specifier.slice(prefix.length);
+            const target = resolveTarget(map[key], conditions);
+            if (target && typeof target === 'string') {
+                return target.replace('*', matched);
+            }
+        }
+    }
+    return null;
+}
+exports.resolveImports = resolveImports;
+// ─────────────────────────────────────────────────────────────────────
+// Internal: condition + target resolution
+// ─────────────────────────────────────────────────────────────────────
+/**
+ * Resolve a target value which may be a string, conditions object, or null.
+ */
+function resolveTarget(target, conditions) {
+    if (typeof target === 'string')
+        return target;
+    if (target === null)
+        return null;
+    if (Array.isArray(target)) {
+        for (const t of target) {
+            const result = resolveTarget(t, conditions);
+            if (result)
+                return result;
+        }
+        return null;
+    }
+    if (typeof target === 'object') {
+        return resolveConditions(target, conditions);
+    }
+    return null;
+}
+/**
+ * Match a conditions object against the active condition set.
+ * First matching condition wins (order of the conditions array matters).
+ */
+function resolveConditions(obj, conditions) {
+    // Check each condition in priority order
+    for (const cond of conditions) {
+        if (cond in obj) {
+            return resolveTarget(obj[cond], conditions);
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=exports-resolver.js.map