tsifdef 1.1.8

package/dist/cli/watch.js

@@ -0,0 +1,183 @@
+"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.watchProject = watchProject;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const index_js_1 = require("../core/index.js");
+const build_js_1 = require("./build.js");
+const config_js_1 = require("./config.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const source_files_js_1 = require("./source-files.js");
+const macroFilePattern = /(?:\.d)?\.(?:ts|tsx|mts|cts)$/i;
+/**
+ * Watch mode for projected compilation. A `createWatchCompilerHost` drives
+ * incremental rebuilds with the same equal-length masking as one-shot builds.
+ * The Profile file is watched separately; any change tears down the current
+ * WatchProgram and rebuilds it in full under the new Profile.
+ */
+async function watchProject(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);
+    }
+    assertWatchSupported(parsed.options, parsed.projectReferences);
+    let currentWatch;
+    let profileWatcher;
+    let reloadTimer;
+    let closed = false;
+    const startWatchProgram = (definitions) => {
+        const macroDiagnostics = new Map();
+        const readProjected = (fileName) => {
+            if (!macroFilePattern.test(fileName))
+                return ts.sys.readFile(fileName);
+            const absolute = (0, node_path_1.resolve)(fileName);
+            let bytes;
+            try {
+                bytes = (0, node_fs_1.readFileSync)(absolute);
+            }
+            catch {
+                macroDiagnostics.delete(absolute);
+                return undefined;
+            }
+            const result = (0, index_js_1.projectSource)((0, source_files_js_1.decodeTypeScriptText)(bytes), definitions);
+            if (result.diagnostics.length > 0)
+                macroDiagnostics.set(absolute, result.diagnostics);
+            else
+                macroDiagnostics.delete(absolute);
+            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 {
+                    // Projection dump is best-effort.
+                }
+            }
+            return result.projectedText;
+        };
+        const host = ts.createWatchCompilerHost(configPath, options.compilerOptionsOverride ?? undefined, ts.sys, ts.createEmitAndSemanticDiagnosticsBuilderProgram, (diagnostic) => {
+            process.stderr.write(`${ts.flattenDiagnosticMessageText(diagnostic.messageText, ts.sys.newLine)}${ts.sys.newLine}`);
+        }, () => {
+            // Suppress the periodic "watching for changes" status lines.
+        });
+        const originalRead = host.readFile?.bind(host);
+        host.readFile = (fileName, encoding) => {
+            const projected = readProjected(fileName);
+            if (projected !== undefined)
+                return projected;
+            return originalRead?.(fileName, encoding);
+        };
+        // Take over emit so we can restore inlineSources, collect outputs, and skip
+        // emit for files with macro-structure errors without killing the watcher.
+        host.afterProgramCreate = (builderProgram) => {
+            const compilerOptions = builderProgram.getCompilerOptions();
+            const restoreSources = compilerOptions.inlineSources === true;
+            const outputFiles = [];
+            const preEmit = ts.getPreEmitDiagnostics(builderProgram.getProgram());
+            const hasTypeErrors = preEmit.some((d) => d.category === ts.DiagnosticCategory.Error);
+            for (const diagnostic of preEmit) {
+                process.stderr.write((0, diagnostics_js_1.formatCliDiagnostics)(ts, [diagnostic], projectRoot));
+            }
+            for (const [file, diagnostics] of macroDiagnostics) {
+                for (const diagnostic of diagnostics) {
+                    process.stderr.write(`${file}:${diagnostic.range.start}: ${diagnostic.message}${ts.sys.newLine}`);
+                }
+            }
+            const blockEmit = macroDiagnostics.size > 0 || (hasTypeErrors && compilerOptions.noEmitOnError === true);
+            if (!blockEmit && compilerOptions.noEmit !== true) {
+                builderProgram.emit(undefined, (fileName, text, writeByteOrderMark) => {
+                    const output = restoreSources ? (0, build_js_1.restoreInlineSourcesFor)(fileName, text) : text;
+                    ts.sys.writeFile(fileName, output, writeByteOrderMark);
+                    outputFiles.push((0, node_path_1.resolve)(fileName));
+                });
+            }
+            outputFiles.sort((left, right) => left.localeCompare(right, "en"));
+            options.onBuild?.({
+                outputFiles,
+                macroDiagnostics: new Map(macroDiagnostics),
+                hasErrors: hasTypeErrors || macroDiagnostics.size > 0,
+            });
+        };
+        const watch = ts.createWatchProgram(host);
+        return { close: () => watch.close() };
+    };
+    const reloadProfile = () => {
+        if (closed)
+            return;
+        void (0, config_js_1.loadProfileFile)(options.profilePath)
+            .then((profile) => {
+            if (closed)
+                return;
+            currentWatch?.close();
+            currentWatch = startWatchProgram(profile.definitions);
+            options.onProfileReload?.(profile);
+        })
+            .catch((error) => {
+            process.stderr.write(`${error instanceof Error ? error.message : String(error)}${ts.sys.newLine}`);
+        });
+    };
+    const initialProfile = await (0, config_js_1.loadProfileFile)(options.profilePath);
+    currentWatch = startWatchProgram(initialProfile.definitions);
+    // Watch the Profile file itself; tsc never watches non-TypeScript inputs.
+    try {
+        profileWatcher = (0, node_fs_1.watch)(options.profilePath, () => {
+            if (reloadTimer !== undefined)
+                clearTimeout(reloadTimer);
+            // Debounce editor save bursts (write + rename can fire several events).
+            reloadTimer = setTimeout(reloadProfile, 50);
+        });
+    }
+    catch {
+        // If the Profile file cannot be watched (e.g. on some platforms), the CLI
+        // still watches sources; the user can restart to pick up a Profile change.
+    }
+    return {
+        close: () => {
+            closed = true;
+            if (reloadTimer !== undefined)
+                clearTimeout(reloadTimer);
+            profileWatcher?.close();
+            currentWatch?.close();
+        },
+    };
+}
+/** Keep watch-mode support aligned with one-shot build. */
+function assertWatchSupported(options, projectReferences) {
+    if (typeof options.outFile === "string" && options.outFile !== "") {
+        throw new build_js_1.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 build_js_1.BuildUnsupportedError("tsifdef build does not support project references (tsc -b / composite solutions); run tsifdef build per referenced project instead.");
+    }
+}
+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);
+}
+function formatConfigDiagnostic(ts, diagnostic) {
+    return `TS${diagnostic.code}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
+}
+//# sourceMappingURL=watch.js.map

package/dist/core/conditional.d.ts

@@ -0,0 +1,18 @@
+import { type ExpressionDiagnostic, type MacroDefinitions } from "./expression.js";
+import { type Directive, type ScannerDiagnostic, type SourceRange } from "./scanner.js";
+export type ConditionalDiagnosticCode = "active-error" | "unexpected-directive-argument";
+export interface ConditionalDiagnostic {
+    readonly code: ConditionalDiagnosticCode;
+    readonly message: string;
+    readonly range: SourceRange;
+}
+export type MacroDiagnostic = ScannerDiagnostic | ExpressionDiagnostic | ConditionalDiagnostic;
+export interface ConditionalAnalysisResult {
+    readonly directives: readonly Directive[];
+    readonly directiveRanges: readonly SourceRange[];
+    readonly inactiveRanges: readonly SourceRange[];
+    readonly diagnostics: readonly MacroDiagnostic[];
+}
+/** Analyze conditional groups without modifying the source text. */
+export declare function analyzeConditionals(source: string, definitions: MacroDefinitions): ConditionalAnalysisResult;
+//# sourceMappingURL=conditional.d.ts.map

package/dist/core/conditional.js

@@ -0,0 +1,126 @@
+"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.analyzeConditionals = analyzeConditionals;
+const expression_js_1 = require("./expression.js");
+const scanner_js_1 = require("./scanner.js");
+/** Analyze conditional groups without modifying the source text. */
+function analyzeConditionals(source, definitions) {
+    const scanned = (0, scanner_js_1.scanDirectives)(source);
+    const diagnostics = [...scanned.diagnostics];
+    const inactiveRanges = [];
+    const stack = [];
+    let cursor = 0;
+    let currentActive = true;
+    for (const directive of scanned.directives) {
+        if (!currentActive) {
+            appendRange(inactiveRanges, { start: cursor, end: directive.range.start });
+        }
+        switch (directive.kind) {
+            case "if": {
+                const condition = evaluateDirectiveExpression(directive, definitions, diagnostics);
+                stack.push({
+                    parentActive: currentActive,
+                    branchTaken: condition,
+                    currentActive: currentActive && condition,
+                    sawElse: false,
+                });
+                currentActive = stack.at(-1).currentActive;
+                break;
+            }
+            case "elif": {
+                const condition = evaluateDirectiveExpression(directive, definitions, diagnostics);
+                const frame = stack.at(-1);
+                if (frame !== undefined) {
+                    frame.currentActive =
+                        !frame.sawElse && frame.parentActive && !frame.branchTaken && condition;
+                    if (!frame.sawElse) {
+                        frame.branchTaken ||= condition;
+                    }
+                    currentActive = frame.currentActive;
+                }
+                break;
+            }
+            case "else": {
+                reportUnexpectedArgument(directive, diagnostics);
+                const frame = stack.at(-1);
+                if (frame !== undefined) {
+                    frame.currentActive =
+                        !frame.sawElse && frame.parentActive && !frame.branchTaken;
+                    if (!frame.sawElse) {
+                        frame.sawElse = true;
+                        frame.branchTaken = true;
+                    }
+                    currentActive = frame.currentActive;
+                }
+                break;
+            }
+            case "endif":
+                reportUnexpectedArgument(directive, diagnostics);
+                if (stack.length > 0) {
+                    stack.pop();
+                    currentActive = stack.at(-1)?.currentActive ?? true;
+                }
+                break;
+            case "error":
+                if (currentActive) {
+                    diagnostics.push({
+                        code: "active-error",
+                        message: directive.argument || "#error directive is active.",
+                        range: directive.argumentRange ?? directive.keywordRange,
+                    });
+                }
+                break;
+        }
+        cursor = directive.range.end;
+    }
+    if (!currentActive) {
+        appendRange(inactiveRanges, { start: cursor, end: source.length });
+    }
+    diagnostics.sort((left, right) => left.range.start - right.range.start);
+    return {
+        directives: scanned.directives,
+        directiveRanges: scanned.directiveRanges,
+        inactiveRanges,
+        diagnostics,
+    };
+}
+function evaluateDirectiveExpression(directive, definitions, diagnostics) {
+    const result = (0, expression_js_1.evaluateMacroExpression)(directive.argument, definitions, directive.argumentRange?.start ?? directive.keywordRange.end);
+    diagnostics.push(...result.diagnostics);
+    return result.value;
+}
+function reportUnexpectedArgument(directive, diagnostics) {
+    if (directive.argumentRange !== null) {
+        diagnostics.push({
+            code: "unexpected-directive-argument",
+            message: `#${directive.kind} does not accept an argument.`,
+            range: directive.argumentRange,
+        });
+    }
+}
+function appendRange(ranges, range) {
+    if (range.start >= range.end) {
+        return;
+    }
+    const previous = ranges.at(-1);
+    if (previous !== undefined && previous.end === range.start) {
+        ranges[ranges.length - 1] = { start: previous.start, end: range.end };
+    }
+    else {
+        ranges.push(range);
+    }
+}
+//# sourceMappingURL=conditional.js.map

package/dist/core/expression.d.ts

@@ -0,0 +1,44 @@
+import type { SourceRange } from "./scanner.js";
+export type MacroDefinitions = Readonly<Record<string, boolean>>;
+export type MacroExpression = IdentifierExpression | DefinedExpression | NotExpression | LogicalExpression;
+export interface IdentifierExpression {
+    readonly kind: "identifier";
+    readonly name: string;
+    readonly range: SourceRange;
+}
+export interface DefinedExpression {
+    readonly kind: "defined";
+    readonly name: string;
+    readonly range: SourceRange;
+    readonly nameRange: SourceRange;
+}
+export interface NotExpression {
+    readonly kind: "not";
+    readonly operand: MacroExpression;
+    readonly range: SourceRange;
+}
+export interface LogicalExpression {
+    readonly kind: "logical";
+    readonly operator: "&&" | "||";
+    readonly left: MacroExpression;
+    readonly right: MacroExpression;
+    readonly range: SourceRange;
+}
+export type ExpressionDiagnosticCode = "expected-expression" | "expected-defined-parenthesis" | "expected-defined-name" | "expected-closing-parenthesis" | "unexpected-token";
+export interface ExpressionDiagnostic {
+    readonly code: ExpressionDiagnosticCode;
+    readonly message: string;
+    readonly range: SourceRange;
+}
+export interface ParseExpressionResult {
+    readonly expression: MacroExpression | null;
+    readonly diagnostics: readonly ExpressionDiagnostic[];
+}
+export interface EvaluateExpressionResult extends ParseExpressionResult {
+    readonly value: boolean;
+}
+/** Parse one macro expression. Offsets in the result include `baseOffset`. */
+export declare function parseMacroExpression(source: string, baseOffset?: number): ParseExpressionResult;
+/** Parse and evaluate one macro expression against a Profile definition map. */
+export declare function evaluateMacroExpression(source: string, definitions: MacroDefinitions, baseOffset?: number): EvaluateExpressionResult;
+//# sourceMappingURL=expression.d.ts.map

package/dist/core/expression.js

@@ -0,0 +1,224 @@
+"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.parseMacroExpression = parseMacroExpression;
+exports.evaluateMacroExpression = evaluateMacroExpression;
+/** Parse one macro expression. Offsets in the result include `baseOffset`. */
+function parseMacroExpression(source, baseOffset = 0) {
+    const parser = new ExpressionParser(tokenize(source, baseOffset));
+    return parser.parse();
+}
+/** Parse and evaluate one macro expression against a Profile definition map. */
+function evaluateMacroExpression(source, definitions, baseOffset = 0) {
+    const parsed = parseMacroExpression(source, baseOffset);
+    if (parsed.expression === null || parsed.diagnostics.length > 0) {
+        return { ...parsed, value: false };
+    }
+    const value = evaluateNode(parsed.expression, definitions);
+    return { expression: parsed.expression, diagnostics: [], value };
+}
+class ExpressionParser {
+    tokens;
+    offset = 0;
+    diagnostics = [];
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const expression = this.parseOr();
+        if (expression !== null && this.current().kind !== "eof") {
+            this.addDiagnostic("unexpected-token", `Unexpected token '${this.current().text}'.`, this.current().range);
+        }
+        return {
+            expression: this.diagnostics.length === 0 ? expression : null,
+            diagnostics: this.diagnostics,
+        };
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (left !== null && this.current().kind === "or") {
+            this.advance();
+            const right = this.parseAnd();
+            if (right === null) {
+                return null;
+            }
+            left = {
+                kind: "logical",
+                operator: "||",
+                left,
+                right,
+                range: { start: left.range.start, end: right.range.end },
+            };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseUnary();
+        while (left !== null && this.current().kind === "and") {
+            this.advance();
+            const right = this.parseUnary();
+            if (right === null) {
+                return null;
+            }
+            left = {
+                kind: "logical",
+                operator: "&&",
+                left,
+                right,
+                range: { start: left.range.start, end: right.range.end },
+            };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.current().kind !== "not") {
+            return this.parsePrimary();
+        }
+        const operator = this.advance();
+        const operand = this.parseUnary();
+        return operand === null
+            ? null
+            : {
+                kind: "not",
+                operand,
+                range: { start: operator.range.start, end: operand.range.end },
+            };
+    }
+    parsePrimary() {
+        const token = this.current();
+        if (token.kind === "identifier") {
+            this.advance();
+            return token.text === "defined"
+                ? this.parseDefined(token)
+                : { kind: "identifier", name: token.text, range: token.range };
+        }
+        if (token.kind === "open-parenthesis") {
+            this.advance();
+            const expression = this.parseOr();
+            if (expression === null) {
+                return null;
+            }
+            if (this.current().kind !== "close-parenthesis") {
+                this.addDiagnostic("expected-closing-parenthesis", "Expected ')' to close macro expression.", this.current().range);
+                return null;
+            }
+            this.advance();
+            return expression;
+        }
+        this.addDiagnostic("expected-expression", "Expected a macro name, defined(NAME), '!', or '('.", token.range);
+        if (token.kind !== "eof") {
+            this.advance();
+        }
+        return null;
+    }
+    parseDefined(definedToken) {
+        if (this.current().kind !== "open-parenthesis") {
+            this.addDiagnostic("expected-defined-parenthesis", "Expected '(' after defined.", this.current().range);
+            return null;
+        }
+        this.advance();
+        const name = this.current();
+        if (name.kind !== "identifier") {
+            this.addDiagnostic("expected-defined-name", "Expected a macro name inside defined(...).", name.range);
+            return null;
+        }
+        this.advance();
+        const closing = this.current();
+        if (closing.kind !== "close-parenthesis") {
+            this.addDiagnostic("expected-closing-parenthesis", "Expected ')' after the macro name in defined(...).", closing.range);
+            return null;
+        }
+        this.advance();
+        return {
+            kind: "defined",
+            name: name.text,
+            nameRange: name.range,
+            range: { start: definedToken.range.start, end: closing.range.end },
+        };
+    }
+    current() {
+        return this.tokens[this.offset] ?? this.tokens[this.tokens.length - 1];
+    }
+    advance() {
+        const token = this.current();
+        if (token.kind !== "eof") {
+            this.offset += 1;
+        }
+        return token;
+    }
+    addDiagnostic(code, message, range) {
+        this.diagnostics.push({ code, message, range });
+    }
+}
+function tokenize(source, baseOffset) {
+    const tokens = [];
+    let offset = 0;
+    while (offset < source.length) {
+        const character = source[offset];
+        if (/\s/.test(character)) {
+            offset += 1;
+            continue;
+        }
+        const start = offset;
+        if (/[A-Za-z_]/.test(character)) {
+            offset += 1;
+            while (offset < source.length && /[A-Za-z0-9_]/.test(source[offset])) {
+                offset += 1;
+            }
+            tokens.push(makeToken("identifier", source.slice(start, offset), start, offset, baseOffset));
+            continue;
+        }
+        const pair = source.slice(offset, offset + 2);
+        if (pair === "&&" || pair === "||") {
+            offset += 2;
+            tokens.push(makeToken(pair === "&&" ? "and" : "or", pair, start, offset, baseOffset));
+            continue;
+        }
+        offset += 1;
+        const kind = character === "!"
+            ? "not"
+            : character === "("
+                ? "open-parenthesis"
+                : character === ")"
+                    ? "close-parenthesis"
+                    : "invalid";
+        tokens.push(makeToken(kind, character, start, offset, baseOffset));
+    }
+    tokens.push(makeToken("eof", "end of expression", source.length, source.length, baseOffset));
+    return tokens;
+}
+function makeToken(kind, text, start, end, baseOffset) {
+    return {
+        kind,
+        text,
+        range: { start: baseOffset + start, end: baseOffset + end },
+    };
+}
+function evaluateNode(expression, definitions) {
+    switch (expression.kind) {
+        case "identifier":
+            return definitions[expression.name] === true;
+        case "defined":
+            return Object.hasOwn(definitions, expression.name);
+        case "not":
+            return !evaluateNode(expression.operand, definitions);
+        case "logical": {
+            const left = evaluateNode(expression.left, definitions);
+            const right = evaluateNode(expression.right, definitions);
+            return expression.operator === "&&" ? left && right : left || right;
+        }
+    }
+}
+//# sourceMappingURL=expression.js.map

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+/** Version of the public core API contract. */
+export declare const coreApiVersion: 1;
+export * from "./conditional.js";
+export * from "./expression.js";
+export * from "./projection.js";
+export * from "./scanner.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -0,0 +1,37 @@
+"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 });
+exports.coreApiVersion = void 0;
+/** Version of the public core API contract. */
+exports.coreApiVersion = 1;
+__exportStar(require("./conditional.js"), exports);
+__exportStar(require("./expression.js"), exports);
+__exportStar(require("./projection.js"), exports);
+__exportStar(require("./scanner.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/projection.d.ts

@@ -0,0 +1,15 @@
+import { type ConditionalAnalysisResult } from "./conditional.js";
+import type { MacroDefinitions } from "./expression.js";
+import type { SourceRange } from "./scanner.js";
+export interface ProjectionResult extends ConditionalAnalysisResult {
+    readonly projectedText: string;
+    readonly maskedRanges: readonly SourceRange[];
+}
+/** Analyze and project source through the selected macro definitions. */
+export declare function projectSource(source: string, definitions: MacroDefinitions): ProjectionResult;
+/**
+ * Replace non-newline text with whitespace while preserving both UTF-8 byte
+ * offsets and UTF-16 editor offsets.
+ */
+export declare function maskSourceRanges(source: string, ranges: readonly SourceRange[]): string;
+//# sourceMappingURL=projection.d.ts.map