tsifdef 1.1.8

package/dist/cli/build.js

@@ -0,0 +1,298 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildUnsupportedError = exports.BuildMacroDiagnosticsError = void 0;
+exports.buildProject = buildProject;
+exports.restoreInlineSourcesFor = restoreInlineSourcesFor;
+exports.parseTscOverride = parseTscOverride;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const index_js_1 = require("../core/index.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const source_files_js_1 = require("./source-files.js");
+/** Raised when source files contain macro-structure diagnostics; blocks emit. */
+class BuildMacroDiagnosticsError extends Error {
+    files;
+    code = "build-macro-diagnostics";
+    constructor(files) {
+        super(`Cannot build because ${files.length} source file(s) have macro diagnostics.`);
+        this.files = files;
+        this.name = "BuildMacroDiagnosticsError";
+    }
+}
+exports.BuildMacroDiagnosticsError = BuildMacroDiagnosticsError;
+/** Raised for tsconfig shapes that projected compilation cannot support. */
+class BuildUnsupportedError extends Error {
+    code = "build-unsupported";
+    constructor(message) {
+        super(message);
+        this.name = "BuildUnsupportedError";
+    }
+}
+exports.BuildUnsupportedError = BuildUnsupportedError;
+const macroFilePattern = /(?:\.d)?\.(?:ts|tsx|mts|cts)$/i;
+/** Stable hash of the enabled macro set; changes exactly when the Profile does. */
+function hashProfile(profile) {
+    const names = Object.keys(profile.definitions).sort();
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(names)).digest("hex");
+}
+/** True when `path` is at or below `root` (never escapes via `..`). */
+function isInsideRoot(root, path) {
+    const value = (0, node_path_1.relative)(root, path);
+    return value !== ".." && !value.startsWith(`..${node_path_1.sep}`) && !(0, node_path_1.isAbsolute)(value);
+}
+/**
+ * Compile the project by projected compilation: hijack the CompilerHost so the
+ * TypeScript compiler reads equal-length masked text under the ORIGINAL file
+ * names, then drive `program.emit()`. Because the compiler never sees a shadow
+ * path, emitted sourcemap `sources`, `.d.ts`, and diagnostic paths point at the
+ * original sources with no post-processing.
+ */
+async function buildProject(options) {
+    const ts = (await import("typescript")).default;
+    const projectRoot = (0, node_path_1.resolve)(options.projectRoot);
+    const configPath = (0, node_path_1.resolve)(projectRoot, options.project);
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.error !== undefined)
+        throw new Error(formatConfigDiagnostic(ts, configFile.error));
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, (0, node_path_1.dirname)(configPath), undefined, configPath);
+    if (parsed.errors.length > 0) {
+        throw new Error(parsed.errors.map((item) => formatConfigDiagnostic(ts, item)).join("\n"));
+    }
+    if (options.compilerOptionsOverride !== undefined) {
+        Object.assign(parsed.options, options.compilerOptionsOverride);
+    }
+    assertSupported(parsed.options, parsed.projectReferences);
+    // Incremental builds key their .tsbuildinfo off disk file versions, which do
+    // not change when only the Profile changes. Compare a sidecar profile hash and
+    // discard stale build info so a Profile switch forces a full rebuild (§8.1).
+    const useIncremental = parsed.options.incremental === true || parsed.options.composite === true;
+    const buildInfoPath = useIncremental ? ts.getTsBuildInfoEmitOutputFilePath(parsed.options) : undefined;
+    const profileHash = hashProfile(options.profile);
+    const profileHashPath = buildInfoPath === undefined ? undefined : `${buildInfoPath}.profilehash`;
+    if (buildInfoPath !== undefined && profileHashPath !== undefined) {
+        let stored;
+        try {
+            stored = (0, node_fs_1.readFileSync)(profileHashPath, "utf8");
+        }
+        catch {
+            stored = undefined;
+        }
+        if (stored !== profileHash) {
+            (0, node_fs_1.rmSync)(buildInfoPath, { force: true });
+        }
+    }
+    // Cache projected text and collect macro diagnostics per file. The compiler
+    // may read a file more than once; project it only on the first read.
+    const projected = new Map();
+    const failures = [];
+    const readProjected = (fileName) => {
+        if (!macroFilePattern.test(fileName))
+            return ts.sys.readFile(fileName);
+        const absolute = (0, node_path_1.resolve)(fileName);
+        const cached = projected.get(absolute);
+        if (cached !== undefined)
+            return cached;
+        let bytes;
+        try {
+            bytes = (0, node_fs_1.readFileSync)(absolute);
+        }
+        catch {
+            return undefined;
+        }
+        const result = (0, index_js_1.projectSource)((0, source_files_js_1.decodeTypeScriptText)(bytes), options.profile.definitions);
+        if (result.diagnostics.length > 0) {
+            failures.push({ file: (0, node_path_1.relative)(projectRoot, absolute), diagnostics: result.diagnostics });
+        }
+        projected.set(absolute, result.projectedText);
+        if (options.emitProjectionDir !== undefined && isInsideRoot(projectRoot, absolute)) {
+            const dumpPath = (0, node_path_1.resolve)(options.emitProjectionDir, (0, node_path_1.relative)(projectRoot, absolute));
+            try {
+                (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(dumpPath), { recursive: true });
+                (0, node_fs_1.writeFileSync)(dumpPath, result.projectedText, "utf8");
+            }
+            catch {
+                // The dump is best-effort auditing; never fail the build over it.
+            }
+        }
+        return result.projectedText;
+    };
+    // Override only readFile for masking, and let the host's own getSourceFile run:
+    // it reads through our masked readFile and sets SourceFile.version the way
+    // TypeScript persists it in .tsbuildinfo, so cross-process incremental reuse
+    // works. (A custom version here breaks that reuse.) A Profile switch changes
+    // the masked text, hence the version, and the profilehash sidecar forces a
+    // full rebuild regardless.
+    const host = useIncremental
+        ? ts.createIncrementalCompilerHost(parsed.options)
+        : ts.createCompilerHost(parsed.options, true);
+    host.readFile = readProjected;
+    const programReferences = parsed.projectReferences === undefined ? {} : { projectReferences: parsed.projectReferences };
+    let emit;
+    let collectDiagnostics;
+    if (useIncremental) {
+        const builder = ts.createIncrementalProgram({
+            rootNames: parsed.fileNames,
+            options: parsed.options,
+            host,
+            ...programReferences,
+        });
+        emit = builder.emit.bind(builder);
+        // Use the builder's incremental diagnostics: semantic results are cached
+        // per file in .tsbuildinfo and reused across processes for unchanged files.
+        collectDiagnostics = () => [
+            ...builder.getConfigFileParsingDiagnostics(),
+            ...builder.getOptionsDiagnostics(),
+            ...builder.getGlobalDiagnostics(),
+            ...builder.getSyntacticDiagnostics(),
+            ...builder.getSemanticDiagnostics(),
+        ];
+    }
+    else {
+        const program = ts.createProgram({
+            rootNames: parsed.fileNames,
+            options: parsed.options,
+            host,
+            ...programReferences,
+        });
+        emit = program.emit.bind(program);
+        collectDiagnostics = () => ts.getPreEmitDiagnostics(program);
+    }
+    // Macro-structure diagnostics are surfaced from projection; block emit.
+    if (failures.length > 0)
+        throw new BuildMacroDiagnosticsError(failures);
+    const preEmit = collectDiagnostics();
+    const hasErrors = preEmit.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    if (preEmit.length > 0) {
+        process.stderr.write((0, diagnostics_js_1.formatCliDiagnostics)(ts, preEmit, projectRoot));
+    }
+    const noEmit = parsed.options.noEmit === true;
+    const blockedByErrors = hasErrors && parsed.options.noEmitOnError === true;
+    if (noEmit || blockedByErrors) {
+        return { emitted: false, outputFiles: [], hasErrors };
+    }
+    const outputFiles = [];
+    const restoreSources = parsed.options.inlineSources === true;
+    const emitResult = emit(undefined, (fileName, text, writeByteOrderMark) => {
+        const output = restoreSources ? restoreInlineSourcesFor(fileName, text) : text;
+        ts.sys.writeFile(fileName, output, writeByteOrderMark);
+        outputFiles.push((0, node_path_1.resolve)(fileName));
+    });
+    const emitDiagnostics = emitResult.diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    if (emitResult.diagnostics.length > 0) {
+        process.stderr.write((0, diagnostics_js_1.formatCliDiagnostics)(ts, emitResult.diagnostics, projectRoot));
+    }
+    // Record the Profile hash next to the build info so the next run detects a
+    // Profile switch and forces a full rebuild.
+    if (profileHashPath !== undefined && !emitResult.emitSkipped) {
+        try {
+            (0, node_fs_1.writeFileSync)(profileHashPath, profileHash, "utf8");
+        }
+        catch {
+            // A missing hash sidecar simply forces a full rebuild next time.
+        }
+    }
+    outputFiles.sort((left, right) => left.localeCompare(right, "en"));
+    return {
+        emitted: !emitResult.emitSkipped,
+        outputFiles,
+        hasErrors: hasErrors || emitDiagnostics.length > 0,
+    };
+}
+/**
+ * With `inlineSources`, tsc embeds the text it read — which is our masked
+ * projection — into the sourcemap's `sourcesContent`. Replace each embedded
+ * entry with the original disk text so debuggers show real source, keeping the
+ * equal-length projection everywhere else. Handles both external `.map` files
+ * and inline base64 `sourceMappingURL` data URIs.
+ */
+function restoreInlineSourcesFor(fileName, text) {
+    if (/\.map$/i.test(fileName)) {
+        return rewriteMapSourcesContent(fileName, text);
+    }
+    const inlinePattern = /(\/\/[#@]\s*sourceMappingURL=data:application\/json;(?:charset=[^;]+;)?base64,)([A-Za-z0-9+/=]+)/;
+    const match = inlinePattern.exec(text);
+    if (match === undefined || match === null)
+        return text;
+    const decoded = Buffer.from(match[2], "base64").toString("utf8");
+    const rewritten = rewriteMapSourcesContent(fileName, decoded);
+    const encoded = Buffer.from(rewritten, "utf8").toString("base64");
+    return text.replace(inlinePattern, `${match[1]}${encoded}`);
+}
+/** Rewrite a sourcemap JSON's `sourcesContent` from disk originals. */
+function rewriteMapSourcesContent(mapFileName, mapText) {
+    let map;
+    try {
+        map = JSON.parse(mapText);
+    }
+    catch {
+        return mapText;
+    }
+    if (!Array.isArray(map.sources) || map.sources.length === 0)
+        return mapText;
+    const base = (0, node_path_1.dirname)((0, node_path_1.resolve)(mapFileName));
+    const root = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
+    map.sourcesContent = map.sources.map((source) => {
+        try {
+            return (0, source_files_js_1.decodeTypeScriptText)((0, node_fs_1.readFileSync)((0, node_path_1.resolve)(base, root, source)));
+        }
+        catch {
+            return null;
+        }
+    });
+    return JSON.stringify(map);
+}
+/** Reject tsconfig shapes incompatible with per-file projected compilation. */
+function assertSupported(options, projectReferences) {
+    if (typeof options.outFile === "string" && options.outFile !== "") {
+        throw new BuildUnsupportedError("tsifdef build does not support 'outFile'; per-file projection is incompatible with single-file bundle output.");
+    }
+    if (projectReferences !== undefined && projectReferences.length > 0) {
+        throw new BuildUnsupportedError("tsifdef build does not support project references (tsc -b / composite solutions); run tsifdef build per referenced project instead.");
+    }
+}
+function formatConfigDiagnostic(ts, diagnostic) {
+    return `TS${diagnostic.code}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
+}
+/**
+ * Parse tsc-style flags (e.g. `--module commonjs --outDir dist`) into a
+ * `CompilerOptions` override using TypeScript's own command-line parser, so the
+ * CLI never reimplements option parsing. Only compiler options are honored;
+ * file names in the flags are ignored.
+ *
+ * Path-valued options are resolved to absolute paths against `cwd`. This is
+ * required for cross-run incremental correctness: `.tsbuildinfo` stores output
+ * paths, and a relative `outDir` / `tsBuildInfoFile` resolves against a
+ * different base on the next run, defeating the up-to-date check.
+ */
+async function parseTscOverride(args, cwd = process.cwd()) {
+    if (args.length === 0)
+        return {};
+    const ts = (await import("typescript")).default;
+    const parsed = ts.parseCommandLine([...args]);
+    if (parsed.errors.length > 0) {
+        throw new BuildUnsupportedError(parsed.errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n"));
+    }
+    const options = parsed.options;
+    for (const key of ["outDir", "outFile", "tsBuildInfoFile", "declarationDir", "rootDir"]) {
+        const value = options[key];
+        if (typeof value === "string" && value !== "" && !(0, node_path_1.isAbsolute)(value)) {
+            options[key] = (0, node_path_1.resolve)(cwd, value);
+        }
+    }
+    return options;
+}
+//# sourceMappingURL=build.js.map

package/dist/cli/config.d.ts

@@ -0,0 +1,30 @@
+import type { MacroDefinitions } from "../core/expression.js";
+export type TsIfDefConfigErrorCode = "config-read-failed" | "config-invalid-json" | "config-invalid-shape" | "config-invalid-name";
+export declare class TsIfDefConfigError extends Error {
+    readonly code: TsIfDefConfigErrorCode;
+    constructor(code: TsIfDefConfigErrorCode, message: string, options?: ErrorOptions);
+}
+export interface ProfileFile {
+    readonly path: string;
+    readonly fileName: string;
+    readonly definitions: MacroDefinitions;
+}
+export interface ProjectConfiguration {
+    readonly packagePath: string;
+    readonly profilePath: string;
+}
+/** Load the single Profile pointer from the current project's package.json. */
+export declare function loadProjectConfiguration(projectRoot: string): Promise<ProjectConfiguration>;
+/**
+ * Discover an optional VSCode project configuration.
+ *
+ * An ordinary TypeScript project without a package.json or `tsifdef` property
+ * has not opted into TSIfDef. Explicit but malformed TSIfDef configuration
+ * remains an error so configuration mistakes are visible.
+ */
+export declare function discoverProjectConfiguration(projectRoot: string): Promise<ProjectConfiguration | undefined>;
+/** Load one explicitly selected Profile file containing enabled macro names. */
+export declare function loadProfileFile(path: string): Promise<ProfileFile>;
+/** Parse a Profile JSON array of enabled macro names. */
+export declare function parseProfileFile(text: string, path: string): ProfileFile;
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/config.js

@@ -0,0 +1,135 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsIfDefConfigError = void 0;
+exports.loadProjectConfiguration = loadProjectConfiguration;
+exports.discoverProjectConfiguration = discoverProjectConfiguration;
+exports.loadProfileFile = loadProfileFile;
+exports.parseProfileFile = parseProfileFile;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+class TsIfDefConfigError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "TsIfDefConfigError";
+    }
+}
+exports.TsIfDefConfigError = TsIfDefConfigError;
+const namePattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Load the single Profile pointer from the current project's package.json. */
+async function loadProjectConfiguration(projectRoot) {
+    const packagePath = (0, node_path_1.resolve)(projectRoot, "package.json");
+    const value = await readPackageJson(packagePath);
+    return parseProjectConfiguration(value, packagePath);
+}
+/**
+ * Discover an optional VSCode project configuration.
+ *
+ * An ordinary TypeScript project without a package.json or `tsifdef` property
+ * has not opted into TSIfDef. Explicit but malformed TSIfDef configuration
+ * remains an error so configuration mistakes are visible.
+ */
+async function discoverProjectConfiguration(projectRoot) {
+    const packagePath = (0, node_path_1.resolve)(projectRoot, "package.json");
+    let value;
+    try {
+        value = await readPackageJson(packagePath);
+    }
+    catch (error) {
+        if (isMissingFileError(error))
+            return undefined;
+        throw error;
+    }
+    if (value !== null
+        && typeof value === "object"
+        && !Object.prototype.hasOwnProperty.call(value, "tsifdef")) {
+        return undefined;
+    }
+    return parseProjectConfiguration(value, packagePath);
+}
+async function readPackageJson(packagePath) {
+    try {
+        return JSON.parse((await (0, promises_1.readFile)(packagePath, "utf8")).replace(/^\uFEFF/, ""));
+    }
+    catch (error) {
+        throw new TsIfDefConfigError("config-invalid-json", `Cannot read a valid package.json at '${packagePath}'.`, { cause: error });
+    }
+}
+function parseProjectConfiguration(value, packagePath) {
+    const pointer = value !== null && typeof value === "object"
+        ? value.tsifdef
+        : undefined;
+    if (typeof pointer !== "string" || pointer.trim() === "") {
+        throw new TsIfDefConfigError("config-invalid-shape", `package.json at '${packagePath}' must contain a non-empty string 'tsifdef' Profile path.`);
+    }
+    return Object.freeze({
+        packagePath,
+        profilePath: (0, node_path_1.resolve)((0, node_path_1.dirname)(packagePath), pointer),
+    });
+}
+function isMissingFileError(error) {
+    if (!(error instanceof TsIfDefConfigError))
+        return false;
+    const cause = error.cause;
+    return (cause !== null
+        && typeof cause === "object"
+        && "code" in cause
+        && cause.code === "ENOENT");
+}
+/** Load one explicitly selected Profile file containing enabled macro names. */
+async function loadProfileFile(path) {
+    const resolvedPath = (0, node_path_1.resolve)(path);
+    let text;
+    try {
+        text = await (0, promises_1.readFile)(resolvedPath, "utf8");
+    }
+    catch (error) {
+        throw new TsIfDefConfigError("config-read-failed", `Cannot read TSIfDef Profile '${resolvedPath}'.`, { cause: error });
+    }
+    return parseProfileFile(text, resolvedPath);
+}
+/** Parse a Profile JSON array of enabled macro names. */
+function parseProfileFile(text, path) {
+    let value;
+    try {
+        value = JSON.parse(text.replace(/^\uFEFF/, ""));
+    }
+    catch (error) {
+        throw new TsIfDefConfigError("config-invalid-json", `TSIfDef Profile '${path}' is not valid JSON.`, { cause: error });
+    }
+    if (!Array.isArray(value)) {
+        throw new TsIfDefConfigError("config-invalid-shape", `TSIfDef Profile '${path}' must be an array of enabled macro names.`);
+    }
+    const definitions = Object.create(null);
+    for (const macro of value) {
+        if (typeof macro !== "string" || !namePattern.test(macro)) {
+            throw new TsIfDefConfigError("config-invalid-name", `TSIfDef Profile '${path}' contains invalid macro name '${String(macro)}'.`);
+        }
+        // A repeated macro name is semantically harmless (enabling X twice is
+        // enabling X). Tolerate it by de-duplicating rather than rejecting the whole
+        // Profile — a generated Profile with an accidental duplicate must not
+        // collapse projection and break every editor diagnostic.
+        definitions[macro] = true;
+    }
+    const resolvedPath = (0, node_path_1.resolve)(path);
+    return Object.freeze({
+        path: resolvedPath,
+        fileName: (0, node_path_1.basename)(resolvedPath),
+        definitions: Object.freeze(definitions),
+    });
+}
+//# sourceMappingURL=config.js.map

package/dist/cli/diagnostics.d.ts

@@ -0,0 +1,3 @@
+export declare function diagnosticHost(ts: typeof import("typescript"), projectRoot: string): import("typescript").FormatDiagnosticsHost;
+export declare function formatCliDiagnostics(ts: typeof import("typescript"), diagnostics: readonly import("typescript").Diagnostic[], projectRoot: string): string;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/cli/diagnostics.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnosticHost = diagnosticHost;
+exports.formatCliDiagnostics = formatCliDiagnostics;
+function diagnosticHost(ts, projectRoot) {
+    return {
+        getCurrentDirectory: () => projectRoot,
+        getCanonicalFileName: (fileName) => fileName,
+        getNewLine: () => ts.sys.newLine,
+    };
+}
+function formatCliDiagnostics(ts, diagnostics, projectRoot) {
+    const host = diagnosticHost(ts, projectRoot);
+    return process.stderr.isTTY === true
+        ? ts.formatDiagnosticsWithColorAndContext(diagnostics, host)
+        : ts.formatDiagnostics(diagnostics, host);
+}
+//# sourceMappingURL=diagnostics.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./build.js";
+export * from "./config.js";
+export * from "./precompile.js";
+export * from "./source-files.js";
+export * from "./watch.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,35 @@
+"use strict";
+// Copyright (C) 2026 Tencent. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./build.js"), exports);
+__exportStar(require("./config.js"), exports);
+__exportStar(require("./precompile.js"), exports);
+__exportStar(require("./source-files.js"), exports);
+__exportStar(require("./watch.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/cli/main.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+export declare const CliExitCode: {
+    readonly success: 0;
+    readonly diagnostics: 1;
+    readonly failure: 2;
+};
+/** Run the TSIfDef CLI: `build` for projected compilation, else legacy precompile. */
+export declare function runCli(args: readonly string[], cwd?: string): Promise<number>;
+//# sourceMappingURL=main.d.ts.map