tsifdef 1.1.8

package/dist/eslint/plugin.d.ts

@@ -0,0 +1,78 @@
+interface LintFix {
+    readonly range: readonly [number, number];
+    readonly text: string;
+}
+interface LintSuggestion {
+    readonly fix?: LintFix;
+    [key: string]: unknown;
+}
+interface LintMessage {
+    readonly ruleId?: string | null;
+    readonly fatal?: boolean;
+    readonly line?: number;
+    readonly column?: number;
+    readonly endLine?: number;
+    readonly endColumn?: number;
+    readonly fix?: LintFix;
+    readonly suggestions?: readonly LintSuggestion[];
+    [key: string]: unknown;
+}
+export declare const processors: {
+    macros: {
+        meta: {
+            name: string;
+            version: string;
+        };
+        supportsAutofix: boolean;
+        preprocess(text: string, filename: string): string[];
+        postprocess(messages: LintMessage[][], filename: string): LintMessage[];
+    };
+};
+export interface FlatConfig {
+    readonly files: readonly string[];
+    readonly plugins: {
+        readonly tsifdef: EslintPlugin;
+    };
+    readonly processor: string;
+    readonly settings: {
+        readonly "import/parsers": {
+            readonly "tsifdef/parser": readonly string[];
+        };
+    };
+}
+/**
+ * The legacy `.eslintrc` schema rejects a top-level `files` key, so the flat
+ * config cannot be reused for `extends: ["plugin:tsifdef/recommended"]`. The
+ * same targeting is expressed through `overrides` instead. Legacy resolves the
+ * plugin as `eslint-plugin-tsifdef`, so `import/parsers` must be keyed by that
+ * full package name rather than the flat-config short name.
+ */
+export interface LegacyConfig {
+    readonly plugins: readonly string[];
+    readonly overrides: readonly {
+        readonly files: readonly string[];
+        readonly processor: string;
+    }[];
+    readonly settings: {
+        readonly "import/parsers": {
+            readonly "eslint-plugin-tsifdef/parser": readonly string[];
+        };
+    };
+}
+interface EslintPlugin {
+    readonly meta: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly processors: typeof processors;
+    readonly configs: Record<string, FlatConfig | LegacyConfig>;
+}
+export declare const meta: {
+    name: string;
+    version: string;
+};
+export declare const configs: Record<string, FlatConfig | LegacyConfig>;
+declare const plugin: EslintPlugin;
+export declare const legacyRecommended: LegacyConfig;
+export default plugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/eslint/plugin.js

@@ -0,0 +1,229 @@
+"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.legacyRecommended = exports.configs = exports.meta = exports.processors = void 0;
+const node_path_1 = require("node:path");
+const version_js_1 = require("../version.js");
+const projection_js_1 = require("./projection.js");
+const projectionContexts = new Map();
+function rememberProjection(filename, source, maskedRanges) {
+    projectionContexts.set((0, node_path_1.resolve)(filename), {
+        source,
+        lineStarts: collectLineStarts(source),
+        maskedRanges,
+    });
+}
+function takeProjection(filename) {
+    const key = (0, node_path_1.resolve)(filename);
+    const context = projectionContexts.get(key);
+    projectionContexts.delete(key);
+    return context;
+}
+function collectLineStarts(source) {
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1) {
+        if (source[index] === "\n") {
+            starts.push(index + 1);
+        }
+    }
+    return starts;
+}
+function locationToOffset(context, line, column) {
+    if (!Number.isInteger(line) || !Number.isInteger(column) || line < 1 || column < 1) {
+        return undefined;
+    }
+    const lineStart = context.lineStarts[line - 1];
+    if (lineStart === undefined) {
+        return undefined;
+    }
+    const nextLineStart = context.lineStarts[line] ?? context.source.length;
+    let lineEnd = nextLineStart;
+    if (lineEnd > lineStart && context.source[lineEnd - 1] === "\n") {
+        lineEnd -= 1;
+    }
+    if (lineEnd > lineStart && context.source[lineEnd - 1] === "\r") {
+        lineEnd -= 1;
+    }
+    const offset = lineStart + column - 1;
+    return offset <= lineEnd ? offset : undefined;
+}
+/**
+ * Diagnostics caused solely by projected text do not describe the user's source.
+ * Keep diagnostics that touch any unmasked, non-newline source character so
+ * active code or real whitespace is never hidden merely because a range crosses a macro.
+ */
+function isSyntheticDiagnostic(message, context) {
+    if (message.fatal === true
+        || message.ruleId == null
+        || message.line === undefined
+        || message.column === undefined) {
+        return false;
+    }
+    const start = locationToOffset(context, message.line, message.column);
+    if (start === undefined) {
+        return false;
+    }
+    const hasEndLine = message.endLine !== undefined;
+    const hasEndColumn = message.endColumn !== undefined;
+    if (hasEndLine !== hasEndColumn) {
+        return false;
+    }
+    const explicitEnd = hasEndLine && hasEndColumn
+        ? locationToOffset(context, message.endLine, message.endColumn)
+        : undefined;
+    if (hasEndLine && (explicitEnd === undefined || explicitEnd < start)) {
+        return false;
+    }
+    const end = explicitEnd ?? Math.min(start + 1, context.source.length);
+    if (end === start) {
+        return context.maskedRanges.some((range) => start >= range.start && start < range.end);
+    }
+    let cursor = start;
+    let overlapsMaskedRange = false;
+    for (const range of context.maskedRanges) {
+        if (range.end <= start) {
+            continue;
+        }
+        if (range.start >= end) {
+            break;
+        }
+        const maskedStart = Math.max(start, range.start);
+        const maskedEnd = Math.min(end, range.end);
+        if (/[^\r\n]/u.test(context.source.slice(cursor, maskedStart))) {
+            return false;
+        }
+        overlapsMaskedRange = true;
+        cursor = Math.max(cursor, maskedEnd);
+    }
+    if (!overlapsMaskedRange) {
+        return false;
+    }
+    return !/[^\r\n]/u.test(context.source.slice(cursor, end));
+}
+/**
+ * A fix is safe only when its replacement range touches no masked character.
+ *
+ * Equal-length masking keeps projected offsets identical to source offsets, so a
+ * fix range that avoids every masked range rewrites exactly the active text the
+ * rule saw. A fix that overlaps masking would splice the user's `#if` directives
+ * or inactive branches into the replacement text and silently destroy them, so
+ * it is dropped. Zero-length insertions are treated as a single point: they are
+ * unsafe only when the insertion point falls strictly inside a masked range.
+ */
+function isSafeFix(fix, context) {
+    const range = fix.range;
+    if (!Array.isArray(range) || range.length !== 2) {
+        return false;
+    }
+    const [start, end] = range;
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start) {
+        return false;
+    }
+    return !context.maskedRanges.some((masked) => start === end
+        ? start > masked.start && start < masked.end
+        : start < masked.end && end > masked.start);
+}
+/**
+ * Strip only the unsafe fixes, keeping the diagnostic itself so the problem is
+ * still reported even when TSIfDef cannot offer a safe automatic repair.
+ */
+function withSafeFixes(message, context) {
+    const fixIsUnsafe = message.fix !== undefined && !isSafeFix(message.fix, context);
+    const suggestions = message.suggestions;
+    const safeSuggestions = suggestions === undefined
+        ? undefined
+        : suggestions.filter((suggestion) => suggestion.fix === undefined || isSafeFix(suggestion.fix, context));
+    const suggestionsChanged = suggestions !== undefined && safeSuggestions.length !== suggestions.length;
+    if (!fixIsUnsafe && !suggestionsChanged) {
+        return message;
+    }
+    const next = { ...message };
+    if (fixIsUnsafe) {
+        delete next.fix;
+    }
+    if (suggestionsChanged) {
+        next.suggestions = safeSuggestions;
+    }
+    return next;
+}
+exports.processors = {
+    macros: {
+        meta: { name: "tsifdef/macros", version: version_js_1.VERSION },
+        // Autofix stays enabled so unrelated rules keep their quick fixes; ESLint
+        // disables fixes for every rule in the file when this is false. Fixes that
+        // would overwrite masked directives or inactive branches are removed
+        // individually in postprocess instead.
+        supportsAutofix: true,
+        preprocess(text, filename) {
+            // Equal-length masking replaces inactive branches and directive lines
+            // with spaces while preserving CR/LF characters and total length.
+            const projection = (0, projection_js_1.projectSourceForEslint)(text, filename);
+            rememberProjection(filename, text, projection.maskedRanges);
+            return [projection.projectedText];
+        },
+        postprocess(messages, filename) {
+            // The equal-length projection preserves diagnostic line and column positions.
+            // Discard only diagnostics whose reported range contains no visible source
+            // outside TSIfDef's synthetic masking; all active-source diagnostics survive.
+            // Surviving diagnostics keep only the fixes that stay clear of masked text.
+            const flattened = messages.flat();
+            const context = takeProjection(filename);
+            return context === undefined
+                ? flattened
+                : flattened
+                    .filter((message) => !isSyntheticDiagnostic(message, context))
+                    .map((message) => withSafeFixes(message, context));
+        },
+    },
+};
+const MACRO_FILE_GLOBS = ["**/*.{ts,tsx,mts,cts}"];
+const MACRO_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+exports.meta = { name: "tsifdef", version: version_js_1.VERSION };
+exports.configs = {};
+const plugin = { meta: exports.meta, processors: exports.processors, configs: exports.configs };
+const flatRecommended = {
+    files: MACRO_FILE_GLOBS,
+    plugins: { tsifdef: plugin },
+    processor: "tsifdef/macros",
+    settings: {
+        "import/parsers": {
+            "tsifdef/parser": MACRO_EXTENSIONS,
+        },
+    },
+};
+exports.legacyRecommended = {
+    plugins: ["tsifdef"],
+    overrides: [
+        {
+            files: ["*.ts", "*.tsx", "*.mts", "*.cts"],
+            processor: "tsifdef/macros",
+        },
+    ],
+    settings: {
+        "import/parsers": {
+            "eslint-plugin-tsifdef/parser": MACRO_EXTENSIONS,
+        },
+    },
+};
+// This entry is what flat configs import as `tsifdef/eslint-plugin`, where
+// `recommended` has always meant the flat config. Keep it that way: changing
+// its shape makes ESLint 9 reject the config outright. The legacy shape is
+// reachable here under an explicit name, and is what `configs.recommended`
+// resolves to on the package entry that `.eslintrc` loads.
+exports.configs.recommended = flatRecommended;
+exports.configs["flat/recommended"] = flatRecommended;
+exports.configs["legacy/recommended"] = exports.legacyRecommended;
+exports.default = plugin;
+//# sourceMappingURL=plugin.js.map

package/dist/eslint/projection.d.ts

@@ -0,0 +1,11 @@
+import { type SourceRange } from "../core/index.js";
+export interface EslintProjection {
+    readonly projectedText: string;
+    readonly maskedRanges: readonly SourceRange[];
+}
+/**
+ * Resolve the nearest TSIfDef Profile and return an equal-length projection.
+ * Any missing or transiently invalid configuration fails open to the raw text.
+ */
+export declare function projectSourceForEslint(source: string, filename: string | undefined): EslintProjection;
+//# sourceMappingURL=projection.d.ts.map

package/dist/eslint/projection.js

@@ -0,0 +1,116 @@
+"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.projectSourceForEslint = projectSourceForEslint;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_js_1 = require("../cli/config.js");
+const index_js_1 = require("../core/index.js");
+const profileCache = new Map();
+const packagePointerCache = new Map();
+const macroFilePattern = /\.(?:d\.)?(?:ts|tsx|mts|cts)$/i;
+/**
+ * Resolve the nearest TSIfDef Profile and return an equal-length projection.
+ * Any missing or transiently invalid configuration fails open to the raw text.
+ */
+function projectSourceForEslint(source, filename) {
+    if (filename === undefined || !macroFilePattern.test(filename)) {
+        return { projectedText: source, maskedRanges: [] };
+    }
+    const profilePath = resolveProfilePath(filename);
+    if (profilePath === undefined) {
+        return { projectedText: source, maskedRanges: [] };
+    }
+    const definitions = loadDefinitions(profilePath);
+    if (definitions === undefined) {
+        return { projectedText: source, maskedRanges: [] };
+    }
+    const projection = (0, index_js_1.projectSource)(source, definitions);
+    return {
+        projectedText: projection.projectedText,
+        maskedRanges: projection.maskedRanges,
+    };
+}
+function resolveProfilePath(filename) {
+    let dir = (0, node_path_1.dirname)((0, node_path_1.resolve)(filename));
+    for (;;) {
+        const lookup = readPackagePointer((0, node_path_1.join)(dir, "package.json"), dir);
+        if (lookup.kind === "resolved") {
+            return lookup.profilePath ?? undefined;
+        }
+        const parent = (0, node_path_1.dirname)(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function readPackagePointer(packagePath, packageDir) {
+    let stat;
+    try {
+        stat = (0, node_fs_1.statSync)(packagePath);
+    }
+    catch {
+        return { kind: "continue" };
+    }
+    const cached = packagePointerCache.get(packagePath);
+    if (cached !== undefined && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+        return { kind: "resolved", profilePath: cached.profilePath };
+    }
+    try {
+        const raw = JSON.parse((0, node_fs_1.readFileSync)(packagePath, "utf8").replace(/^\uFEFF/, ""));
+        if (raw !== null && typeof raw === "object") {
+            const value = raw.tsifdef;
+            const profilePath = typeof value === "string" && value.trim() !== ""
+                ? (0, node_path_1.resolve)(packageDir, value)
+                : null;
+            packagePointerCache.set(packagePath, {
+                mtimeMs: stat.mtimeMs,
+                size: stat.size,
+                profilePath,
+            });
+            return { kind: "resolved", profilePath };
+        }
+    }
+    catch {
+        // Keep lint permissive when a package.json is temporarily unreadable.
+    }
+    return { kind: "continue" };
+}
+function loadDefinitions(profilePath) {
+    let mtimeMs;
+    let size;
+    try {
+        const stat = (0, node_fs_1.statSync)(profilePath);
+        mtimeMs = stat.mtimeMs;
+        size = stat.size;
+    }
+    catch {
+        return undefined;
+    }
+    const cached = profileCache.get(profilePath);
+    if (cached !== undefined && cached.mtimeMs === mtimeMs && cached.size === size) {
+        return cached.definitions;
+    }
+    try {
+        const text = (0, node_fs_1.readFileSync)(profilePath, "utf8");
+        const definitions = (0, config_js_1.parseProfileFile)(text, profilePath).definitions;
+        profileCache.set(profilePath, { mtimeMs, size, definitions });
+        return definitions;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=projection.js.map

package/dist/tsserver/host-projection.d.ts

@@ -0,0 +1,45 @@
+import type * as ts from "typescript";
+import type { MacroDefinitions } from "../core/expression.js";
+/** The active Profile applied to macro files, or `undefined` when none is selected. */
+export interface ActiveProfile {
+    /** The externally selected, read-only macro definitions. */
+    readonly definitions: MacroDefinitions;
+    /** A version tag identifying the Profile, appended to each script version. */
+    readonly version: string;
+}
+export interface HostProjectionOptions {
+    /**
+     * Return the currently active Profile, read fresh on every snapshot and
+     * version request. Returning `undefined` disables projection so raw snapshots
+     * and versions pass through. Reading live (rather than capturing once) lets a
+     * later Profile change take effect without recreating the language service.
+     */
+    readonly getProfile: () => ActiveProfile | undefined;
+    /** Decide whether a file participates in macro projection. */
+    readonly isMacroFile?: (fileName: string) => boolean;
+}
+/**
+ * Wrap a `LanguageServiceHost` so the language service sees macro-projected
+ * source.
+ *
+ * `getScriptSnapshot` reads the complete current snapshot via
+ * `getText(0, getLength())`, analyzes every directive in that whole file, and
+ * returns one equal-length projected snapshot. tsserver may then read any slice
+ * of that projection; macro state is never inferred from a requested slice.
+ * Unsaved edits are honored because the wrapper reads the host's in-memory
+ * snapshot rather than the file on disk.
+ *
+ * Projections are memoized per file against the host snapshot identity and the
+ * Profile version, so repeated reads of an unchanged file do not re-scan it.
+ * Files containing no directives are passed through untouched, which keeps
+ * large generated `.d.ts` files on TypeScript's own fast paths.
+ *
+ * `getScriptVersion` gains the Profile version so tsserver never reuses an AST
+ * built for a different Profile. Non-macro files, and all files while no Profile
+ * is selected, pass through unchanged.
+ *
+ * The `ts` module is injected (tsserver supplies it to the plugin) so this
+ * wrapper is testable without a global TypeScript dependency.
+ */
+export declare function wrapHostWithProjection<THost extends ts.LanguageServiceHost>(_typescript: typeof ts, host: THost, options: HostProjectionOptions): THost;
+//# sourceMappingURL=host-projection.d.ts.map

package/dist/tsserver/host-projection.js

@@ -0,0 +1,160 @@
+"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.wrapHostWithProjection = wrapHostWithProjection;
+const index_js_1 = require("../core/index.js");
+/** Default macro-file matcher: TypeScript-family extensions. */
+const macroExtensionPattern = /\.(?:d\.)?(?:ts|tsx|mts|cts)$/i;
+/**
+ * A projected snapshot that keeps incremental reparsing working.
+ *
+ * tsserver asks a snapshot how it differs from the previous one via
+ * `getChangeRange`. When that returns `undefined`, TypeScript cannot reuse any
+ * of the previous AST and reparses the whole file on every keystroke, which is
+ * catastrophic on large files. `ts.ScriptSnapshot.fromString` always returns
+ * `undefined`, so wrapping the host with it silently disabled incremental
+ * reparsing for every macro file.
+ *
+ * Equal-length masking is what makes delegation sound: a projected document has
+ * exactly the same length and offsets as its source, so a change range computed
+ * over the source is valid for the projection verbatim. The one exception is an
+ * edit that changes macro structure (adding, removing, or flipping a directive),
+ * which can rewrite text far from the edit. That case is detected by comparing
+ * masked ranges and reported as a full change so TypeScript reparses.
+ */
+class ProjectedSnapshot {
+    projectedText;
+    maskedRanges;
+    sourceSnapshot;
+    constructor(projectedText, 
+    /** Masked ranges of this projection, used to detect macro-structure edits. */
+    maskedRanges, 
+    /** The host snapshot this projection was derived from. */
+    sourceSnapshot) {
+        this.projectedText = projectedText;
+        this.maskedRanges = maskedRanges;
+        this.sourceSnapshot = sourceSnapshot;
+    }
+    getText(start, end) {
+        return this.projectedText.slice(start, end);
+    }
+    getLength() {
+        return this.projectedText.length;
+    }
+    getChangeRange(oldSnapshot) {
+        if (!(oldSnapshot instanceof ProjectedSnapshot)) {
+            return undefined;
+        }
+        // A macro-structure edit can alter text anywhere, so the source delta no
+        // longer describes the projection. Force a full reparse.
+        if (!sameMaskedRanges(oldSnapshot.maskedRanges, this.maskedRanges)) {
+            return undefined;
+        }
+        // Offsets are identical between source and projection, so the host's own
+        // change range applies to the projected text unchanged.
+        return this.sourceSnapshot.getChangeRange(oldSnapshot.sourceSnapshot);
+    }
+}
+function sameMaskedRanges(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index].start !== right[index].start || left[index].end !== right[index].end) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Wrap a `LanguageServiceHost` so the language service sees macro-projected
+ * source.
+ *
+ * `getScriptSnapshot` reads the complete current snapshot via
+ * `getText(0, getLength())`, analyzes every directive in that whole file, and
+ * returns one equal-length projected snapshot. tsserver may then read any slice
+ * of that projection; macro state is never inferred from a requested slice.
+ * Unsaved edits are honored because the wrapper reads the host's in-memory
+ * snapshot rather than the file on disk.
+ *
+ * Projections are memoized per file against the host snapshot identity and the
+ * Profile version, so repeated reads of an unchanged file do not re-scan it.
+ * Files containing no directives are passed through untouched, which keeps
+ * large generated `.d.ts` files on TypeScript's own fast paths.
+ *
+ * `getScriptVersion` gains the Profile version so tsserver never reuses an AST
+ * built for a different Profile. Non-macro files, and all files while no Profile
+ * is selected, pass through unchanged.
+ *
+ * The `ts` module is injected (tsserver supplies it to the plugin) so this
+ * wrapper is testable without a global TypeScript dependency.
+ */
+function wrapHostWithProjection(
+// Retained for API compatibility and future use; projection no longer needs
+// to build snapshots through the TypeScript module.
+_typescript, host, options) {
+    const isMacroFile = options.isMacroFile ?? ((fileName) => macroExtensionPattern.test(fileName));
+    const originalGetScriptSnapshot = host.getScriptSnapshot.bind(host);
+    const originalGetScriptVersion = host.getScriptVersion.bind(host);
+    const projectionCache = new Map();
+    host.getScriptSnapshot = (fileName) => {
+        const snapshot = originalGetScriptSnapshot(fileName);
+        const profile = options.getProfile();
+        if (snapshot === undefined || profile === undefined || !isMacroFile(fileName)) {
+            return snapshot;
+        }
+        // Reuse the previous projection when neither the file content nor the
+        // Profile changed. tsserver requests the same snapshot repeatedly while
+        // serving one request, and re-scanning a multi-megabyte file each time is
+        // pure overhead. The snapshot identity check is the cheap path; hosts that
+        // rebuild snapshot objects per call still hit the cache via content.
+        const cached = projectionCache.get(fileName);
+        if (cached !== undefined && cached.profileVersion === profile.version) {
+            if (cached.sourceSnapshot === snapshot) {
+                return cached.snapshot ?? snapshot;
+            }
+            if (snapshot.getLength() === cached.sourceText.length
+                && snapshot.getText(0, snapshot.getLength()) === cached.sourceText) {
+                return cached.snapshot ?? snapshot;
+            }
+        }
+        // Read the entire current file; directive pairing spans the whole file and
+        // cannot be evaluated from an isolated slice.
+        const source = snapshot.getText(0, snapshot.getLength());
+        const projection = (0, index_js_1.projectSource)(source, profile.definitions);
+        const projected = projection.maskedRanges.length === 0
+            // Nothing is masked, so the projection is the source. Returning the host
+            // snapshot preserves its change range and avoids copying the text.
+            ? undefined
+            : new ProjectedSnapshot(projection.projectedText, projection.maskedRanges, snapshot);
+        projectionCache.set(fileName, {
+            sourceSnapshot: snapshot,
+            sourceText: source,
+            profileVersion: profile.version,
+            snapshot: projected,
+        });
+        return projected ?? snapshot;
+    };
+    host.getScriptVersion = (fileName) => {
+        const version = originalGetScriptVersion(fileName);
+        const profile = options.getProfile();
+        if (profile === undefined || !isMacroFile(fileName)) {
+            return version;
+        }
+        return `${version}|tsifdef:${profile.version}`;
+    };
+    return host;
+}
+//# sourceMappingURL=host-projection.js.map

package/dist/tsserver/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./host-projection.js";
+export * from "./project-controller.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tsserver/index.js

@@ -0,0 +1,32 @@
+"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("./host-projection.js"), exports);
+__exportStar(require("./project-controller.js"), exports);
+//# sourceMappingURL=index.js.map