@bleedingdev/modern-js-server-utils 3.9.0-ultramodern.17 → 3.9.0-ultramodern.19

package/dist/cjs/compilers/typescript/index.js

@@ -1,314 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    compileByTs: ()=>compileByTs,
-    createResolvedTsgoConfig: ()=>createResolvedTsgoConfig,
-    getTsgoBinPath: ()=>getTsgoBinPath,
-    rewriteOutputSpecifiers: ()=>rewriteOutputSpecifiers
-});
-const utils_namespaceObject = require("@modern-js/utils");
-const external_child_process_namespaceObject = require("child_process");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-const external_importRewriter_js_namespaceObject = require("./importRewriter.js");
-const external_tsconfigPathsPlugin_js_namespaceObject = require("./tsconfigPathsPlugin.js");
-const copyFiles = async (from, to, appDirectory)=>{
-    if (await utils_namespaceObject.fs.pathExists(from)) {
-        const relativePath = external_path_default().relative(appDirectory, from);
-        const targetDir = external_path_default().join(to, relativePath);
-        await utils_namespaceObject.fs.copy(from, targetDir, {
-            filter: (src)=>!/\.(?:[cm]?ts|tsx|jsx?)$/u.test(src) && !src.endsWith('tsconfig.json')
-        });
-    }
-};
-let resolvedConfigCount = 0;
-const createResolvedTsgoConfig = async (appDirectory, tsconfigPath, distDir, sourceDirs, moduleType, tsgoBinPath, excludeFiles = [])=>{
-    const tsconfigDir = external_path_default().dirname(tsconfigPath);
-    const output = await runTsgo(tsgoBinPath, [
-        '--showConfig',
-        '-p',
-        tsconfigPath
-    ], {
-        cwd: tsconfigDir
-    });
-    const config = JSON.parse(output.stdout);
-    config.compilerOptions ??= {};
-    config.compilerOptions.rootDir = appDirectory;
-    config.compilerOptions.outDir = distDir;
-    config.compilerOptions.composite = false;
-    config.compilerOptions.declarationMap = false;
-    config.compilerOptions.emitDeclarationOnly = false;
-    config.compilerOptions.incremental = false;
-    config.compilerOptions.noEmit = false;
-    if (void 0 === config.compilerOptions.jsx || 'preserve' === config.compilerOptions.jsx) config.compilerOptions.jsx = 'react-jsx';
-    delete config.compilerOptions.tsBuildInfoFile;
-    if (true === config.compilerOptions.allowImportingTsExtensions) config.compilerOptions.rewriteRelativeImportExtensions = true;
-    config.files = filterSourceFiles(tsconfigDir, sourceDirs, config.files, excludeFiles);
-    delete config.include;
-    delete config.references;
-    delete config.compilerOptions.baseUrl;
-    if ([
-        'node',
-        'node10'
-    ].includes(String(config.compilerOptions.moduleResolution).toLowerCase())) delete config.compilerOptions.moduleResolution;
-    if ('module' !== moduleType) {
-        if ([
-            'preserve',
-            'esnext',
-            'es2015',
-            'es2020',
-            'es2022',
-            'es6'
-        ].includes(String(config.compilerOptions.module).toLowerCase())) {
-            config.compilerOptions.module = 'commonjs';
-            delete config.compilerOptions.moduleResolution;
-        }
-        config.compilerOptions.verbatimModuleSyntax = false;
-    }
-    const resolvedConfigPath = external_path_default().join(tsconfigDir, `.tsgo.${process.pid}.${resolvedConfigCount++}.resolved.json`);
-    await utils_namespaceObject.fs.writeFile(resolvedConfigPath, JSON.stringify(config, null, 2));
-    return {
-        config,
-        resolvedConfigPath
-    };
-};
-const filterSourceFiles = (tsconfigDir, sourceDirs, files = [], excludeFiles = [])=>{
-    const sourcePosixPaths = sourceDirs.map((sourceDir)=>sourceDir.split(external_path_default().sep).join(external_path_default().posix.sep));
-    const excludedPaths = new Set(excludeFiles.map((file)=>external_path_default().normalize(file).split(external_path_default().sep).join(external_path_default().posix.sep)));
-    return files.filter((fileName)=>{
-        const absoluteFileName = external_path_default().resolve(tsconfigDir, fileName).split(external_path_default().sep).join(external_path_default().posix.sep);
-        if (excludedPaths.has(absoluteFileName)) return false;
-        return fileName.endsWith('.d.ts') || sourcePosixPaths.some((sourceDir)=>absoluteFileName.includes(sourceDir));
-    });
-};
-const runTsgo = (tsgoBinPath, args, options)=>new Promise((resolve, reject)=>{
-        const child = (0, external_child_process_namespaceObject.spawn)(process.execPath, [
-            tsgoBinPath,
-            ...args
-        ], {
-            cwd: options.cwd,
-            stdio: [
-                'ignore',
-                'pipe',
-                'pipe'
-            ]
-        });
-        let stdout = '';
-        let stderr = '';
-        child.stdout.on('data', (data)=>{
-            stdout += data;
-        });
-        child.stderr.on('data', (data)=>{
-            stderr += data;
-        });
-        child.on('error', reject);
-        child.on('close', (code)=>{
-            const result = {
-                stdout,
-                stderr,
-                code: code ?? 1
-            };
-            if (false !== options.reject && 0 !== result.code) return void reject(new Error(stderr || stdout || `tsgo exited with ${result.code}`));
-            resolve(result);
-        });
-    });
-const getTsgoBinEntry = (pkg)=>{
-    if ('string' == typeof pkg.bin) return pkg.bin;
-    return pkg.bin?.tsc ?? pkg.bin?.tsgo;
-};
-const resolveTsgoBinPath = (pkgPath)=>{
-    const pkgDir = external_path_default().dirname(pkgPath);
-    const pkg = require(pkgPath);
-    const declaredBinEntry = getTsgoBinEntry(pkg);
-    const candidates = [
-        declaredBinEntry ? external_path_default().resolve(pkgDir, declaredBinEntry) : void 0,
-        external_path_default().join(pkgDir, 'bin/tsgo.js')
-    ].filter((candidate)=>Boolean(candidate));
-    return candidates.find((candidate)=>utils_namespaceObject.fs.existsSync(candidate)) ?? candidates[0];
-};
-const getTsgoBinPath = (appDirectory, resolvePaths = [
-    appDirectory,
-    __dirname
-])=>{
-    try {
-        let pkgPath;
-        try {
-            pkgPath = require.resolve("@typescript/native/package.json", {
-                paths: resolvePaths
-            });
-        } catch  {
-            pkgPath = require.resolve("@typescript/native-preview/package.json", {
-                paths: resolvePaths
-            });
-        }
-        return resolveTsgoBinPath(pkgPath);
-    } catch  {
-        throw new Error('tsgo could not be found! Please install "@typescript/native" (or legacy "@typescript/native-preview") in your project to compile BFF/server code.');
-    }
-};
-const OUTPUT_SOURCE_EXTENSIONS = {
-    '.js': [
-        '.ts',
-        '.tsx',
-        '.js',
-        '.jsx'
-    ],
-    '.mjs': [
-        '.mts',
-        '.mjs'
-    ],
-    '.cjs': [
-        '.cts',
-        '.cjs'
-    ],
-    '.d.ts': [
-        '.ts',
-        '.tsx',
-        '.js',
-        '.jsx'
-    ],
-    '.d.mts': [
-        '.mts',
-        '.mjs'
-    ],
-    '.d.cts': [
-        '.cts',
-        '.cjs'
-    ]
-};
-const getSourceFileForOutput = (appDirectory, distDir, outputFile)=>{
-    const relativeOutput = external_path_default().relative(distDir, outputFile);
-    const parsed = external_path_default().parse(relativeOutput);
-    const isDeclaration = parsed.name.endsWith('.d');
-    const outputExtension = isDeclaration ? `.d${parsed.ext}` : parsed.ext;
-    const sourceName = isDeclaration ? parsed.name.slice(0, -2) : parsed.name;
-    const sourceBase = external_path_default().join(appDirectory, parsed.dir, sourceName);
-    const extensions = OUTPUT_SOURCE_EXTENSIONS[outputExtension] ?? OUTPUT_SOURCE_EXTENSIONS['.js'];
-    for (const extension of extensions){
-        const candidate = `${sourceBase}${extension}`;
-        if (utils_namespaceObject.fs.existsSync(candidate)) return candidate;
-    }
-};
-const sourceMappingUrlRE = /^\/\/[#@] sourceMappingURL=.*$/gm;
-const dropStaleSourceMap = async (outputFile, content)=>{
-    const mapFile = `${outputFile}.map`;
-    if (await utils_namespaceObject.fs.pathExists(mapFile)) await utils_namespaceObject.fs.remove(mapFile);
-    return content.replace(sourceMappingUrlRE, '');
-};
-const rewriteOutputSpecifiers = async (appDirectory, distDir, baseUrl, paths, moduleType)=>{
-    if (!await utils_namespaceObject.fs.pathExists(distDir)) return;
-    const matcher = (0, external_tsconfigPathsPlugin_js_namespaceObject.createTsconfigPathsMatcher)(baseUrl, paths);
-    if (!matcher) return;
-    const files = await collectOutputFiles(distDir);
-    await Promise.all(files.map(async (file)=>{
-        const sourceFile = getSourceFileForOutput(appDirectory, distDir, file);
-        if (!sourceFile) return;
-        (0, external_importRewriter_js_namespaceObject.assertNoNativeModuleOutputCollision)(sourceFile, utils_namespaceObject.fs.existsSync);
-        const content = await utils_namespaceObject.fs.readFile(file, 'utf8');
-        const { content: rewritten, changed } = (0, external_importRewriter_js_namespaceObject.rewriteImportSpecifiers)(content, (specifier)=>(0, external_tsconfigPathsPlugin_js_namespaceObject.getNotAliasedPath)(sourceFile, matcher, specifier, moduleType));
-        if (changed) await utils_namespaceObject.fs.writeFile(file, await dropStaleSourceMap(file, rewritten));
-    }));
-};
-const collectOutputFiles = async (dir)=>{
-    const entries = await utils_namespaceObject.fs.readdir(dir, {
-        withFileTypes: true
-    });
-    const files = await Promise.all(entries.map(async (entry)=>{
-        const fullPath = external_path_default().join(dir, entry.name);
-        if (entry.isDirectory()) return collectOutputFiles(fullPath);
-        return /\.(?:c|m)?js$|\.d\.(?:c|m)?ts$/.test(entry.name) ? [
-            fullPath
-        ] : [];
-    }));
-    return files.flat();
-};
-const compileByTs = async (appDirectory, config, compileOptions)=>{
-    utils_namespaceObject.logger.info("Running tsgo compile...");
-    const { sourceDirs, distDir, tsconfigPath } = compileOptions;
-    if (!tsconfigPath) return;
-    const { alias } = config;
-    const aliasOption = (0, utils_namespaceObject.getAliasConfig)(alias, {
-        appDirectory,
-        tsconfigPath
-    });
-    const { paths = {}, absoluteBaseUrl = './' } = aliasOption;
-    const tsgoBinPath = getTsgoBinPath(appDirectory);
-    const { config: tsgoConfig, resolvedConfigPath } = await createResolvedTsgoConfig(appDirectory, tsconfigPath, distDir, sourceDirs, compileOptions.moduleType, tsgoBinPath, compileOptions.excludeFiles);
-    let result;
-    try {
-        result = await runTsgo(tsgoBinPath, [
-            '-p',
-            resolvedConfigPath
-        ], {
-            cwd: appDirectory,
-            reject: false
-        });
-    } finally{
-        await utils_namespaceObject.fs.remove(resolvedConfigPath);
-    }
-    if (result.stderr) utils_namespaceObject.logger.error(result.stderr);
-    if (result.stdout) utils_namespaceObject.logger.info(result.stdout);
-    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
-    if (0 !== result.code) {
-        const noEmitOnError = tsgoConfig.compilerOptions?.noEmitOnError;
-        if (void 0 === noEmitOnError || true === noEmitOnError) if (compileOptions.throwErrorInsteadOfExit) {
-            utils_namespaceObject.logger.error('TS-Go compilation failed');
-            throw new Error([
-                `TS-Go compilation failed with exit code ${result.code}.`,
-                result.stderr.trim() || result.stdout.trim()
-            ].filter(Boolean).join('\n'));
-        } else process.exit(1);
-    }
-    for (const source of sourceDirs)await copyFiles(source, distDir, appDirectory);
-    await rewriteOutputSpecifiers(appDirectory, distDir, absoluteBaseUrl, paths, compileOptions.moduleType);
-    utils_namespaceObject.logger.info("TS-Go compile succeed");
-};
-exports.compileByTs = __webpack_exports__.compileByTs;
-exports.createResolvedTsgoConfig = __webpack_exports__.createResolvedTsgoConfig;
-exports.getTsgoBinPath = __webpack_exports__.getTsgoBinPath;
-exports.rewriteOutputSpecifiers = __webpack_exports__.rewriteOutputSpecifiers;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "compileByTs",
-    "createResolvedTsgoConfig",
-    "getTsgoBinPath",
-    "rewriteOutputSpecifiers"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/compilers/typescript/tsconfigPathsPlugin.js

@@ -1,194 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module1)=>{
-        var getter = module1 && module1.__esModule ? ()=>module1['default'] : ()=>module1;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    createTsconfigPathsMatcher: ()=>createTsconfigPathsMatcher,
-    getNotAliasedPath: ()=>getNotAliasedPath
-});
-const utils_namespaceObject = require("@modern-js/utils");
-const tsconfig_paths_namespaceObject = require("@modern-js/utils/tsconfig-paths");
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
-const windowsAbsolutePathRE = /^[A-Za-z]:[\\/]/u;
-const isAbsolutePath = (input)=>external_path_default().isAbsolute(input) || external_path_default().win32.isAbsolute(input);
-const pathApiFor = (...inputs)=>inputs.some((input)=>windowsAbsolutePathRE.test(input)) ? external_path_default().win32 : external_path_default();
-const toImportSpecifier = (sourceFile, resolvedPath)=>{
-    const pathApi = pathApiFor(sourceFile, resolvedPath);
-    const relativePath = pathApi.relative(pathApi.dirname(sourceFile), resolvedPath).split(pathApi.sep).join(external_path_default().posix.sep);
-    return '.' === relativePath[0] ? relativePath : `./${relativePath}`;
-};
-const SOURCE_TO_OUTPUT_EXTENSION = new Map([
-    [
-        '.ts',
-        '.js'
-    ],
-    [
-        '.tsx',
-        '.js'
-    ],
-    [
-        '.js',
-        '.js'
-    ],
-    [
-        '.jsx',
-        '.js'
-    ],
-    [
-        '.mts',
-        '.mjs'
-    ],
-    [
-        '.mjs',
-        '.mjs'
-    ],
-    [
-        '.cts',
-        '.cjs'
-    ],
-    [
-        '.cjs',
-        '.cjs'
-    ]
-]);
-const toEsmOutputPath = (resolvedPath)=>{
-    const sourcePath = ((0, utils_namespaceObject.findSourceEntry)(resolvedPath) || resolvedPath).replace(/\\/g, '/');
-    const ext = external_path_default().extname(sourcePath);
-    if (!ext) return `${sourcePath}.js`;
-    const outputExtension = SOURCE_TO_OUTPUT_EXTENSION.get(ext);
-    if (!outputExtension) return sourcePath;
-    return `${sourcePath.slice(0, -ext.length)}${outputExtension}`;
-};
-const resolveRelativeEsmSpecifier = (sourceFile, text)=>{
-    if (!text.startsWith('./') && !text.startsWith('../')) return;
-    const pathApi = pathApiFor(sourceFile);
-    return pathApi.resolve(pathApi.dirname(sourceFile), text);
-};
-const isRegExpKey = (str)=>str.startsWith('^') || str.endsWith('$');
-const resolveAliasPath = (baseUrl, filePath)=>{
-    if (filePath.startsWith('.') || filePath.startsWith('..')) return external_path_default().resolve(baseUrl, filePath);
-    return filePath;
-};
-const createAliasMatcher = (baseUrl, alias)=>{
-    const aliasPairs = Object.keys(alias).reduce((o, key)=>{
-        if (isRegExpKey(key)) {
-            const regexp = new RegExp(key);
-            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
-            o.push([
-                regexp,
-                aliasPath
-            ]);
-        } else {
-            const aliasPath = resolveAliasPath(baseUrl, alias[key]);
-            o.push([
-                key,
-                aliasPath
-            ]);
-        }
-        return o;
-    }, []);
-    const cacheMap = new Map();
-    return (requestedModule)=>{
-        if (cacheMap.has(requestedModule)) return cacheMap.get(requestedModule);
-        for (const [key, value] of aliasPairs){
-            if (key instanceof RegExp) {
-                if (key.test(requestedModule)) {
-                    cacheMap.set(requestedModule, value);
-                    return value;
-                }
-            }
-            if (requestedModule === key) {
-                cacheMap.set(requestedModule, value);
-                return value;
-            }
-        }
-    };
-};
-const createTsconfigPathsMatcher = (baseUrl, paths)=>{
-    const tsPaths = {};
-    const alias = {};
-    Object.keys(paths).forEach((key)=>{
-        if (Array.isArray(paths[key])) tsPaths[key] = paths[key];
-        else alias[key] = paths[key];
-    });
-    const matchAliasPath = createAliasMatcher(baseUrl, alias);
-    const matchTsPath = (0, tsconfig_paths_namespaceObject.createMatchPath)(baseUrl, tsPaths, [
-        'main'
-    ]);
-    return (requestedModule, readJSONSync, fileExists, extensions)=>{
-        const result = matchTsPath(requestedModule, readJSONSync, fileExists, extensions);
-        if (result) return result;
-        return matchAliasPath(requestedModule);
-    };
-};
-function getNotAliasedPath(sourceFile, matcher, text, moduleType) {
-    let result = (0, utils_namespaceObject.findMatchedSourcePath)(matcher, text);
-    if (!result && 'module' === moduleType) result = resolveRelativeEsmSpecifier(sourceFile, text);
-    if (!result) return;
-    if (!isAbsolutePath(result)) {
-        if (!result.startsWith('.') && !result.startsWith('..')) try {
-            const packagePath = require.resolve(result, {
-                paths: [
-                    process.cwd(),
-                    ...module.paths
-                ]
-            });
-            if (packagePath) return result;
-        } catch  {}
-        try {
-            const packagePath = require.resolve(text, {
-                paths: [
-                    process.cwd(),
-                    ...module.paths
-                ]
-            });
-            if (packagePath) return text;
-        } catch  {}
-    }
-    if ('module' === moduleType || /\.[cm]ts$/iu.test(result)) result = toEsmOutputPath(result);
-    return toImportSpecifier(sourceFile, result) || './';
-}
-exports.createTsconfigPathsMatcher = __webpack_exports__.createTsconfigPathsMatcher;
-exports.getNotAliasedPath = __webpack_exports__.getNotAliasedPath;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "createTsconfigPathsMatcher",
-    "getNotAliasedPath"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/esm/compilers/typescript/importRewriter.mjs

@@ -1,134 +0,0 @@
-import { parseSync } from "@swc/core";
-const assertNoNativeModuleOutputCollision = (sourceFile, fileExists)=>{
-    const rawModuleFile = sourceFile.endsWith('.mts') ? `${sourceFile.slice(0, -4)}.mjs` : sourceFile.endsWith('.cts') ? `${sourceFile.slice(0, -4)}.cjs` : void 0;
-    if (rawModuleFile && fileExists(rawModuleFile)) throw new Error(`Native module sources collide: "${sourceFile}" and "${rawModuleFile}" publish the same output.`);
-};
-const isObjectRecord = (value)=>'object' == typeof value && null !== value;
-const isAstNode = (value)=>isObjectRecord(value) && 'string' == typeof value.type;
-const isStringLiteral = (value)=>isAstNode(value) && 'StringLiteral' === value.type && 'string' == typeof value.value && 'object' == typeof value.span && null !== value.span && 'number' == typeof value.span.start && 'number' == typeof value.span.end;
-const getCallSpecifier = (node)=>{
-    if ('CallExpression' !== node.type || !Array.isArray(node.arguments)) return;
-    const callee = node.callee;
-    const isDynamicImport = isAstNode(callee) && 'Import' === callee.type;
-    const isCommonJsRequire = isAstNode(callee) && 'Identifier' === callee.type && 'require' === callee.value;
-    if (!isDynamicImport && !isCommonJsRequire) return;
-    const firstArgument = node.arguments[0];
-    if (!isObjectRecord(firstArgument)) return;
-    return isStringLiteral(firstArgument.expression) ? firstArgument.expression : void 0;
-};
-const collectSpecifierLiterals = (content)=>{
-    const parserOptions = {
-        decorators: true,
-        syntax: "typescript",
-        target: 'esnext'
-    };
-    let program;
-    try {
-        program = parseSync(content, parserOptions);
-    } catch (typescriptError) {
-        try {
-            program = parseSync(content, {
-                ...parserOptions,
-                tsx: true
-            });
-        } catch  {
-            throw typescriptError;
-        }
-    }
-    const literals = [];
-    const seenSpans = new Set();
-    const add = (value)=>{
-        if (!isStringLiteral(value)) return;
-        const spanKey = `${value.span.start}:${value.span.end}`;
-        if (!seenSpans.has(spanKey)) {
-            seenSpans.add(spanKey);
-            literals.push(value);
-        }
-    };
-    const visit = (value)=>{
-        if (Array.isArray(value)) return void value.forEach(visit);
-        if (!isObjectRecord(value)) return;
-        if (isAstNode(value)) switch(value.type){
-            case 'ImportDeclaration':
-            case 'ExportAllDeclaration':
-            case 'ExportNamedDeclaration':
-                add(value.source);
-                break;
-            case 'TsImportType':
-                add(value.argument);
-                break;
-            case 'TsExternalModuleReference':
-                add(value.expression);
-                break;
-            case 'CallExpression':
-                add(getCallSpecifier(value));
-                break;
-        }
-        for (const [key, child] of Object.entries(value))if ('span' !== key) visit(child);
-    };
-    visit(program);
-    return literals.sort((left, right)=>left.span.start - right.span.start);
-};
-const mapUtf8ByteOffsets = (content, byteOffsets)=>{
-    const pending = new Set(byteOffsets);
-    const result = new Map();
-    let byteOffset = 0;
-    let stringOffset = 0;
-    while(stringOffset <= content.length && pending.size > 0){
-        if (pending.delete(byteOffset)) result.set(byteOffset, stringOffset);
-        if (stringOffset === content.length) break;
-        const codePoint = content.codePointAt(stringOffset);
-        if (void 0 === codePoint) break;
-        const character = String.fromCodePoint(codePoint);
-        byteOffset += Buffer.byteLength(character);
-        stringOffset += character.length;
-    }
-    if (pending.size > 0) throw new Error('SWC returned an import specifier span outside its source');
-    return result;
-};
-const scanSpecifiers = (content)=>{
-    const literals = collectSpecifierLiterals(content);
-    const byteOffsets = literals.flatMap((literal)=>[
-            literal.span.start,
-            literal.span.end - 2
-        ]);
-    const stringOffsets = mapUtf8ByteOffsets(content, byteOffsets);
-    return literals.map((literal)=>{
-        const start = stringOffsets.get(literal.span.start);
-        const end = stringOffsets.get(literal.span.end - 2);
-        if (void 0 === start || void 0 === end) throw new Error('Could not locate an SWC import specifier in its source');
-        return {
-            start,
-            end,
-            value: content.slice(start, end)
-        };
-    });
-};
-const rewriteImportSpecifiers = (content, rewrite)=>{
-    const specifiers = scanSpecifiers(content);
-    if (0 === specifiers.length) return {
-        content,
-        changed: false
-    };
-    let result = '';
-    let cursor = 0;
-    let changed = false;
-    for (const specifier of specifiers){
-        if (specifier.value.includes('\\')) continue;
-        const next = rewrite(specifier.value);
-        if (void 0 !== next && next !== specifier.value) {
-            changed = true;
-            result += content.slice(cursor, specifier.start) + next;
-            cursor = specifier.end;
-        }
-    }
-    if (!changed) return {
-        content,
-        changed: false
-    };
-    return {
-        content: result + content.slice(cursor),
-        changed: true
-    };
-};
-export { assertNoNativeModuleOutputCollision, rewriteImportSpecifiers };