typia 13.0.0 → 13.0.1

package/lib/executable/TypiaGenerateWizard2.mjs

@@ -1,719 +0,0 @@
-import { __exports as TypiaGenerateWizard$2 } from '../_virtual/TypiaGenerateWizard.mjs';
-import require$$0 from '../_virtual/_commander.mjs';
-import require$$1 from '../_virtual/_node_fs.mjs';
-import require$$2 from '../_virtual/_inquirer.mjs';
-import require$$0$1 from '../_virtual/_node_module.mjs';
-import require$$1$1 from '../_virtual/_node_path.mjs';
-import require$$5 from '../_virtual/_tinyglobby.mjs';
-
-
-// -- Shims --
-import cjsUrl from 'node:url';
-import cjsPath from 'node:path';
-import cjsModule from 'node:module';
-const __filename = cjsUrl.fileURLToPath(import.meta.url);
-const __dirname = cjsPath.dirname(__filename);
-const require = cjsModule.createRequire(import.meta.url);
-function _mergeNamespaces(n, m) {
-    m.forEach(function (e) {
-        e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-            if (k !== 'default' && !(k in n)) {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    });
-    return Object.freeze(n);
-}
-
-var __awaiter = (TypiaGenerateWizard$2 && TypiaGenerateWizard$2.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (TypiaGenerateWizard$2 && TypiaGenerateWizard$2.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(TypiaGenerateWizard$2, "__esModule", { value: true });
-var TypiaGenerateWizard_2 = TypiaGenerateWizard$2.TypiaGenerateWizard = void 0;
-const commander_1 = require$$0;
-const fs_1 = __importDefault(require$$1);
-const inquirer_1 = __importDefault(require$$2);
-const module_1 = require$$0$1;
-const path_1 = __importDefault(require$$1$1);
-const tinyglobby_1 = require$$5;
-var TypiaGenerateWizard;
-(function (TypiaGenerateWizard) {
-    function generate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log("----------------------------------------");
-            console.log(" Typia Generate Wizard");
-            console.log("----------------------------------------");
-            const options = yield parseArguments();
-            yield build(options);
-        });
-    }
-    TypiaGenerateWizard.generate = generate;
-    function parseArguments() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const command = (0, commander_1.createCommand)("typia generate");
-            command.usage("[options] [files...]");
-            command.argument("[files...]", "input TypeScript source files or globs");
-            command.option("--input <path>", "input directory");
-            command.option("--output <directory>", "output directory");
-            command.option("--project <project>", "tsconfig.json/jsconfig.json file or directory");
-            const questioned = { value: false };
-            const prompt = inquirer_1.default.createPromptModule;
-            const input = (name) => (message) => __awaiter(this, void 0, void 0, function* () {
-                questioned.value = true;
-                const result = yield prompt()({
-                    type: "input",
-                    name,
-                    message,
-                    default: "",
-                });
-                return result[name];
-            });
-            const configure = () => __awaiter(this, void 0, void 0, function* () {
-                const file = findProjectConfigFile(process.cwd());
-                if (file === null) {
-                    throw new URIError(`Unable to find "tsconfig.json" or "jsconfig.json" file.`);
-                }
-                return file;
-            });
-            return new Promise((resolve, reject) => {
-                command.action((files, options) => __awaiter(this, void 0, void 0, function* () {
-                    var _a, _b, _c;
-                    try {
-                        if (files.length !== 0 && options.input !== undefined) {
-                            throw new URIError("Error on TypiaGenerateWizard.generate(): file arguments cannot be combined with --input.");
-                        }
-                        if (files.length === 0) {
-                            (_a = options.input) !== null && _a !== void 0 ? _a : (options.input = yield input("input")("input directory"));
-                        }
-                        if (files.length !== 0 && options.output === undefined) {
-                            throw new URIError("Error on TypiaGenerateWizard.generate(): output directory is required when file arguments are used.");
-                        }
-                        const output = (_b = options.output) !== null && _b !== void 0 ? _b : (yield input("output")("output directory"));
-                        const project = (_c = options.project) !== null && _c !== void 0 ? _c : (yield configure());
-                        if (questioned.value)
-                            console.log("");
-                        resolve({
-                            input: options.input,
-                            output,
-                            project,
-                            files,
-                        });
-                    }
-                    catch (exp) {
-                        reject(exp);
-                    }
-                }));
-                command.parseAsync(process.argv.slice(3), { from: "user" }).catch(reject);
-            });
-        });
-    }
-    function build(location) {
-        return __awaiter(this, void 0, void 0, function* () {
-            location.output = path_1.default.resolve(location.output);
-            location.project = resolveProjectConfigFile(location.project);
-            const entries = location.files.length === 0
-                ? yield prepareDirectoryInput(location)
-                : yield prepareFileInputs(location);
-            const binary = resolveTsgoBinary();
-            const cwd = path_1.default.dirname(location.project);
-            const transformed = transformProject({
-                binary,
-                cwd,
-                tsconfig: location.project,
-            });
-            const outputByKey = indexTransformedOutputs(transformed);
-            const outputs = entries.map((entry) => {
-                const output = getTransformedOutput({
-                    cwd,
-                    entry,
-                    outputByKey,
-                });
-                if (output === undefined) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): no transformed output for ${entry.file}. Check that --project includes the file.`);
-                }
-                return { entry, output };
-            });
-            yield ensureOutputDirectory(location.output);
-            yield ensureTargetDirectories({
-                output: location.output,
-                targets: outputs.map(({ entry }) => entry.target),
-            });
-            yield ensurePhysicalTargets({
-                output: location.output,
-                entries: outputs.map(({ entry }) => entry),
-            });
-            yield ensureTargetFiles(outputs.map(({ entry }) => entry));
-            for (const { entry, output } of outputs) {
-                yield fs_1.default.promises.writeFile(entry.target, formatOutput(output), "utf8");
-            }
-        });
-    }
-    function ensureOutputDirectory(output) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (fs_1.default.existsSync(output) === false) {
-                yield ensureCreatableDirectory(output);
-                yield fs_1.default.promises.mkdir(output, { recursive: true });
-            }
-            else {
-                yield ensureExistingDirectory({
-                    label: "output path",
-                    directory: output,
-                });
-            }
-        });
-    }
-    function ensureTargetDirectories(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const directories = new Map();
-            for (const target of props.targets) {
-                const directory = path_1.default.dirname(target);
-                directories.set(filesystemKey(directory), directory);
-            }
-            for (const directory of directories.values()) {
-                yield ensureOutputAncestorDirectories({
-                    output: props.output,
-                    directory,
-                });
-                if (fs_1.default.existsSync(directory)) {
-                    yield ensureExistingDirectory({
-                        label: "output parent path",
-                        directory,
-                    });
-                }
-            }
-            for (const directory of directories.values()) {
-                try {
-                    yield fs_1.default.promises.mkdir(directory, { recursive: true });
-                }
-                catch (exp) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to create output parent directory ${directory}: ${formatUnknownError(exp)}`);
-                }
-                yield ensureExistingDirectory({
-                    label: "output parent path",
-                    directory,
-                });
-            }
-        });
-    }
-    function ensureCreatableDirectory(directory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parent = yield nearestExistingAncestor(directory);
-            yield ensureExistingDirectoryPath({
-                label: "output parent path",
-                directory: parent,
-            });
-        });
-    }
-    function nearestExistingAncestor(directory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let current = path_1.default.resolve(directory);
-            while (fs_1.default.existsSync(current) === false) {
-                const parent = path_1.default.dirname(current);
-                if (parent === current) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to find existing output parent path: ${directory}`);
-                }
-                current = parent;
-            }
-            return current;
-        });
-    }
-    function ensureOutputAncestorDirectories(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const output = path_1.default.resolve(props.output);
-            const directory = path_1.default.resolve(props.directory);
-            if (isSameOrChildPath(directory, output) === false) {
-                throw new URIError(`Error on TypiaGenerateWizard.generate(): output parent path escapes output directory: ${props.directory}`);
-            }
-            const relative = path_1.default.relative(output, directory);
-            if (relative === "") {
-                return;
-            }
-            let current = output;
-            for (const segment of relative.split(path_1.default.sep)) {
-                current = path_1.default.join(current, segment);
-                let stat;
-                try {
-                    stat = yield fs_1.default.promises.lstat(current);
-                }
-                catch (exp) {
-                    if (isMissingFileError(exp)) {
-                        return;
-                    }
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to inspect output parent path ${current}: ${formatUnknownError(exp)}`);
-                }
-                if (stat.isSymbolicLink()) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output parent path contains a symbolic link: ${current}`);
-                }
-                if (stat.isDirectory() === false) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output parent path is not a directory: ${current}`);
-                }
-            }
-        });
-    }
-    function ensureExistingDirectory(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield ensureExistingDirectoryPath(props);
-        });
-    }
-    function ensureExistingDirectoryPath(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const directory = path_1.default.resolve(props.directory);
-            const parsed = path_1.default.parse(directory);
-            const relative = path_1.default.relative(parsed.root, directory);
-            let current = parsed.root;
-            for (const segment of relative === "" ? [] : relative.split(path_1.default.sep)) {
-                current = path_1.default.join(current, segment);
-                yield ensureExistingDirectorySegment({
-                    label: filesystemKey(current) === filesystemKey(directory)
-                        ? props.label
-                        : `${props.label} ancestor`,
-                    directory: current,
-                });
-            }
-        });
-    }
-    function ensureExistingDirectorySegment(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stat = yield fs_1.default.promises.lstat(props.directory);
-            if (stat.isSymbolicLink()) {
-                throw new URIError(`Error on TypiaGenerateWizard.generate(): ${props.label} is a symbolic link: ${props.directory}`);
-            }
-            if (stat.isDirectory() === false) {
-                throw new URIError(`Error on TypiaGenerateWizard.generate(): ${props.label} is not a directory: ${props.directory}`);
-            }
-        });
-    }
-    function ensurePhysicalTargets(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const output = yield fs_1.default.promises.realpath(props.output);
-            const inputs = new Set();
-            for (const entry of props.entries) {
-                inputs.add(filesystemKey(yield fs_1.default.promises.realpath(entry.file)));
-            }
-            for (const entry of props.entries) {
-                const parent = path_1.default.dirname(entry.target);
-                const directory = yield fs_1.default.promises.realpath(parent);
-                if (isSameOrChildPath(directory, output) === false) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output parent path escapes output directory through a symbolic link: ${parent}`);
-                }
-                const target = path_1.default.join(directory, path_1.default.basename(entry.target));
-                if (inputs.has(filesystemKey(target))) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output file would overwrite input file through a symbolic link: ${entry.target}`);
-                }
-            }
-        });
-    }
-    function ensureTargetFiles(entries) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inputs = new Set();
-            const files = new Map();
-            for (const entry of entries) {
-                inputs.add(fileIdentityKey(yield fs_1.default.promises.stat(entry.file)));
-                files.set(filesystemKey(entry.target), entry);
-            }
-            for (const entry of files.values()) {
-                let stat;
-                try {
-                    stat = yield fs_1.default.promises.lstat(entry.target);
-                }
-                catch (exp) {
-                    if (isMissingFileError(exp)) {
-                        continue;
-                    }
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to inspect output file ${entry.target}: ${formatUnknownError(exp)}`);
-                }
-                if (stat.isFile() === false) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output file path is not a regular file: ${entry.target}`);
-                }
-                if (inputs.has(fileIdentityKey(stat))) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output file would overwrite input file through a physical file alias: ${entry.target}`);
-                }
-                if (stat.nlink > 1) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output file has multiple hard links: ${entry.target}`);
-                }
-            }
-        });
-    }
-    function prepareDirectoryInput(location) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (location.input === undefined) {
-                throw new URIError("Error on TypiaGenerateWizard.generate(): input path is required.");
-            }
-            const input = path_1.default.resolve(location.input);
-            if (fs_1.default.existsSync(input) === false) {
-                throw new URIError(`Error on TypiaGenerateWizard.generate(): input path does not exist: ${input}`);
-            }
-            if ((yield isDirectory(input)) === false) {
-                throw new URIError("Error on TypiaGenerateWizard.generate(): input path is not a directory.");
-            }
-            const files = [];
-            yield gather({
-                location: {
-                    input,
-                    output: location.output,
-                },
-                container: files,
-                from: input,
-                to: location.output,
-            });
-            return files.map((file) => ({
-                file,
-                target: path_1.default.join(location.output, path_1.default.relative(input, file)),
-            }));
-        });
-    }
-    function prepareFileInputs(location) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const targets = new Set();
-            const output = [];
-            for (const input of yield expandFileInputs(location.files, location.output)) {
-                const file = path_1.default.resolve(input);
-                if (fs_1.default.existsSync(file) === false) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): input file does not exist: ${input}`);
-                }
-                else if ((yield isFile(file)) === false) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): input path is not a file: ${input}`);
-                }
-                else if (isDeclarationFile(file)) {
-                    continue;
-                }
-                else if (isSupportedExtension(file) === false) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): input file is not a supported TypeScript source: ${input}`);
-                }
-                const target = path_1.default.join(location.output, path_1.default.basename(file));
-                if (isSamePath(file, target)) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): output file would overwrite input file: ${input}`);
-                }
-                const key = filesystemKey(target);
-                if (targets.has(key)) {
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): duplicate output filename for ${target}`);
-                }
-                targets.add(key);
-                output.push({ file, target });
-            }
-            if (output.length === 0) {
-                throw new URIError("Error on TypiaGenerateWizard.generate(): input files do not include any supported TypeScript source files outside the output directory.");
-            }
-            return output;
-        });
-    }
-    function expandFileInputs(inputs, directory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const output = [];
-            for (const input of inputs) {
-                const pattern = toGlobPattern(input);
-                if ((0, tinyglobby_1.isDynamicPattern)(pattern, { caseSensitiveMatch: true })) {
-                    const matches = yield (0, tinyglobby_1.glob)(pattern, {
-                        absolute: true,
-                        caseSensitiveMatch: isCaseSensitive(),
-                        cwd: process.cwd(),
-                        onlyFiles: true,
-                    });
-                    if (matches.length === 0) {
-                        throw new URIError(`Error on TypiaGenerateWizard.generate(): input pattern does not match any files: ${input}`);
-                    }
-                    output.push(...excludeOutputFiles(matches, directory).filter(isSupportedExtension));
-                }
-                else {
-                    const file = path_1.default.resolve(input);
-                    if (isSameOrChildPath(file, directory) === false) {
-                        output.push(file);
-                    }
-                }
-            }
-            return output;
-        });
-    }
-    function excludeOutputFiles(files, directory) {
-        return files.filter((file) => isSameOrChildPath(file, directory) === false);
-    }
-    function toGlobPattern(input) {
-        return input.replace(/\\/g, "/");
-    }
-    function transformProject(props) {
-        const TtscCompiler = loadTtscCompiler();
-        const result = new TtscCompiler({
-            binary: props.binary,
-            cwd: props.cwd,
-            tsconfig: props.tsconfig,
-        }).transform();
-        if (result.type === "success") {
-            return result.typescript;
-        }
-        if (result.type === "failure") {
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): ${formatDiagnostics(result.diagnostics)}`);
-        }
-        throw new URIError(`Error on TypiaGenerateWizard.generate(): ${formatUnknownError(result.error)}`);
-    }
-    function resolveProjectConfigFile(project) {
-        const resolved = path_1.default.resolve(project);
-        if (fs_1.default.existsSync(resolved) === false) {
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): project path does not exist: ${resolved}`);
-        }
-        const stat = fs_1.default.statSync(resolved);
-        if (stat.isDirectory()) {
-            for (const filename of ["tsconfig.json", "jsconfig.json"]) {
-                const candidate = path_1.default.join(resolved, filename);
-                if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isFile()) {
-                    return resolveRealPath(candidate);
-                }
-            }
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): project directory has no tsconfig.json or jsconfig.json: ${resolved}`);
-        }
-        if (stat.isFile() === false) {
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): project path is not a file: ${resolved}`);
-        }
-        return resolveRealPath(resolved);
-    }
-    function findProjectConfigFile(directory) {
-        let current = path_1.default.resolve(directory);
-        while (true) {
-            for (const filename of ["tsconfig.json", "jsconfig.json"]) {
-                const candidate = path_1.default.join(current, filename);
-                if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isFile()) {
-                    return resolveRealPath(candidate);
-                }
-            }
-            const parent = path_1.default.dirname(current);
-            if (parent === current) {
-                return null;
-            }
-            current = parent;
-        }
-    }
-    function loadTtscCompiler() {
-        const packageRoot = resolveTypiaPackageRoot();
-        const resolved = resolveFromRoots("ttsc", resolveRuntimeRoots(packageRoot));
-        if (resolved === null) {
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to resolve ttsc from the current project, typia package, or workspace root. Run "npm i -D ttsc typescript" before.`);
-        }
-        const imported = (0, module_1.createRequire)(resolved)(resolved);
-        return imported.TtscCompiler;
-    }
-    function resolveTsgoBinary() {
-        const explicit = process.env.TTSC_TSGO_BINARY;
-        if (explicit !== undefined && explicit.length !== 0) {
-            if (path_1.default.isAbsolute(explicit) && fs_1.default.existsSync(explicit)) {
-                return explicit;
-            }
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): TTSC_TSGO_BINARY must be an existing absolute path: ${explicit}`);
-        }
-        const packageRoot = resolveTypiaPackageRoot();
-        const manifest = resolveFromRoots("typescript/package.json", resolveRuntimeRoots(packageRoot));
-        if (manifest === null) {
-            throw new URIError("Error on TypiaGenerateWizard.generate(): unable to resolve typescript from the current project, typia package, or workspace root.");
-        }
-        const platform = `@typescript/typescript-${process.platform}-${process.arch}`;
-        const platformManifest = (0, module_1.createRequire)(manifest).resolve(`${platform}/package.json`);
-        const binary = path_1.default.join(path_1.default.dirname(platformManifest), "lib", process.platform === "win32" ? "tsc.exe" : "tsc");
-        if (fs_1.default.existsSync(binary) === false) {
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): TypeScript-Go executable not found: ${binary}`);
-        }
-        return binary;
-    }
-    function resolveTypiaPackageRoot() {
-        const current = path_1.default.resolve(__dirname);
-        for (const directory of [
-            path_1.default.resolve(current, "..", ".."),
-            path_1.default.resolve(current, ".."),
-        ]) {
-            const file = path_1.default.join(directory, "package.json");
-            if (fs_1.default.existsSync(file) === false) {
-                continue;
-            }
-            try {
-                const pack = JSON.parse(fs_1.default.readFileSync(file, "utf8"));
-                if (pack.name === "typia") {
-                    return directory;
-                }
-            }
-            catch (_a) {
-                continue;
-            }
-        }
-        const resolved = resolveFromRoots("typia/package.json", [
-            process.cwd(),
-            current,
-        ]);
-        if (resolved === null) {
-            throw new URIError("Error on TypiaGenerateWizard.generate(): unable to resolve typia package root.");
-        }
-        return path_1.default.dirname(resolved);
-    }
-    function resolveRuntimeRoots(packageRoot) {
-        return [process.cwd(), packageRoot, path_1.default.resolve(packageRoot, "..", "..")];
-    }
-    function resolveFromRoots(request, roots) {
-        for (const root of roots) {
-            try {
-                return require.resolve(request, { paths: [root] });
-            }
-            catch (_a) {
-                continue;
-            }
-        }
-        return null;
-    }
-    function isDirectory(current) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stat = yield fs_1.default.promises.stat(current);
-            return stat.isDirectory();
-        });
-    }
-    function isFile(current) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stat = yield fs_1.default.promises.stat(current);
-            return stat.isFile();
-        });
-    }
-    function gather(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isSamePath(props.from, props.location.output))
-                return;
-            for (const file of yield fs_1.default.promises.readdir(props.from)) {
-                const next = path_1.default.join(props.from, file);
-                const stat = yield fs_1.default.promises.stat(next);
-                if (stat.isDirectory()) {
-                    yield gather({
-                        location: props.location,
-                        container: props.container,
-                        from: next,
-                        to: path_1.default.join(props.to, file),
-                    });
-                    continue;
-                }
-                if (isSupportedExtension(file)) {
-                    props.container.push(next);
-                }
-            }
-        });
-    }
-    function isSupportedExtension(filename) {
-        const normalized = isCaseSensitive()
-            ? filename
-            : filename.toLowerCase();
-        return TS_PATTERN.test(normalized) && !DTS_PATTERN.test(normalized);
-    }
-    function isDeclarationFile(filename) {
-        const normalized = isCaseSensitive()
-            ? filename
-            : filename.toLowerCase();
-        return DTS_PATTERN.test(normalized);
-    }
-    function formatOutput(output) {
-        return output.startsWith("// @ts-nocheck")
-            ? output
-            : `// @ts-nocheck\n${output}`;
-    }
-    function indexTransformedOutputs(outputs) {
-        const map = new Map();
-        for (const [file, output] of Object.entries(outputs)) {
-            map.set(projectFileKey(file), output);
-        }
-        return map;
-    }
-    function getTransformedOutput(props) {
-        const output = props.outputByKey.get(projectFileKey(projectKey(props.cwd, props.entry.file)));
-        if (output !== undefined) {
-            return output;
-        }
-        const real = resolveRealPath(props.entry.file);
-        if (isSamePath(real, props.entry.file) ||
-            isSameOrChildPath(real, props.cwd) === false) {
-            return undefined;
-        }
-        return props.outputByKey.get(projectFileKey(projectKey(props.cwd, real)));
-    }
-    function projectKey(root, file) {
-        return path_1.default.relative(root, file).replace(/\\/g, "/");
-    }
-    function projectFileKey(file) {
-        return isCaseSensitive() ? file : file.toLowerCase();
-    }
-    function resolveRealPath(file) {
-        try {
-            return fs_1.default.realpathSync(file);
-        }
-        catch (_a) {
-            return file;
-        }
-    }
-    function isSamePath(x, y) {
-        return filesystemKey(x) === filesystemKey(y);
-    }
-    function isSameOrChildPath(file, directory) {
-        const fileKey = filesystemKey(path_1.default.resolve(file));
-        const directoryKey = filesystemKey(path_1.default.resolve(directory));
-        const directoryPrefix = directoryKey.endsWith(path_1.default.sep)
-            ? directoryKey
-            : `${directoryKey}${path_1.default.sep}`;
-        return fileKey === directoryKey || fileKey.startsWith(directoryPrefix);
-    }
-    function filesystemKey(file) {
-        const normalized = path_1.default.normalize(file);
-        return isCaseSensitive() ? normalized : normalized.toLowerCase();
-    }
-    function isCaseSensitive() {
-        return process.platform !== "win32" && process.platform !== "darwin";
-    }
-    function isMissingFileError(exp) {
-        return (typeof exp === "object" &&
-            exp !== null &&
-            "code" in exp &&
-            exp.code === "ENOENT");
-    }
-    function fileIdentityKey(stat) {
-        return `${stat.dev}:${stat.ino}`;
-    }
-    function formatDiagnostics(diagnostics) {
-        return diagnostics.length === 0
-            ? "transformation failed"
-            : diagnostics
-                .map((diag) => { var _a, _b; return [
-                (_a = diag.file) !== null && _a !== void 0 ? _a : "ttsc",
-                diag.line === undefined
-                    ? undefined
-                    : `${diag.line}:${(_b = diag.character) !== null && _b !== void 0 ? _b : 1}`,
-                diag.messageText,
-            ]
-                .filter((part) => part !== undefined && part !== "")
-                .join(": "); })
-                .join("\n");
-    }
-    function formatUnknownError(error) {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        if (typeof error === "object" &&
-            error !== null &&
-            "message" in error &&
-            typeof error.message === "string") {
-            return error.message;
-        }
-        return String(error);
-    }
-})(TypiaGenerateWizard || (TypiaGenerateWizard_2 = TypiaGenerateWizard$2.TypiaGenerateWizard = TypiaGenerateWizard = {}));
-const TS_PATTERN = /\.[cm]?tsx?$/;
-const DTS_PATTERN = /\.d\.[cm]?tsx?$/;
-
-var TypiaGenerateWizard$1 = /*#__PURE__*/_mergeNamespaces({
-    __proto__: null,
-    get TypiaGenerateWizard () { return TypiaGenerateWizard_2; },
-    default: TypiaGenerateWizard$2
-}, [TypiaGenerateWizard$2]);
-
-export { TypiaGenerateWizard$1 as T, TypiaGenerateWizard_2 as TypiaGenerateWizard, TypiaGenerateWizard$2 as default };
-//# sourceMappingURL=TypiaGenerateWizard2.mjs.map