@bleedingdev/modern-js-app-tools-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/cjs/deploy-output/plugin.js

@@ -0,0 +1,97 @@
+"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__, {
+    createDeployOutputAliasesPlugin: ()=>createDeployOutputAliasesPlugin,
+    createDeployOutputPublicAssetsPlugin: ()=>createDeployOutputPublicAssetsPlugin
+});
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_npmAliases_js_namespaceObject = require("./npmAliases.js");
+const external_public_assets_js_namespaceObject = require("./public-assets.js");
+const external_target_js_namespaceObject = require("./target.js");
+const createDeployOutputAliasesPlugin = ()=>({
+        name: '@modern-js/deploy-output-aliases',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const appContext = api.getAppContext();
+                if ('node' !== (0, external_target_js_namespaceObject.getDeployingTarget)(appContext)) return;
+                const { appDirectory } = appContext;
+                const entry = (0, external_node_module_namespaceObject.createRequire)(__filename).resolve('@modern-js/prod-server');
+                const identity = await (0, external_npmAliases_js_namespaceObject.readPackageIdentity)(entry);
+                await (0, external_npmAliases_js_namespaceObject.preserveNpmAliases)({
+                    appDirectory,
+                    outputDirectory: external_node_path_default().join(appDirectory, '.output'),
+                    implicitAliases: [
+                        {
+                            aliasName: '@modern-js/prod-server',
+                            targetName: identity.name,
+                            targetVersion: identity.version
+                        }
+                    ]
+                });
+            });
+        }
+    });
+const createDeployOutputPublicAssetsPlugin = ()=>({
+        name: '@modern-js/deploy-output-public-assets',
+        setup (api) {
+            api.onAfterDeploy(async ()=>{
+                const appContext = api.getAppContext();
+                if ('node' !== (0, external_target_js_namespaceObject.getDeployingTarget)(appContext)) return;
+                const { appDirectory } = appContext;
+                const config = api.getNormalizedConfig();
+                await (0, external_public_assets_js_namespaceObject.stageDeclaredPublicAssets)({
+                    appDirectory,
+                    outputDirectory: external_node_path_default().join(appDirectory, '.output'),
+                    assets: (0, external_public_assets_js_namespaceObject.normalizeDeclaredPublicAssets)(config.deploy?.node?.publicAssets, external_public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE),
+                    scope: external_public_assets_js_namespaceObject.NODE_PUBLIC_ASSET_SCOPE
+                });
+            });
+        }
+    });
+exports.createDeployOutputAliasesPlugin = __webpack_exports__.createDeployOutputAliasesPlugin;
+exports.createDeployOutputPublicAssetsPlugin = __webpack_exports__.createDeployOutputPublicAssetsPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDeployOutputAliasesPlugin",
+    "createDeployOutputPublicAssetsPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/deploy-output/public-assets.js

@@ -0,0 +1,146 @@
+"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__, {
+    CLOUDFLARE_PUBLIC_ASSET_SCOPE: ()=>CLOUDFLARE_PUBLIC_ASSET_SCOPE,
+    DECLARED_PUBLIC_ASSET_DIRECTORY: ()=>DECLARED_PUBLIC_ASSET_DIRECTORY,
+    NODE_PUBLIC_ASSET_SCOPE: ()=>NODE_PUBLIC_ASSET_SCOPE,
+    normalizeDeclaredPublicAssets: ()=>normalizeDeclaredPublicAssets,
+    resolveAddedDeclaredPublicAssetPaths: ()=>resolveAddedDeclaredPublicAssetPaths,
+    stageDeclaredPublicAssets: ()=>stageDeclaredPublicAssets
+});
+const promises_namespaceObject = require("node:fs/promises");
+var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_js_namespaceObject = require("../cloudflare/utils.js");
+const DECLARED_PUBLIC_ASSET_DIRECTORY = 'public';
+const CLOUDFLARE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.worker.publicAssets',
+    output: 'Cloudflare public output'
+};
+const NODE_PUBLIC_ASSET_SCOPE = {
+    label: 'deploy.node.publicAssets',
+    output: 'Node public output'
+};
+const normalizeDeclaredPublicAssets = (assets, scope)=>(assets ?? []).map((asset, index)=>({
+            from: (0, utils_js_namespaceObject.normalizeRelativePath)(asset?.from, `${scope.label}[${index}].from`, 'app root'),
+            to: (0, utils_js_namespaceObject.normalizeRelativePath)(asset?.to, `${scope.label}[${index}].to`, scope.output, {
+                allowRoot: true
+            }),
+            index
+        }));
+const isMissingPathError = (error)=>error instanceof Error && 'code' in error && 'ENOENT' === error.code;
+const pathExists = async (filePath)=>{
+    try {
+        await promises_default().lstat(filePath);
+        return true;
+    } catch (error) {
+        if (isMissingPathError(error)) return false;
+        throw error;
+    }
+};
+const listDeclaredPublicAssetFiles = async (appDirectory, assets, scope)=>{
+    const files = [];
+    const owners = new Map();
+    const add = (index, logicalPath)=>{
+        const owner = owners.get(logicalPath);
+        if (void 0 !== owner) throw new Error(`${scope.label}[${index}] and ${scope.label}[${owner}] both stage ${JSON.stringify(logicalPath)}.`);
+        owners.set(logicalPath, index);
+        files.push({
+            index,
+            logicalPath
+        });
+    };
+    const visit = async (asset, sourcePath, destination)=>{
+        const stat = await promises_default().lstat(sourcePath);
+        if (stat.isSymbolicLink()) throw new Error(`${scope.label}[${asset.index}].from must not contain symbolic links: ${external_node_path_default().relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        if (stat.isFile()) {
+            if (destination === DECLARED_PUBLIC_ASSET_DIRECTORY) throw new Error(`${scope.label}[${asset.index}].to must name a file when ${scope.label}[${asset.index}].from is a file.`);
+            add(asset.index, destination);
+            return;
+        }
+        if (!stat.isDirectory()) throw new Error(`${scope.label}[${asset.index}].from must contain only files and directories: ${external_node_path_default().relative(appDirectory, sourcePath).replace(/\\/gu, '/')}`);
+        const entries = (await promises_default().readdir(sourcePath)).sort();
+        for (const entry of entries)await visit(asset, external_node_path_default().join(sourcePath, entry), external_node_path_default().posix.join(destination, entry));
+    };
+    for (const asset of assets){
+        const sourcePath = external_node_path_default().join(appDirectory, asset.from);
+        if (!await pathExists(sourcePath)) throw new Error(`${scope.label}[${asset.index}].from does not exist: ${asset.from}`);
+        await visit(asset, sourcePath, external_node_path_default().posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to));
+    }
+    return files;
+};
+const resolveAddedDeclaredPublicAssetPaths = async ({ appDirectory, assets, generatedRoot, scope })=>{
+    const added = [];
+    for (const file of (await listDeclaredPublicAssetFiles(appDirectory, assets, scope)))if (!await pathExists(external_node_path_default().join(generatedRoot, file.logicalPath))) added.push(file.logicalPath);
+    return added.sort();
+};
+const stageDeclaredPublicAssets = async ({ appDirectory, outputDirectory, assets, scope })=>{
+    const files = await listDeclaredPublicAssetFiles(appDirectory, assets, scope);
+    const added = [];
+    for (const file of files){
+        const asset = assets.find((candidate)=>candidate.index === file.index);
+        const relativePath = external_node_path_default().posix.relative(external_node_path_default().posix.join(DECLARED_PUBLIC_ASSET_DIRECTORY, asset.to), file.logicalPath);
+        const destination = external_node_path_default().join(outputDirectory, file.logicalPath);
+        const replacesGeneratedFile = await pathExists(destination);
+        await promises_default().mkdir(external_node_path_default().dirname(destination), {
+            recursive: true
+        });
+        await promises_default().copyFile(external_node_path_default().join(appDirectory, asset.from, relativePath), destination);
+        if (!replacesGeneratedFile) added.push(file.logicalPath);
+    }
+    return added.sort();
+};
+exports.CLOUDFLARE_PUBLIC_ASSET_SCOPE = __webpack_exports__.CLOUDFLARE_PUBLIC_ASSET_SCOPE;
+exports.DECLARED_PUBLIC_ASSET_DIRECTORY = __webpack_exports__.DECLARED_PUBLIC_ASSET_DIRECTORY;
+exports.NODE_PUBLIC_ASSET_SCOPE = __webpack_exports__.NODE_PUBLIC_ASSET_SCOPE;
+exports.normalizeDeclaredPublicAssets = __webpack_exports__.normalizeDeclaredPublicAssets;
+exports.resolveAddedDeclaredPublicAssetPaths = __webpack_exports__.resolveAddedDeclaredPublicAssetPaths;
+exports.stageDeclaredPublicAssets = __webpack_exports__.stageDeclaredPublicAssets;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLOUDFLARE_PUBLIC_ASSET_SCOPE",
+    "DECLARED_PUBLIC_ASSET_DIRECTORY",
+    "NODE_PUBLIC_ASSET_SCOPE",
+    "normalizeDeclaredPublicAssets",
+    "resolveAddedDeclaredPublicAssetPaths",
+    "stageDeclaredPublicAssets"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/deploy-output/target.js

@@ -0,0 +1,104 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    DEPLOY_TARGETS: ()=>DEPLOY_TARGETS,
+    DEPLOY_TARGET_FLAG: ()=>DEPLOY_TARGET_FLAG,
+    getDeployingTarget: ()=>getDeployingTarget,
+    resolveDeployTarget: ()=>resolveDeployTarget
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_std_env_namespaceObject = require("std-env");
+const DEPLOY_TARGETS = [
+    'node',
+    'vercel',
+    'netlify',
+    'ghPages',
+    'cloudflare'
+];
+const DEPLOY_TARGET_FLAG = '--deploy-target';
+const providerDeployTargets = {
+    vercel: 'vercel',
+    netlify: 'netlify',
+    cloudflare: 'cloudflare',
+    cloudflare_pages: 'cloudflare',
+    cloudflare_workers: 'cloudflare'
+};
+const readDeployTargetFlag = (argv)=>{
+    for (const [index, arg] of argv.entries()){
+        if (arg === DEPLOY_TARGET_FLAG) {
+            const value = argv[index + 1];
+            if (void 0 === value || value.startsWith('-')) throw new Error(`${DEPLOY_TARGET_FLAG} needs a value.`);
+            return value;
+        }
+        if (arg.startsWith(`${DEPLOY_TARGET_FLAG}=`)) return arg.slice(DEPLOY_TARGET_FLAG.length + 1);
+    }
+};
+const assertDeployTarget = (target, source)=>{
+    if (!DEPLOY_TARGETS.includes(target)) throw new Error(`Unknown deploy target '${target}' from ${source}. Use one of: ${DEPLOY_TARGETS.join(', ')}.`);
+    return target;
+};
+const resolveDeployTarget = ({ argv = (0, utils_namespaceObject.getArgv)(), configTarget, env = process.env.MODERNJS_DEPLOY, provider = external_std_env_namespaceObject.provider } = {})=>{
+    const explicit = [
+        [
+            readDeployTargetFlag(argv),
+            DEPLOY_TARGET_FLAG
+        ],
+        [
+            configTarget,
+            'deploy.target'
+        ],
+        [
+            env,
+            'MODERNJS_DEPLOY'
+        ]
+    ].find(([target])=>target);
+    if (explicit?.[0]) return {
+        target: assertDeployTarget(explicit[0], explicit[1]),
+        explicit: true
+    };
+    return {
+        target: provider && providerDeployTargets[provider] || 'node',
+        explicit: false
+    };
+};
+const getDeployingTarget = ({ deployTarget, metaName })=>deployTarget && ('modern-js' === metaName || deployTarget.explicit) ? deployTarget.target : void 0;
+exports.DEPLOY_TARGETS = __webpack_exports__.DEPLOY_TARGETS;
+exports.DEPLOY_TARGET_FLAG = __webpack_exports__.DEPLOY_TARGET_FLAG;
+exports.getDeployingTarget = __webpack_exports__.getDeployingTarget;
+exports.resolveDeployTarget = __webpack_exports__.resolveDeployTarget;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEPLOY_TARGETS",
+    "DEPLOY_TARGET_FLAG",
+    "getDeployingTarget",
+    "resolveDeployTarget"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/deploy-output/trace-files.js

@@ -0,0 +1,90 @@
+"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__, {
+    createBuildHostIgnore: ()=>createBuildHostIgnore,
+    traceDeployFiles: ()=>traceDeployFiles
+});
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const nft_namespaceObject = require("@vercel/nft");
+const SYSTEM_ROOTS = 'win32' === process.platform ? [] : [
+    '/dev',
+    '/etc',
+    '/proc',
+    '/run',
+    '/sys',
+    '/var/run'
+];
+const GLOB_SEGMENT = /[*?[{]/;
+const isInside = (parent, child)=>child === parent || child.startsWith(`${parent}${external_node_path_default().sep}`);
+const globRoot = (absolutePattern)=>{
+    const { root } = external_node_path_default().parse(absolutePattern);
+    const segments = absolutePattern.slice(root.length).split(external_node_path_default().sep);
+    const index = segments.findIndex((segment)=>GLOB_SEGMENT.test(segment));
+    return -1 === index ? void 0 : external_node_path_default().join(root, ...segments.slice(0, index));
+};
+const createBuildHostIgnore = (base)=>{
+    const wholeDirectories = new Set([
+        external_node_path_default().parse(external_node_path_default().resolve(base)).root,
+        external_node_path_default().resolve(external_node_os_default().homedir()),
+        external_node_path_default().resolve(external_node_os_default().tmpdir())
+    ]);
+    return (relativePath)=>{
+        const absolutePath = external_node_path_default().resolve(base, relativePath);
+        if (SYSTEM_ROOTS.some((root)=>isInside(root, absolutePath))) return true;
+        const root = globRoot(absolutePath);
+        return void 0 !== root && wholeDirectories.has(root);
+    };
+};
+const traceDeployFiles = ({ entryFiles, sourceDir, base = '/' })=>(0, nft_namespaceObject.nodeFileTrace)(entryFiles, {
+        base,
+        processCwd: sourceDir,
+        ignore: createBuildHostIgnore(base)
+    });
+exports.createBuildHostIgnore = __webpack_exports__.createBuildHostIgnore;
+exports.traceDeployFiles = __webpack_exports__.traceDeployFiles;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBuildHostIgnore",
+    "traceDeployFiles"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/native-type-checker.js

@@ -0,0 +1,193 @@
+"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__, {
+    UltramodernNativeTypeChecker: ()=>UltramodernNativeTypeChecker,
+    configureUltramodernTypeChecker: ()=>configureUltramodernTypeChecker
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_util_namespaceObject = require("node:util");
+const builder_namespaceObject = require("@modern-js/builder");
+const execute = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.execFile);
+const native_type_checker_name = 'UltramodernNativeTypeChecker';
+const watchDependencyPath = (file)=>{
+    if ('win32' !== process.platform) return file;
+    try {
+        return external_node_fs_namespaceObject.realpathSync.native(file);
+    } catch  {
+        return file;
+    }
+};
+class UltramodernNativeTypeChecker {
+    async check() {
+        const { configFile, build } = this.options;
+        if (!build) {
+            const config = JSON.parse(await this.run([
+                '--showConfig',
+                '--project',
+                configFile
+            ]));
+            if (config.references?.length) await this.run([
+                '--build',
+                ...config.references.map((reference)=>external_node_path_default().resolve(external_node_path_default().dirname(configFile), reference.path)),
+                '--stopBuildOnErrors',
+                '--pretty',
+                'false'
+            ]);
+        }
+        const args = build ? [
+            '--build',
+            configFile,
+            '--stopBuildOnErrors'
+        ] : [
+            '--project',
+            configFile,
+            '--noEmit'
+        ];
+        await this.run([
+            ...args,
+            '--pretty',
+            'false'
+        ]);
+    }
+    async run(args) {
+        try {
+            const result = await execute(this.options.compiler(), args, {
+                cwd: external_node_path_default().dirname(this.options.configFile),
+                maxBuffer: 16777216
+            });
+            return result.stdout;
+        } catch (cause) {
+            const output = cause;
+            const diagnostics = `${output.stdout ?? ''}${output.stderr ?? ''}`;
+            throw new Error(`${native_type_checker_name} failed:\n${diagnostics || (cause instanceof Error ? cause.message : String(cause))}`, {
+                cause
+            });
+        }
+    }
+    async watchInputs() {
+        const inputs = new Set();
+        const missing = new Set();
+        const projects = [
+            this.options.configFile
+        ];
+        const visited = new Set();
+        for (const configFile of projects){
+            if (visited.has(configFile)) continue;
+            visited.add(configFile);
+            inputs.add(configFile);
+            if (!(0, external_node_fs_namespaceObject.existsSync)(configFile)) {
+                missing.add(configFile);
+                continue;
+            }
+            let config;
+            try {
+                config = JSON.parse(await this.run([
+                    '--showConfig',
+                    '--project',
+                    configFile
+                ]));
+            } catch  {
+                continue;
+            }
+            const directory = external_node_path_default().dirname(configFile);
+            for (const file of config.files ?? [])inputs.add(external_node_path_default().resolve(directory, file));
+            for (const reference of config.references ?? []){
+                const target = external_node_path_default().resolve(directory, reference.path);
+                projects.push('.json' === external_node_path_default().extname(target) ? target : external_node_path_default().join(target, 'tsconfig.json'));
+            }
+        }
+        return {
+            inputs,
+            missing
+        };
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(native_type_checker_name, (compilation)=>{
+            compilation.hooks.processAssets.tapPromise(native_type_checker_name, async ()=>{
+                try {
+                    compilation.fileDependencies.add(watchDependencyPath(this.options.configFile));
+                    const projectConfigFile = (0, builder_namespaceObject.refreshTsgoCheckerConfig)(this.options.configFile);
+                    if (projectConfigFile) {
+                        const watched = watchDependencyPath(projectConfigFile);
+                        compilation.fileDependencies.add(watched);
+                        if (!(0, external_node_fs_namespaceObject.existsSync)(projectConfigFile)) compilation.missingDependencies.add(watched);
+                    }
+                    const { inputs, missing } = await this.watchInputs();
+                    for (const file of inputs)compilation.fileDependencies.add(watchDependencyPath(file));
+                    for (const file of missing)compilation.missingDependencies.add(watchDependencyPath(file));
+                    await this.check();
+                } catch (cause) {
+                    compilation.errors.push(new Error(cause instanceof Error ? cause.message : String(cause), {
+                        cause
+                    }));
+                }
+            });
+        });
+    }
+    constructor(options){
+        this.options = options;
+    }
+}
+function configureUltramodernTypeChecker(chain, pluginId, resolveCompiler) {
+    if (!chain.plugins.has(pluginId)) return;
+    const options = chain.plugin(pluginId).get('args')?.[0];
+    const typescript = options?.typescript;
+    if (typescript?.tsgo === false) return;
+    if (!typescript?.configFile) throw new Error(`${native_type_checker_name} requires the configured TypeScript project.`);
+    const configFile = external_node_path_default().resolve(typescript.configFile);
+    chain.plugin(pluginId).use(UltramodernNativeTypeChecker, [
+        {
+            build: true === typescript.build,
+            compiler: ()=>resolveCompiler(configFile),
+            configFile
+        }
+    ]);
+}
+exports.UltramodernNativeTypeChecker = __webpack_exports__.UltramodernNativeTypeChecker;
+exports.configureUltramodernTypeChecker = __webpack_exports__.configureUltramodernTypeChecker;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "UltramodernNativeTypeChecker",
+    "configureUltramodernTypeChecker"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});