tsifdef 1.1.8

package/dist/core/projection.js

@@ -0,0 +1,99 @@
+"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.projectSource = projectSource;
+exports.maskSourceRanges = maskSourceRanges;
+const conditional_js_1 = require("./conditional.js");
+/** Analyze and project source through the selected macro definitions. */
+function projectSource(source, definitions) {
+    const analysis = (0, conditional_js_1.analyzeConditionals)(source, definitions);
+    const maskedRanges = normalizeRanges(source.length, analysis.directiveRanges.concat(analysis.inactiveRanges));
+    return {
+        ...analysis,
+        projectedText: maskSourceRanges(source, maskedRanges),
+        maskedRanges,
+    };
+}
+/**
+ * Replace non-newline text with whitespace while preserving both UTF-8 byte
+ * offsets and UTF-16 editor offsets.
+ */
+function maskSourceRanges(source, ranges) {
+    const normalized = normalizeRanges(source.length, ranges);
+    const chunks = [];
+    let cursor = 0;
+    for (const range of normalized) {
+        chunks.push(source.slice(cursor, range.start));
+        chunks.push(maskText(source.slice(range.start, range.end)));
+        cursor = range.end;
+    }
+    chunks.push(source.slice(cursor));
+    return chunks.join("");
+}
+function maskText(source) {
+    let result = "";
+    for (const character of source) {
+        if (character === "\r" || character === "\n") {
+            result += character;
+            continue;
+        }
+        const codePoint = character.codePointAt(0);
+        if (codePoint <= 0x7f) {
+            result += " ";
+        }
+        else if (codePoint <= 0x7ff) {
+            result += "\u00A0";
+        }
+        else if (codePoint <= 0xffff) {
+            result += "\u3000";
+        }
+        else {
+            // Astral code points occupy four UTF-8 bytes and two UTF-16 code units.
+            result += "\u00A0\u00A0";
+        }
+    }
+    return result;
+}
+function normalizeRanges(sourceLength, ranges) {
+    const sorted = ranges.map((range) => {
+        if (!Number.isInteger(range.start) ||
+            !Number.isInteger(range.end) ||
+            range.start < 0 ||
+            range.end < range.start ||
+            range.end > sourceLength) {
+            throw new RangeError(`Invalid source range [${range.start}, ${range.end}) for length ${sourceLength}.`);
+        }
+        return range;
+    });
+    sorted.sort((left, right) => left.start - right.start || left.end - right.end);
+    const normalized = [];
+    for (const range of sorted) {
+        if (range.start === range.end) {
+            continue;
+        }
+        const previous = normalized.at(-1);
+        if (previous !== undefined && range.start <= previous.end) {
+            normalized[normalized.length - 1] = {
+                start: previous.start,
+                end: Math.max(previous.end, range.end),
+            };
+        }
+        else {
+            normalized.push({ start: range.start, end: range.end });
+        }
+    }
+    return normalized;
+}
+//# sourceMappingURL=projection.js.map

package/dist/core/scanner.d.ts

@@ -0,0 +1,33 @@
+export interface SourceRange {
+    /** Inclusive UTF-16 offset. */
+    readonly start: number;
+    /** Exclusive UTF-16 offset. */
+    readonly end: number;
+}
+export type DirectiveKind = "if" | "elif" | "else" | "endif" | "error";
+export interface Directive {
+    readonly kind: DirectiveKind;
+    /** Zero-based physical line number. */
+    readonly line: number;
+    /** Entire line excluding its line ending. */
+    readonly range: SourceRange;
+    /** The `#` and directive name. */
+    readonly keywordRange: SourceRange;
+    readonly argument: string;
+    readonly argumentRange: SourceRange | null;
+}
+export type ScannerDiagnosticCode = "unknown-directive" | "unmatched-elif" | "unmatched-else" | "unmatched-endif" | "elif-after-else" | "duplicate-else" | "unterminated-if";
+export interface ScannerDiagnostic {
+    readonly code: ScannerDiagnosticCode;
+    readonly message: string;
+    readonly range: SourceRange;
+}
+export interface ScanResult {
+    readonly directives: readonly Directive[];
+    /** Every directive-looking line, including unknown directives. */
+    readonly directiveRanges: readonly SourceRange[];
+    readonly diagnostics: readonly ScannerDiagnostic[];
+}
+/** Scan C/C++-style macro directives without evaluating their expressions. */
+export declare function scanDirectives(source: string): ScanResult;
+//# sourceMappingURL=scanner.d.ts.map

package/dist/core/scanner.js

@@ -0,0 +1,344 @@
+"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.scanDirectives = scanDirectives;
+const directivePattern = /^[\t \v\f\uFEFF]*#(.*)$/;
+const directiveKinds = new Set([
+    "if",
+    "elif",
+    "else",
+    "endif",
+    "error",
+]);
+const regexPrefixKeywords = new Set([
+    "await",
+    "case",
+    "delete",
+    "in",
+    "instanceof",
+    "new",
+    "of",
+    "return",
+    "throw",
+    "typeof",
+    "void",
+    "yield",
+]);
+/** Scan C/C++-style macro directives without evaluating their expressions. */
+function scanDirectives(source) {
+    const directives = [];
+    const directiveRanges = [];
+    const diagnostics = [];
+    const conditionalStack = [];
+    const lexicalState = { mode: "code", templates: [] };
+    let offset = 0;
+    let line = 0;
+    while (offset < source.length) {
+        const lineEnd = findLineEnd(source, offset);
+        const lineText = source.slice(offset, lineEnd);
+        const parsedLine = lexicalState.mode === "code"
+            ? parseDirectiveLine(lineText, offset, line, diagnostics)
+            : null;
+        if (parsedLine !== null) {
+            directiveRanges.push(parsedLine.range);
+            if (parsedLine.directive !== null) {
+                directives.push(parsedLine.directive);
+                checkStructure(parsedLine.directive, conditionalStack, diagnostics);
+            }
+            // Directive arguments are not TypeScript and cannot change lexical state.
+        }
+        else {
+            scanTypeScriptLine(lineText, lexicalState);
+        }
+        offset = skipLineEnding(source, lineEnd);
+        line += 1;
+    }
+    for (const frame of conditionalStack) {
+        diagnostics.push({
+            code: "unterminated-if",
+            message: "#if directive has no matching #endif.",
+            range: frame.opening.keywordRange,
+        });
+    }
+    diagnostics.sort((left, right) => left.range.start - right.range.start);
+    return { directives, directiveRanges, diagnostics };
+}
+function parseDirectiveLine(lineText, lineOffset, line, diagnostics) {
+    const match = directivePattern.exec(lineText);
+    if (match === null) {
+        return null;
+    }
+    const hashIndex = lineText.indexOf("#");
+    const lineRange = { start: lineOffset, end: lineOffset + lineText.length };
+    const remainder = match[1] ?? "";
+    const nameMatch = /^([A-Za-z_][A-Za-z0-9_]*)(.*)$/.exec(remainder);
+    const name = nameMatch?.[1];
+    if (name === undefined) {
+        diagnostics.push({
+            code: "unknown-directive",
+            message: "Expected a directive name after '#'.",
+            range: { start: lineOffset + hashIndex, end: lineOffset + hashIndex + 1 },
+        });
+        return { directive: null, range: lineRange };
+    }
+    const keywordRange = {
+        start: lineOffset + hashIndex,
+        end: lineOffset + hashIndex + name.length + 1,
+    };
+    const rawArgument = nameMatch?.[2] ?? "";
+    if (!directiveKinds.has(name)) {
+        if (isTypeScriptPrivateIdentifier(rawArgument)) {
+            return null;
+        }
+        diagnostics.push({
+            code: "unknown-directive",
+            message: `Unknown directive #${name}.`,
+            range: keywordRange,
+        });
+        return { directive: null, range: lineRange };
+    }
+    const leadingWhitespace = rawArgument.length - rawArgument.trimStart().length;
+    const argument = rawArgument.trim();
+    const argumentStart = keywordRange.end + leadingWhitespace;
+    return {
+        directive: {
+            kind: name,
+            line,
+            range: lineRange,
+            keywordRange,
+            argument,
+            argumentRange: argument.length === 0
+                ? null
+                : { start: argumentStart, end: argumentStart + argument.length },
+        },
+        range: lineRange,
+    };
+}
+/**
+ * A private field or method may begin a physical line with `#name`, which is
+ * indistinguishable from a directive until the following token is inspected.
+ */
+function isTypeScriptPrivateIdentifier(remainder) {
+    const continuation = remainder.trimStart();
+    if (continuation.length === 0) {
+        // Keep a bare "#name" as an unknown directive. Private members normally
+        // have a type, initializer, modifier, terminator, or parameter list.
+        return false;
+    }
+    return /^(?:[!?:=;(<]|\bin\b)/.test(continuation);
+}
+function checkStructure(directive, stack, diagnostics) {
+    const current = stack.at(-1);
+    switch (directive.kind) {
+        case "if":
+            stack.push({ opening: directive, sawElse: false });
+            break;
+        case "elif":
+            if (current === undefined) {
+                addStructureDiagnostic(diagnostics, directive, "unmatched-elif", "#elif directive has no matching #if.");
+            }
+            else if (current.sawElse) {
+                addStructureDiagnostic(diagnostics, directive, "elif-after-else", "#elif directive cannot appear after #else.");
+            }
+            break;
+        case "else":
+            if (current === undefined) {
+                addStructureDiagnostic(diagnostics, directive, "unmatched-else", "#else directive has no matching #if.");
+            }
+            else if (current.sawElse) {
+                addStructureDiagnostic(diagnostics, directive, "duplicate-else", "Conditional block cannot contain more than one #else.");
+            }
+            else {
+                current.sawElse = true;
+            }
+            break;
+        case "endif":
+            if (current === undefined) {
+                addStructureDiagnostic(diagnostics, directive, "unmatched-endif", "#endif directive has no matching #if.");
+            }
+            else {
+                stack.pop();
+            }
+            break;
+        case "error":
+            break;
+    }
+}
+function addStructureDiagnostic(diagnostics, directive, code, message) {
+    diagnostics.push({ code, message, range: directive.keywordRange });
+}
+function findLineEnd(source, start) {
+    let offset = start;
+    while (offset < source.length) {
+        const character = source.charCodeAt(offset);
+        if (character === 0x0a || character === 0x0d) {
+            break;
+        }
+        offset += 1;
+    }
+    return offset;
+}
+function skipLineEnding(source, lineEnd) {
+    if (source.charCodeAt(lineEnd) === 0x0d && source.charCodeAt(lineEnd + 1) === 0x0a) {
+        return lineEnd + 2;
+    }
+    return lineEnd < source.length ? lineEnd + 1 : lineEnd;
+}
+function scanTypeScriptLine(line, state) {
+    let offset = 0;
+    let quoteContinues = false;
+    while (offset < line.length) {
+        const character = line[offset];
+        const next = line[offset + 1];
+        if (state.mode === "block-comment") {
+            if (character === "*" && next === "/") {
+                state.mode = "code";
+                offset += 2;
+            }
+            else {
+                offset += 1;
+            }
+            continue;
+        }
+        if (state.mode === "single-quote" || state.mode === "double-quote") {
+            const closingQuote = state.mode === "single-quote" ? "'" : '"';
+            if (character === "\\") {
+                quoteContinues = offset === line.length - 1;
+                offset += 2;
+            }
+            else if (character === closingQuote) {
+                state.mode = "code";
+                offset += 1;
+            }
+            else {
+                offset += 1;
+            }
+            continue;
+        }
+        if (state.mode === "template") {
+            if (character === "\\") {
+                offset += 2;
+            }
+            else if (character === "`") {
+                state.templates.pop();
+                state.mode = "code";
+                offset += 1;
+            }
+            else if (character === "$" && next === "{") {
+                const template = state.templates.at(-1);
+                if (template !== undefined) {
+                    template.expressionBraceDepth = 0;
+                }
+                state.mode = "code";
+                offset += 2;
+            }
+            else {
+                offset += 1;
+            }
+            continue;
+        }
+        if (character === "/" && next === "/") {
+            break;
+        }
+        if (character === "/" && next === "*") {
+            state.mode = "block-comment";
+            offset += 2;
+            continue;
+        }
+        if (character === "/" && isLikelyRegexStart(line, offset)) {
+            offset = skipRegexLiteral(line, offset);
+            continue;
+        }
+        if (character === "'") {
+            state.mode = "single-quote";
+            offset += 1;
+            continue;
+        }
+        if (character === '"') {
+            state.mode = "double-quote";
+            offset += 1;
+            continue;
+        }
+        if (character === "`") {
+            state.templates.push({ expressionBraceDepth: null });
+            state.mode = "template";
+            offset += 1;
+            continue;
+        }
+        const template = state.templates.at(-1);
+        if (template !== undefined && template.expressionBraceDepth !== null) {
+            if (character === "{") {
+                template.expressionBraceDepth += 1;
+            }
+            else if (character === "}") {
+                if (template.expressionBraceDepth === 0) {
+                    template.expressionBraceDepth = null;
+                    state.mode = "template";
+                }
+                else {
+                    template.expressionBraceDepth -= 1;
+                }
+            }
+        }
+        offset += 1;
+    }
+    if ((state.mode === "single-quote" || state.mode === "double-quote") &&
+        !quoteContinues) {
+        // Recover after an invalid unterminated string instead of poisoning later lines.
+        state.mode = "code";
+    }
+}
+function isLikelyRegexStart(line, slashOffset) {
+    const prefix = line.slice(0, slashOffset).trimEnd();
+    if (prefix.length === 0) {
+        return true;
+    }
+    const previous = prefix.at(-1);
+    if (previous !== undefined && "([{,:;=!?&|+-*%^~<>".includes(previous)) {
+        return true;
+    }
+    const word = /([A-Za-z_$][A-Za-z0-9_$]*)$/.exec(prefix)?.[1];
+    return word !== undefined && regexPrefixKeywords.has(word);
+}
+function skipRegexLiteral(line, slashOffset) {
+    let offset = slashOffset + 1;
+    let inCharacterClass = false;
+    while (offset < line.length) {
+        const character = line[offset];
+        if (character === "\\") {
+            offset += 2;
+        }
+        else if (character === "[") {
+            inCharacterClass = true;
+            offset += 1;
+        }
+        else if (character === "]") {
+            inCharacterClass = false;
+            offset += 1;
+        }
+        else if (character === "/" && !inCharacterClass) {
+            offset += 1;
+            while (offset < line.length && /[A-Za-z]/.test(line[offset] ?? "")) {
+                offset += 1;
+            }
+            return offset;
+        }
+        else {
+            offset += 1;
+        }
+    }
+    return offset;
+}
+//# sourceMappingURL=scanner.js.map

package/dist/eslint/package.d.ts

@@ -0,0 +1,10 @@
+export * from "../core/index.js";
+export { configs as eslintConfigs, default as eslintPlugin, meta as eslintPluginMeta, processors, } from "./plugin.js";
+export declare const meta: {
+    name: string;
+    version: string;
+};
+export declare const configs: {
+    recommended: import("./plugin.js").LegacyConfig;
+};
+//# sourceMappingURL=package.d.ts.map

package/dist/eslint/package.js

@@ -0,0 +1,55 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configs = exports.meta = exports.processors = exports.eslintPluginMeta = exports.eslintPlugin = exports.eslintConfigs = void 0;
+__exportStar(require("../core/index.js"), exports);
+var plugin_js_1 = require("./plugin.js");
+Object.defineProperty(exports, "eslintConfigs", { enumerable: true, get: function () { return plugin_js_1.configs; } });
+Object.defineProperty(exports, "eslintPlugin", { enumerable: true, get: function () { return __importDefault(plugin_js_1).default; } });
+Object.defineProperty(exports, "eslintPluginMeta", { enumerable: true, get: function () { return plugin_js_1.meta; } });
+Object.defineProperty(exports, "processors", { enumerable: true, get: function () { return plugin_js_1.processors; } });
+const plugin_js_2 = require("./plugin.js");
+// The legacy `.eslintrc` system resolves a plugin by package name, which lands
+// on this entry rather than on `./eslint-plugin`. It then reads `configs`,
+// `processors`, and `meta` off the module, so `extends: ["plugin:tsifdef/
+// recommended"]` only works if those names are present here too.
+//
+// `recommended` must be the eslintrc shape here: the legacy schema rejects a
+// top-level `files` key. The flat shape stays reachable under the same names
+// it has on the flat entry, so a flat config that reaches this entry through
+// the `eslint-plugin-tsifdef` alias still works.
+exports.meta = plugin_js_2.meta;
+exports.configs = {
+    ...plugin_js_2.configs,
+    recommended: plugin_js_2.legacyRecommended,
+};
+//# sourceMappingURL=package.js.map

package/dist/eslint/parser.d.ts

@@ -0,0 +1,35 @@
+interface ParserOptions {
+    readonly filePath?: string;
+    readonly [key: string]: unknown;
+}
+interface ParserResult {
+    readonly ast: unknown;
+    readonly services?: unknown;
+    readonly visitorKeys?: unknown;
+    readonly scopeManager?: unknown;
+}
+/**
+ * ESLint parser wrapper that projects TSIfDef source before delegating to
+ * `@typescript-eslint/parser`.
+ *
+ * The processor still owns ESLint's primary projection and synthetic-message
+ * filtering. This wrapper additionally covers consumers such as
+ * `eslint-plugin-import` that bypass processors, read dependencies from disk,
+ * and invoke the configured parser directly.
+ */
+export declare function parseForESLint(code: string, options?: ParserOptions): ParserResult;
+export declare function parse(code: string, options?: ParserOptions): unknown;
+export declare const meta: {
+    name: string;
+    version: string;
+};
+declare const _default: {
+    parse: typeof parse;
+    parseForESLint: typeof parseForESLint;
+    meta: {
+        name: string;
+        version: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=parser.d.ts.map

package/dist/eslint/parser.js

@@ -0,0 +1,59 @@
+"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.meta = void 0;
+exports.parseForESLint = parseForESLint;
+exports.parse = parse;
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const version_js_1 = require("../version.js");
+const projection_js_1 = require("./projection.js");
+const parserCache = new Map();
+/** Resolve the peer parser relative to the file currently being linted. */
+function loadTypeScriptEslintParser(filePath) {
+    const anchor = filePath === undefined
+        ? (0, node_path_1.join)(process.cwd(), "package.json")
+        : (0, node_path_1.join)((0, node_path_1.dirname)((0, node_path_1.resolve)(filePath)), "__tsifdef_eslint_parser__.js");
+    const hostRequire = (0, node_module_1.createRequire)(anchor);
+    const parserPath = hostRequire.resolve("@typescript-eslint/parser");
+    const cached = parserCache.get(parserPath);
+    if (cached !== undefined)
+        return cached;
+    const parser = hostRequire(parserPath);
+    parserCache.set(parserPath, parser);
+    return parser;
+}
+/**
+ * ESLint parser wrapper that projects TSIfDef source before delegating to
+ * `@typescript-eslint/parser`.
+ *
+ * The processor still owns ESLint's primary projection and synthetic-message
+ * filtering. This wrapper additionally covers consumers such as
+ * `eslint-plugin-import` that bypass processors, read dependencies from disk,
+ * and invoke the configured parser directly.
+ */
+function parseForESLint(code, options) {
+    const filePath = typeof options?.filePath === "string" ? options.filePath : undefined;
+    const projected = (0, projection_js_1.projectSourceForEslint)(code, filePath).projectedText;
+    return loadTypeScriptEslintParser(filePath).parseForESLint(projected, options);
+}
+function parse(code, options) {
+    const filePath = typeof options?.filePath === "string" ? options.filePath : undefined;
+    const projected = (0, projection_js_1.projectSourceForEslint)(code, filePath).projectedText;
+    return loadTypeScriptEslintParser(filePath).parse(projected, options);
+}
+exports.meta = { name: "tsifdef/parser", version: version_js_1.VERSION };
+exports.default = { parse, parseForESLint, meta: exports.meta };
+//# sourceMappingURL=parser.js.map