ttsc 0.4.0-dev.20260424 → 0.4.0-dev.20260425

package/README.md

@@ -1,19 +1,21 @@
 # `ttsc`
 
-![banner of ttsc and ttsx](https://private-user-images.githubusercontent.com/13158709/583518390-6df1deb5-9e8c-4f4b-9d0f-eae1cc3bb55c.png?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3NzcwNTQ2NzUsIm5iZiI6MTc3NzA1NDM3NSwicGF0aCI6Ii8xMzE1ODcwOS81ODM1MTgzOTAtNmRmMWRlYjUtOWU4Yy00ZjRiLTlkMGYtZWFlMWNjM2JiNTVjLnBuZz9YLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1DcmVkZW50aWFsPUFLSUFWQ09EWUxTQTUzUFFLNFpBJTJGMjAyNjA0MjQlMkZ1cy1lYXN0LTElMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1EYXRlPTIwMjYwNDI0VDE4MTI1NVomWC1BbXotRXhwaXJlcz0zMDAmWC1BbXotU2lnbmF0dXJlPTEzMzUxNTE4YThlZDYyNDZjYTVjYmRiMmZiYzAwYzYyZTkyNDk4MjVlYmI4OGZkYjE3NDllNWQzY2IxNmRhYWEmWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0JnJlc3BvbnNlLWNvbnRlbnQtdHlwZT1pbWFnZSUyRnBuZyJ9.7MYb2S99lZfQV-BqD09ZrZwdj1C3XDyJ9nkaSEr901M)
+![banner of ttsc](https://raw.githubusercontent.com/samchon/ttsc/refs/heads/master/assets/og.jpg)
 
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/samchon/ttsc/blob/master/LICENSE)
 [![NPM Version](https://img.shields.io/npm/v/ttsc.svg)](https://www.npmjs.com/package/ttsc)
 [![NPM Downloads](https://img.shields.io/npm/dm/ttsc.svg)](https://www.npmjs.com/package/ttsc)
 [![Build Status](https://github.com/samchon/ttsc/workflows/test/badge.svg)](https://github.com/samchon/ttsc/actions?query=workflow%3Atest)
 
-A `typescript-go` compiler host for build-time transforms.
+A `typescript-go` toolchain for compiler-powered transforms and type-safe execution.
 
-- **Build and check**: run the project through the native TypeScript compiler lane.
-- **Transformer support**: load `compilerOptions.plugins` from `tsconfig.json`.
-- **Library author surface**: publish `ttsc` plugins with native backends or JS output hooks.
+- **`ttsc`**: build, check, and transform.
+- **`ttsx`**: execute TypeScript with type checking.
+  - 10x faster than `ts-node`.
+  - type checking that `tsx` does not provide.
+- **transformer support**: compiler-powered libraries, such as `typia`.
 
-`ttsc` is the compiler host used by `ttsx`. Use `ttsc` when you want one project-aware path for type checking, JavaScript emit, transformer loading, and native backend selection.
+> `ttsx` (CLI command) can run existing `typescript@6` projects.
 
 ## Setup
 
@@ -23,18 +25,18 @@ Install the native TypeScript preview package with `ttsc`:
 npm i -D ttsc @typescript/native-preview
 ```
 
-Build, check, or watch the project:
+Run TypeScript directly with `ttsx` (CLI command):
 
 ```bash
-npx ttsc
-npx ttsc --noEmit
-npx ttsc --watch
+npx ttsx src/index.ts
 ```
 
-Transform a single file:
+Build, check, or watch the project with `ttsc`:
 
 ```bash
-npx ttsc transform --file src/index.ts
+npx ttsc
+npx ttsc --noEmit
+npx ttsc --watch
 ```
 
 ## Transformer Configuration
@@ -51,7 +53,7 @@ npx ttsc transform --file src/index.ts
 }
 ```
 
-The same configuration is used by `ttsc` and `ttsx`.
+The same configuration is used by both `ttsc` commands.
 
 ```bash
 # compile
@@ -61,250 +63,65 @@ npx ttsc
 npx ttsx src/index.ts
 ```
 
-This gives compiler-powered libraries one transform path for build-time and runtime execution.
-
-## CLI
+This gives compiler-powered libraries one transform path for both build-time and runtime execution.
 
-```bash
-ttsc [options]
-ttsc transform --file <path> [options]
-ttsc version
-```
+## What Is a Transform?
 
-Common commands:
-
-```bash
-ttsc
-ttsc -p tsconfig.json
-ttsc --noEmit
-ttsc --watch
-ttsc --outDir lib
-ttsc --verbose
-ttsc transform --file src/index.ts
-ttsc transform --file src/index.ts --out tmp/index.js
-```
-
-Supported options:
-
-- `-p, --project <file>`: resolve project settings from this config file.
-- `--tsconfig <file>`: alias for an explicit project config file.
-- `--cwd <dir>`: resolve project-relative paths from another directory.
-- `--emit`: force emitted files during build.
-- `--noEmit`: type check and transform without writing emitted files.
-- `-w, --watch`: rebuild when project files change.
-- `--preserveWatchOutput`: keep watch output on screen.
-- `--outDir <dir>`: override `compilerOptions.outDir`.
-- `--rewrite-mode <mode>`: force a native rewrite backend id.
-- `--quiet`: keep native build output quiet.
-- `--verbose`: print the native build summary and emitted files.
-- `--out <path>`: write single-file transform output to a file.
-- `--binary <path>`: use an explicit native backend binary.
-
-Compatibility aliases:
-
-```bash
-ttsc build
-ttsc check
-```
-
-`ttsc build` is the same project build lane as `ttsc`. `ttsc check` is the same as `ttsc --noEmit`.
-
-## JS API
-
-`ttsc` exposes a small JS API for bundlers, runners, and higher-level tools.
+A transform uses TypeScript types to generate JavaScript before runtime.
 
 ```ts
-import { build, check, transform, version } from "ttsc";
-```
+import typia, { tags } from "typia";
+import { v4 } from "uuid";
 
-Transform one file:
-
-```ts
-import { transform } from "ttsc";
-
-const code = transform({
-  cwd: "/project",
-  file: "/project/src/index.ts",
-  tsconfig: "/project/tsconfig.json",
-});
-```
-
-Build or check a project:
-
-```ts
-import { build, check } from "ttsc";
-
-const built = build({
-  cwd: process.cwd(),
-  tsconfig: "tsconfig.json",
-  emit: true,
-});
-
-if (built.status !== 0) {
-  console.error(built.stderr);
-}
-
-const checked = check({
-  tsconfig: "tsconfig.json",
+const matched: boolean = typia.is<IMember>({
+  id: v4(),
+  email: "samchon.github@gmail.com",
+  age: 30,
 });
-```
-
-`transform()` throws when the native compiler exits with an error. `build()` and `check()` return `{ status, stdout, stderr }`, so callers can decide how to surface compiler failures.
-
-## Transformer Library Authors
-
-Transformer libraries publish a normal tsconfig plugin entry:
-
-```json
-{
-  "compilerOptions": {
-    "plugins": [
-      { "transform": "my-lib/lib/transform" }
-    ]
-  }
-}
-```
-
-The `transform` value may be:
-
-- a package specifier.
-- an absolute path.
-- a relative path from the project root.
-
-The plugin module may export a plugin object directly, a default export, a `plugin` export, or a `createTtscPlugin` factory.
-
-```ts
-import { definePlugin } from "ttsc";
-
-export default definePlugin((config, context) => ({
-  name: "my-lib",
-  native: {
-    mode: "my-lib",
-    binary: require.resolve("my-lib-native/bin/ttsc-my-lib.js"),
-    contractVersion: 1,
-    capabilities: ["rewrite", "diagnostics"],
-  },
-}));
-```
-
-The factory receives:
-
-- `config`: the raw `compilerOptions.plugins[]` entry.
-- `context.binary`: the fallback `ttsc` native binary path.
-- `context.cwd`: the invocation working directory.
-- `context.projectRoot`: the resolved project root.
-- `context.tsconfig`: the resolved config file path.
-
-Keep this Node-side entry small. Use it for package discovery, feature flags, native binary selection, and manifest construction. Put compiler-sensitive work in the native backend.
-
-## Native Backend Contract
-
-A native transform plugin describes the backend that owns type analysis and rewrite work.
-
-```ts
-import { definePlugin } from "ttsc";
-
-export default definePlugin(() => ({
-  name: "my-lib",
-  native: {
-    mode: "my-lib",
-    binary: require.resolve("my-lib-native/bin/ttsc-my-lib.js"),
-    contractVersion: 1,
-    capabilities: ["rewrite", "diagnostics", "assets"],
-  },
-}));
-```
-
-Descriptor shape:
-
-```ts
-interface TtscNativeBackend {
-  mode: string;
-  binary?: string;
-  contractVersion?: 1;
-  capabilities?: readonly string[];
+console.log(matched); // true
+
+interface IMember {
+  id: string & tags.Format<"uuid">;
+  email: string & tags.Format<"email">;
+  age: number &
+    tags.Type<"uint32"> &
+    tags.ExclusiveMinimum<19> &
+    tags.Maximum<100>;
 }
 ```
 
-- `mode` is the rewrite backend id passed to the native compiler process.
-- `binary` points at a consumer-owned native binary.
-- `contractVersion` pins the plugin to the current host protocol.
-- `capabilities` records the backend responsibilities.
-
-The backend is responsible for the work old TypeScript transformer libraries used to do through in-process compiler APIs:
-
-- loading the project through the `typescript-go` lane.
-- finding marker calls such as `typia.is<T>()`.
-- analyzing types through native checker access or a serialized IR.
-- emitting replacement JavaScript.
-- reporting plugin-specific diagnostics.
-- emitting plugin-owned assets when needed.
-
-## JS Output Hooks
-
-For text-level post-processing, a plugin can provide `transformOutput()`.
-
-```ts
-import { definePlugin } from "ttsc";
-
-export default definePlugin((config) => ({
-  name: "banner-plugin",
-  transformOutput(context) {
-    if (context.command === "build") {
-      return `/* generated by ${config.transform} */\n${context.code}`;
-    }
-    return context.code;
-  },
-}));
-```
-
-`transformOutput()` receives JavaScript text after native emit. Use it for:
-
-- banner injection.
-- output string patching.
-- runtime helper import rewrites.
-- consumer-specific output normalization.
-
-Use a native backend for compiler-sensitive work:
-
-- type analysis.
-- AST mutation.
-- call-site recognition.
-- `ts.Program` / `ts.TypeChecker` transformer compatibility.
-
-## Current Constraints
-
-These are current host constraints transformer authors should design around.
-
-- One invocation can select one native `mode` / `binary` pair.
-- Multiple text-only `transformOutput()` plugins can run in order.
-- Passing `plugins` to the JS API replaces the tsconfig plugin list.
-- `transformOutput()` is a JS text hook, not a JS AST hook.
-- The current setup lane is `@typescript/native-preview`.
-
-## Integration Patterns
-
-Consumer library:
-
-- publish a tsconfig plugin entry such as `my-lib/lib/transform`.
-- resolve a consumer-owned native backend binary from that entry.
-- keep type analysis and rewrite logic in the native backend.
-- optionally layer `transformOutput()` for final JavaScript text normalization.
-
-Bundler adapter:
-
-- call `transform()` for per-file rewrites.
-- pass `plugins` when the adapter needs deterministic plugin state.
-- let `ttsc` resolve the native backend instead of spawning it manually.
-
-Runner:
-
-- use `ttsx` for direct execution.
-- reuse the same `compilerOptions.plugins` contract.
-- keep build-time and runtime transform behavior aligned.
+It is transformed into dedicated JavaScript:
+
+> ```js
+> import typia from "typia";
+> import * as __typia_transform__isFormatEmail from "typia/lib/internal/_isFormatEmail";
+> import * as __typia_transform__isFormatUuid from "typia/lib/internal/_isFormatUuid";
+> import * as __typia_transform__isTypeUint32 from "typia/lib/internal/_isTypeUint32";
+> import { v4 } from "uuid";
+>
+> const matched = (() => {
+>   const _io0 = (input) =>
+>     "string" === typeof input.id &&
+>     __typia_transform__isFormatUuid._isFormatUuid(input.id) &&
+>     "string" === typeof input.email &&
+>     __typia_transform__isFormatEmail._isFormatEmail(input.email) &&
+>     "number" === typeof input.age &&
+>     __typia_transform__isTypeUint32._isTypeUint32(input.age) &&
+>     19 < input.age &&
+>     input.age <= 100;
+>   return (input) => "object" === typeof input && null !== input && _io0(input);
+> })()({
+>   id: v4(),
+>   email: "samchon.github@gmai19l.com",
+>   age: 30,
+> });
+> console.log(matched); // true
+> ```
+
+`ttsc` runs this transform during build, and `ttsx` runs through the same transform path during execution.
 
 ## References
 
 - TypeScript runners: [`ts-node`](https://github.com/TypeStrong/ts-node) and [`tsx`](https://github.com/privatenumber/tsx)
 - Transformer tooling: [`ttypescript`](https://github.com/cevek/ttypescript) and [`ts-patch`](https://github.com/nonara/ts-patch)
-- Inspired by: [`typical`](https://github.com/samchon/typical) and [`tsgonest`](https://github.com/samchon/tsgonest)
+- Inspired by: [`typical`](https://github.com/elliots/typical) and [`tsgonest`](https://github.com/tsgonest/tsgonest)

package/lib/index.d.ts

@@ -15,3 +15,4 @@ export * from "./platform";
 export * from "./api";
 export * from "./project";
 export * from "./plugin";
+export * from "./runner/register";

package/lib/index.js

@@ -31,4 +31,5 @@ __exportStar(require("./platform"), exports);
 __exportStar(require("./api"), exports);
 __exportStar(require("./project"), exports);
 __exportStar(require("./plugin"), exports);
+__exportStar(require("./runner/register"), exports);
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;;;;;;;;;;;;;;AAEH,6CAA2B;AAC3B,wCAAsB;AACtB,4CAA0B;AAC1B,2CAAyB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;;;;;;;;;;;;;;AAEH,6CAA2B;AAC3B,wCAAsB;AACtB,4CAA0B;AAC1B,2CAAyB;AACzB,oDAAkC"}

package/lib/runner/cli.d.ts

@@ -0,0 +1 @@
+export declare function main(argv?: readonly string[]): number;

package/lib/runner/cli.js

@@ -0,0 +1,284 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs = __importStar(require("node:fs"));
+const Module = require("node:module");
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const api_1 = require("../api");
+const register_1 = require("./register");
+function main(argv = process.argv.slice(2)) {
+    try {
+        return run(argv);
+    }
+    catch (error) {
+        process.stderr.write(`${formatError(error)}\n`);
+        return 2;
+    }
+}
+function run(argv) {
+    const parsed = parseCLI(argv);
+    if (parsed === "help") {
+        printHelp();
+        return 0;
+    }
+    if (parsed === "version") {
+        process.stdout.write(`${(0, api_1.version)().replace(/^ttsc\b/, "ttsx")}\n`);
+        return 0;
+    }
+    const cwd = path.resolve(parsed.cwd ?? process.cwd());
+    const entry = path.resolve(cwd, parsed.entry);
+    if (!fs.existsSync(entry)) {
+        process.stderr.write(`ttsx: entry not found: ${entry}\n`);
+        return 2;
+    }
+    const prepared = (0, register_1.prepareExecution)(entry, {
+        binary: parsed.binary,
+        cacheDir: parsed.cacheDir,
+        cwd,
+        env: parsed.env,
+        extensions: parsed.extensions,
+        project: parsed.project,
+    });
+    if (prepared.moduleKind === "esm") {
+        return runEsmEntry(parsed, prepared, cwd);
+    }
+    const unregister = (0, register_1.register)({
+        binary: parsed.binary,
+        cacheDir: parsed.cacheDir,
+        cwd,
+        env: parsed.env,
+        extensions: parsed.extensions,
+        project: parsed.project,
+    });
+    process.once("exit", unregister);
+    for (const preload of parsed.preload) {
+        require(resolvePreload(cwd, preload));
+    }
+    process.argv = [process.execPath, entry, ...parsed.passthrough];
+    Module.runMain();
+    return 0;
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function parseCLI(argv) {
+    const preload = [];
+    const passthroughIndex = argv.indexOf("--");
+    const head = passthroughIndex === -1 ? [...argv] : [...argv.slice(0, passthroughIndex)];
+    const passthrough = passthroughIndex === -1 ? [] : [...argv.slice(passthroughIndex + 1)];
+    let binary;
+    let cacheDir;
+    let cwd;
+    let entry;
+    let project;
+    while (head.length !== 0) {
+        const current = head.shift();
+        if (entry) {
+            passthrough.push(current, ...head);
+            break;
+        }
+        switch (current) {
+            case "-h":
+            case "--help":
+                return "help";
+            case "-v":
+            case "--version":
+                return "version";
+            case "-P":
+            case "--project":
+                project = takeValue(current, head);
+                break;
+            case "--cwd":
+                cwd = takeValue(current, head);
+                break;
+            case "--cache-dir":
+                cacheDir = takeValue(current, head);
+                break;
+            case "-r":
+            case "--require":
+                preload.push(takeValue(current, head));
+                break;
+            case "--binary":
+                binary = takeValue(current, head);
+                break;
+            default:
+                if (current.startsWith("--project=")) {
+                    project = current.slice("--project=".length);
+                }
+                else if (current.startsWith("--cwd=")) {
+                    cwd = current.slice("--cwd=".length);
+                }
+                else if (current.startsWith("--cache-dir=")) {
+                    cacheDir = current.slice("--cache-dir=".length);
+                }
+                else if (current.startsWith("--binary=")) {
+                    binary = current.slice("--binary=".length);
+                }
+                else if (current.startsWith("-")) {
+                    throw new Error(`ttsx: unknown option ${current}`);
+                }
+                else {
+                    entry = current;
+                }
+                break;
+        }
+    }
+    if (!entry) {
+        throw new Error("ttsx: entry file is required");
+    }
+    return {
+        binary,
+        cacheDir,
+        cwd,
+        entry,
+        passthrough,
+        preload,
+        project,
+    };
+}
+function printHelp() {
+    process.stdout.write([
+        "ttsx — TypeScript runner provided by ttsc.",
+        "",
+        "Usage:",
+        "  ttsx [options] <entry.ts> [-- <argv...>]",
+        "",
+        "Options:",
+        "  -P, --project <file>   Use an explicit tsconfig.json",
+        "  --cwd <dir>            Resolve entry/project relative to this directory",
+        "  --cache-dir <dir>      Override the compiled JS cache directory",
+        "  --binary <path>        Use an explicit ttsc native binary",
+        "  -r, --require <file>   Preload a module before the entrypoint",
+        "  -h, --help             Show this help",
+        "  -v, --version          Print the runner version",
+        "",
+        "Runtime:",
+        "  CommonJS projects execute in-process via the require hook.",
+        "  ESM projects execute the cached emitted entry in a child Node process.",
+        "",
+        "Examples:",
+        "  ttsx src/index.ts",
+        "  ttsx --project tsconfig.json src/index.ts -- --port 3000",
+    ].join("\n"));
+    process.stdout.write("\n");
+}
+function resolvePreload(cwd, preload) {
+    if (preload.startsWith(".") || preload.startsWith("/") || preload.includes(path.sep)) {
+        return path.resolve(cwd, preload);
+    }
+    return preload;
+}
+function takeValue(flag, rest) {
+    const value = rest.shift();
+    if (!value) {
+        throw new Error(`ttsx: ${flag} requires a value`);
+    }
+    return value;
+}
+function runEsmEntry(parsed, execution, cwd) {
+    fs.mkdirSync(execution.emitDir, { recursive: true });
+    rewriteEsmSpecifiers(execution.emitDir);
+    fs.writeFileSync(path.join(execution.emitDir, "package.json"), JSON.stringify({ type: "module" }), "utf8");
+    const args = [
+        ...parsed.preload.flatMap((preload) => ["-r", resolvePreload(cwd, preload)]),
+        execution.entryFile,
+        ...parsed.passthrough,
+    ];
+    const result = (0, node_child_process_1.spawnSync)(process.execPath, args, {
+        stdio: "inherit",
+        env: process.env,
+        windowsHide: true,
+    });
+    if (result.error) {
+        process.stderr.write(`${result.error.message}\n`);
+        return 1;
+    }
+    return result.status ?? 1;
+}
+function rewriteEsmSpecifiers(root) {
+    const stack = [root];
+    while (stack.length !== 0) {
+        const current = stack.pop();
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const next = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(next);
+                continue;
+            }
+            if (!entry.isFile() || !isJavaScriptOutput(next)) {
+                continue;
+            }
+            const before = fs.readFileSync(next, "utf8");
+            const after = before
+                .replace(/\bfrom\s+(['"])(\.[^'"]+)\1/g, (_, quote, specifier) => `from ${quote}${withResolvableExtension(next, specifier)}${quote}`)
+                .replace(/\bimport\(\s*(['"])(\.[^'"]+)\1\s*\)/g, (_, quote, specifier) => `import(${quote}${withResolvableExtension(next, specifier)}${quote})`);
+            if (after !== before) {
+                fs.writeFileSync(next, after, "utf8");
+            }
+        }
+    }
+}
+function withResolvableExtension(fromFile, specifier) {
+    if (!specifier.startsWith(".")) {
+        return specifier;
+    }
+    if (/\.(?:[cm]?js|json|node)$/i.test(specifier)) {
+        return specifier;
+    }
+    const [pathname, suffix = ""] = splitSpecifierSuffix(specifier);
+    const fromDir = path.dirname(fromFile);
+    for (const extension of [".js", ".mjs", ".cjs"]) {
+        if (fs.existsSync(path.resolve(fromDir, pathname + extension))) {
+            return pathname + extension + suffix;
+        }
+    }
+    return `${specifier}.js`;
+}
+function splitSpecifierSuffix(specifier) {
+    const index = specifier.search(/[?#]/);
+    if (index === -1) {
+        return [specifier];
+    }
+    return [specifier.slice(0, index), specifier.slice(index)];
+}
+function isJavaScriptOutput(filename) {
+    return /\.(?:[cm]?js)$/i.test(filename);
+}
+//# sourceMappingURL=cli.js.map