@tslite/parser 1.9.0 → 1.12.0

package/dist/corePublic.d.ts

@@ -0,0 +1,62 @@
+export declare const versionMajorMinor = "3.9";
+/** The version of the TypeScript compiler release */
+export declare const version: string;
+/**
+ * Type of objects whose values are all of the same type.
+ * The `in` and `for-in` operators can *not* be safely used,
+ * since `Object.prototype` may be modified by outside code.
+ */
+export interface MapLike<T> {
+    [index: string]: T;
+}
+export interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
+    " __sortedArrayBrand": any;
+}
+export interface SortedArray<T> extends Array<T> {
+    " __sortedArrayBrand": any;
+}
+/** ES6 Map interface, only read methods included. */
+export interface ReadonlyMap<T> {
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    forEach(action: (value: T, key: string) => void): void;
+    readonly size: number;
+    keys(): Iterator<string>;
+    values(): Iterator<T>;
+    entries(): Iterator<[string, T]>;
+}
+/** ES6 Map interface. */
+export interface Map<T> extends ReadonlyMap<T> {
+    set(key: string, value: T): this;
+    delete(key: string): boolean;
+    clear(): void;
+}
+export interface MapConstructor {
+    new <T>(): Map<T>;
+}
+/**
+ * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
+ */
+export declare function tryGetNativeMap(): MapConstructor | undefined;
+export declare const Map: MapConstructor;
+/** ES6 Iterator type. */
+export interface Iterator<T> {
+    next(): {
+        value: T;
+        done?: false;
+    } | {
+        value: never;
+        done: true;
+    };
+}
+/** Array that is only intended to be pushed to, never read. */
+export interface Push<T> {
+    push(...values: T[]): void;
+}
+export type EqualityComparer<T> = (a: T, b: T) => boolean;
+export type Comparer<T> = (a: T, b: T) => Comparison;
+export declare enum Comparison {
+    LessThan = -1,
+    EqualTo = 0,
+    GreaterThan = 1
+}

package/dist/corePublic.js

@@ -0,0 +1,31 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/corePublic.ts: o namespace virou módulo ES, com os imports explícitos.
+import { createMapShim, } from "./_namespaces/ts.js";
+// WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
+// If changing the text in this section, be sure to test `configurePrerelease` too.
+export const versionMajorMinor = "3.9";
+/** The version of the TypeScript compiler release */
+export const version = "3.9.10";
+/**
+ * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
+ */
+export function tryGetNativeMap() {
+    // O `Map` global, com o tipo da declaração acima. No outFile, o `Map` livre era o global; no módulo, o
+    // `export const Map` de baixo faz sombra a ele, e o global se lê pelo `globalThis` — cujo tipo de `Map`
+    // é o da lib, e não o que a declaração afirma.
+    const NativeMap = globalThis.Map;
+    // eslint-disable-next-line no-in-operator
+    return typeof NativeMap !== "undefined" && "entries" in NativeMap.prototype ? NativeMap : undefined;
+}
+export const Map = tryGetNativeMap() || (() => {
+    // NOTE: createMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+    if (typeof createMapShim === "function") {
+        return createMapShim();
+    }
+    throw new Error("TypeScript requires an environment that provides a compatible native Map implementation.");
+})();
+export var Comparison;
+(function (Comparison) {
+    Comparison[Comparison["LessThan"] = -1] = "LessThan";
+    Comparison[Comparison["EqualTo"] = 0] = "EqualTo";
+    Comparison[Comparison["GreaterThan"] = 1] = "GreaterThan";
+})(Comparison || (Comparison = {}));

package/dist/debug.d.ts

@@ -0,0 +1,74 @@
+import * as ts from "./_namespaces/ts.js";
+import { AssertionLevel, EmitFlags, ModifierFlags, NodeFlags, SymbolFlags, SyntaxKind, TransformFlags } from "./_namespaces/ts.js";
+import type { AnyFunction, FlowNode, Node, NodeArray, Symbol } from "./_namespaces/ts.js";
+export declare namespace Debug {
+    let isDebugging: boolean;
+    function getAssertionLevel(): ts.AssertionLevel;
+    function setAssertionLevel(level: AssertionLevel): void;
+    function shouldAssert(level: AssertionLevel): boolean;
+    function fail(message?: string, stackCrawlMark?: AnyFunction): never;
+    function failBadSyntaxKind(node: Node, message?: string, stackCrawlMark?: AnyFunction): never;
+    function assert(expression: unknown, message?: string, verboseDebugInfo?: string | (() => string), stackCrawlMark?: AnyFunction): asserts expression;
+    function assertEqual<T>(a: T, b: T, msg?: string, msg2?: string, stackCrawlMark?: AnyFunction): void;
+    function assertLessThan(a: number, b: number, msg?: string, stackCrawlMark?: AnyFunction): void;
+    function assertLessThanOrEqual(a: number, b: number, stackCrawlMark?: AnyFunction): void;
+    function assertGreaterThanOrEqual(a: number, b: number, stackCrawlMark?: AnyFunction): void;
+    function assertIsDefined<T>(value: T, message?: string, stackCrawlMark?: AnyFunction): asserts value is NonNullable<T>;
+    function checkDefined<T>(value: T | null | undefined, message?: string, stackCrawlMark?: AnyFunction): T;
+    /**
+     * @deprecated Use `checkDefined` to check whether a value is defined inline. Use `assertIsDefined` to check whether
+     * a value is defined at the statement level.
+     */
+    const assertDefined: typeof checkDefined;
+    function assertEachIsDefined<T extends Node>(value: NodeArray<T>, message?: string, stackCrawlMark?: AnyFunction): asserts value is NodeArray<T>;
+    function assertEachIsDefined<T>(value: readonly T[], message?: string, stackCrawlMark?: AnyFunction): asserts value is readonly NonNullable<T>[];
+    function checkEachDefined<T, A extends readonly T[]>(value: A, message?: string, stackCrawlMark?: AnyFunction): A;
+    /**
+     * @deprecated Use `checkEachDefined` to check whether the elements of an array are defined inline. Use `assertEachIsDefined` to check whether
+     * the elements of an array are defined at the statement level.
+     */
+    const assertEachDefined: typeof checkEachDefined;
+    function assertNever(member: never, message?: string, stackCrawlMark?: AnyFunction): never;
+    function assertEachNode<T extends Node, U extends T>(nodes: NodeArray<T>, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts nodes is NodeArray<U>;
+    function assertEachNode<T extends Node, U extends T>(nodes: readonly T[], test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts nodes is readonly U[];
+    function assertEachNode(nodes: readonly Node[], test: (node: Node) => boolean, message?: string, stackCrawlMark?: AnyFunction): void;
+    function assertNode<T extends Node, U extends T>(node: T | undefined, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts node is U;
+    function assertNode(node: Node | undefined, test: ((node: Node) => boolean) | undefined, message?: string, stackCrawlMark?: AnyFunction): void;
+    function assertNotNode<T extends Node, U extends T>(node: T | undefined, test: (node: Node) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts node is Exclude<T, U>;
+    function assertNotNode(node: Node | undefined, test: ((node: Node) => boolean) | undefined, message?: string, stackCrawlMark?: AnyFunction): void;
+    function assertOptionalNode<T extends Node, U extends T>(node: T, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts node is U;
+    function assertOptionalNode<T extends Node, U extends T>(node: T | undefined, test: (node: T) => node is U, message?: string, stackCrawlMark?: AnyFunction): asserts node is U | undefined;
+    function assertOptionalNode(node: Node | undefined, test: ((node: Node) => boolean) | undefined, message?: string, stackCrawlMark?: AnyFunction): void;
+    function assertOptionalToken<T extends Node, K extends SyntaxKind>(node: T, kind: K, message?: string, stackCrawlMark?: AnyFunction): asserts node is Extract<T, {
+        readonly kind: K;
+    }>;
+    function assertOptionalToken<T extends Node, K extends SyntaxKind>(node: T | undefined, kind: K, message?: string, stackCrawlMark?: AnyFunction): asserts node is Extract<T, {
+        readonly kind: K;
+    }> | undefined;
+    function assertOptionalToken(node: Node | undefined, kind: SyntaxKind | undefined, message?: string, stackCrawlMark?: AnyFunction): void;
+    function assertMissingNode(node: Node | undefined, message?: string, stackCrawlMark?: AnyFunction): asserts node is undefined;
+    /**
+     * Afirma que o valor tem o tipo dado só no tipo, sem asserção em runtime. Não é da tag: é do TypeScript 5.0, que o
+     * escreveu para a assinatura de implementação de um predicado que recebe `Node` (o §5 da arquitetura do checker).
+     */
+    function type<T>(value: unknown): asserts value is T;
+    function getFunctionName(func: AnyFunction): any;
+    function formatSymbol(symbol: Symbol): string;
+    /**
+     * Formats an enum value as a string for debugging and debug assertions.
+     */
+    function formatEnum(value: number | undefined, enumObject: any, isFlags?: boolean): string;
+    function formatSyntaxKind(kind: SyntaxKind | undefined): string;
+    function formatNodeFlags(flags: NodeFlags | undefined): string;
+    function formatModifierFlags(flags: ModifierFlags | undefined): string;
+    function formatTransformFlags(flags: TransformFlags | undefined): string;
+    function formatEmitFlags(flags: EmitFlags | undefined): string;
+    function formatSymbolFlags(flags: SymbolFlags | undefined): string;
+    function printControlFlowGraph(flowNode: FlowNode): void;
+    function formatControlFlowGraph(flowNode: FlowNode): string;
+    function attachFlowNodeDebugInfo(flowNode: FlowNode): void;
+    /**
+     * Injects debug information into frequently used types.
+     */
+    function enableDebugInfo(): void;
+}

package/dist/debug.js

@@ -0,0 +1,326 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/debug.ts: o namespace virou módulo ES, com os imports explícitos.
+import * as ts from "./_namespaces/ts.js";
+import { compareValues, every, getEmitFlags, getModifierFlagsNoCache, getOwnKeys, getParseTreeNode, getSourceFileOfNode, getSourceTextOfNodeFromSourceFile, hasProperty, isParseTreeNode, map, nodeIsSynthesized, noop, objectAllocator, stableSort, unescapeLeadingUnderscores, } from "./_namespaces/ts.js";
+export var Debug;
+(function (Debug) {
+    let currentAssertionLevel = 0 /* AssertionLevel.None */;
+    // eslint-disable-next-line prefer-const
+    Debug.isDebugging = false;
+    const assertionCache = {};
+    function getAssertionLevel() {
+        return currentAssertionLevel;
+    }
+    Debug.getAssertionLevel = getAssertionLevel;
+    function setAssertionLevel(level) {
+        const prevAssertionLevel = currentAssertionLevel;
+        currentAssertionLevel = level;
+        if (level > prevAssertionLevel) {
+            // restore assertion functions for the current assertion level (see `shouldAssertFunction`).
+            for (const key of getOwnKeys(assertionCache)) {
+                const cachedFunc = assertionCache[key];
+                if (cachedFunc !== undefined && Debug[key] !== cachedFunc.assertion && level >= cachedFunc.level) {
+                    Debug[key] = cachedFunc;
+                    assertionCache[key] = undefined;
+                }
+            }
+        }
+    }
+    Debug.setAssertionLevel = setAssertionLevel;
+    function shouldAssert(level) {
+        return currentAssertionLevel >= level;
+    }
+    Debug.shouldAssert = shouldAssert;
+    /**
+     * Tests whether an assertion function should be executed. If it shouldn't, it is cached and replaced with `ts.noop`.
+     * Replaced assertion functions are restored when `Debug.setAssertionLevel` is set to a high enough level.
+     * @param level The minimum assertion level required.
+     * @param name The name of the current assertion function.
+     */
+    function shouldAssertFunction(level, name) {
+        if (!shouldAssert(level)) {
+            assertionCache[name] = { level, assertion: Debug[name] };
+            Debug[name] = noop;
+            return false;
+        }
+        return true;
+    }
+    function fail(message, stackCrawlMark) {
+        debugger;
+        const e = new Error(message ? `Debug Failure. ${message}` : "Debug Failure.");
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(e, stackCrawlMark || fail);
+        }
+        throw e;
+    }
+    Debug.fail = fail;
+    function failBadSyntaxKind(node, message, stackCrawlMark) {
+        return fail(`${message || "Unexpected node."}\r\nNode ${formatSyntaxKind(node.kind)} was unexpected.`, stackCrawlMark || failBadSyntaxKind);
+    }
+    Debug.failBadSyntaxKind = failBadSyntaxKind;
+    function assert(expression, message, verboseDebugInfo, stackCrawlMark) {
+        if (!expression) {
+            message = message ? `False expression: ${message}` : "False expression.";
+            if (verboseDebugInfo) {
+                message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo());
+            }
+            fail(message, stackCrawlMark || assert);
+        }
+    }
+    Debug.assert = assert;
+    function assertEqual(a, b, msg, msg2, stackCrawlMark) {
+        if (a !== b) {
+            const message = msg ? msg2 ? `${msg} ${msg2}` : msg : "";
+            fail(`Expected ${a} === ${b}. ${message}`, stackCrawlMark || assertEqual);
+        }
+    }
+    Debug.assertEqual = assertEqual;
+    function assertLessThan(a, b, msg, stackCrawlMark) {
+        if (a >= b) {
+            fail(`Expected ${a} < ${b}. ${msg || ""}`, stackCrawlMark || assertLessThan);
+        }
+    }
+    Debug.assertLessThan = assertLessThan;
+    function assertLessThanOrEqual(a, b, stackCrawlMark) {
+        if (a > b) {
+            fail(`Expected ${a} <= ${b}`, stackCrawlMark || assertLessThanOrEqual);
+        }
+    }
+    Debug.assertLessThanOrEqual = assertLessThanOrEqual;
+    function assertGreaterThanOrEqual(a, b, stackCrawlMark) {
+        if (a < b) {
+            fail(`Expected ${a} >= ${b}`, stackCrawlMark || assertGreaterThanOrEqual);
+        }
+    }
+    Debug.assertGreaterThanOrEqual = assertGreaterThanOrEqual;
+    function assertIsDefined(value, message, stackCrawlMark) {
+        // eslint-disable-next-line no-null/no-null
+        if (value === undefined || value === null) {
+            fail(message, stackCrawlMark || assertIsDefined);
+        }
+    }
+    Debug.assertIsDefined = assertIsDefined;
+    function checkDefined(value, message, stackCrawlMark) {
+        assertIsDefined(value, message, stackCrawlMark || checkDefined);
+        return value;
+    }
+    Debug.checkDefined = checkDefined;
+    /**
+     * @deprecated Use `checkDefined` to check whether a value is defined inline. Use `assertIsDefined` to check whether
+     * a value is defined at the statement level.
+     */
+    Debug.assertDefined = checkDefined;
+    function assertEachIsDefined(value, message, stackCrawlMark) {
+        for (const v of value) {
+            assertIsDefined(v, message, stackCrawlMark || assertEachIsDefined);
+        }
+    }
+    Debug.assertEachIsDefined = assertEachIsDefined;
+    function checkEachDefined(value, message, stackCrawlMark) {
+        assertEachIsDefined(value, message, stackCrawlMark || checkEachDefined);
+        return value;
+    }
+    Debug.checkEachDefined = checkEachDefined;
+    /**
+     * @deprecated Use `checkEachDefined` to check whether the elements of an array are defined inline. Use `assertEachIsDefined` to check whether
+     * the elements of an array are defined at the statement level.
+     */
+    Debug.assertEachDefined = checkEachDefined;
+    function assertNever(member, message = "Illegal value:", stackCrawlMark) {
+        const detail = typeof member === "object" && hasProperty(member, "kind") && hasProperty(member, "pos") && formatSyntaxKind ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member);
+        return fail(`${message} ${detail}`, stackCrawlMark || assertNever);
+    }
+    Debug.assertNever = assertNever;
+    function assertEachNode(nodes, test, message, stackCrawlMark) {
+        if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertEachNode")) {
+            assert(test === undefined || every(nodes, test), message || "Unexpected node.", () => `Node array did not pass test '${getFunctionName(test)}'.`, stackCrawlMark || assertEachNode);
+        }
+    }
+    Debug.assertEachNode = assertEachNode;
+    function assertNode(node, test, message, stackCrawlMark) {
+        if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertNode")) {
+            assert(node !== undefined && (test === undefined || test(node)), message || "Unexpected node.", () => `Node ${formatSyntaxKind(node.kind)} did not pass test '${getFunctionName(test)}'.`, stackCrawlMark || assertNode);
+        }
+    }
+    Debug.assertNode = assertNode;
+    function assertNotNode(node, test, message, stackCrawlMark) {
+        if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertNotNode")) {
+            assert(node === undefined || test === undefined || !test(node), message || "Unexpected node.", () => `Node ${formatSyntaxKind(node.kind)} should not have passed test '${getFunctionName(test)}'.`, stackCrawlMark || assertNotNode);
+        }
+    }
+    Debug.assertNotNode = assertNotNode;
+    function assertOptionalNode(node, test, message, stackCrawlMark) {
+        if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertOptionalNode")) {
+            assert(test === undefined || node === undefined || test(node), message || "Unexpected node.", () => `Node ${formatSyntaxKind(node.kind)} did not pass test '${getFunctionName(test)}'.`, stackCrawlMark || assertOptionalNode);
+        }
+    }
+    Debug.assertOptionalNode = assertOptionalNode;
+    function assertOptionalToken(node, kind, message, stackCrawlMark) {
+        if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertOptionalToken")) {
+            assert(kind === undefined || node === undefined || node.kind === kind, message || "Unexpected node.", () => `Node ${formatSyntaxKind(node.kind)} was not a '${formatSyntaxKind(kind)}' token.`, stackCrawlMark || assertOptionalToken);
+        }
+    }
+    Debug.assertOptionalToken = assertOptionalToken;
+    function assertMissingNode(node, message, stackCrawlMark) {
+        if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertMissingNode")) {
+            assert(node === undefined, message || "Unexpected node.", () => `Node ${formatSyntaxKind(node.kind)} was unexpected'.`, stackCrawlMark || assertMissingNode);
+        }
+    }
+    Debug.assertMissingNode = assertMissingNode;
+    function type(_value) { }
+    Debug.type = type;
+    function getFunctionName(func) {
+        if (typeof func !== "function") {
+            return "";
+        }
+        else if (func.hasOwnProperty("name")) {
+            return func.name;
+        }
+        else {
+            const text = Function.prototype.toString.call(func);
+            const match = /^function\s+([\w\$]+)\s*\(/.exec(text);
+            return match ? match[1] : "";
+        }
+    }
+    Debug.getFunctionName = getFunctionName;
+    function formatSymbol(symbol) {
+        return `{ name: ${unescapeLeadingUnderscores(symbol.escapedName)}; flags: ${formatSymbolFlags(symbol.flags)}; declarations: ${map(symbol.declarations, node => formatSyntaxKind(node.kind))} }`;
+    }
+    Debug.formatSymbol = formatSymbol;
+    /**
+     * Formats an enum value as a string for debugging and debug assertions.
+     */
+    function formatEnum(value = 0, enumObject, isFlags) {
+        const members = getEnumMembers(enumObject);
+        if (value === 0) {
+            return members.length > 0 && members[0][0] === 0 ? members[0][1] : "0";
+        }
+        if (isFlags) {
+            let result = "";
+            let remainingFlags = value;
+            for (const [enumValue, enumName] of members) {
+                if (enumValue > value) {
+                    break;
+                }
+                if (enumValue !== 0 && enumValue & value) {
+                    result = `${result}${result ? "|" : ""}${enumName}`;
+                    remainingFlags &= ~enumValue;
+                }
+            }
+            if (remainingFlags === 0) {
+                return result;
+            }
+        }
+        else {
+            for (const [enumValue, enumName] of members) {
+                if (enumValue === value) {
+                    return enumName;
+                }
+            }
+        }
+        return value.toString();
+    }
+    Debug.formatEnum = formatEnum;
+    function getEnumMembers(enumObject) {
+        const result = [];
+        for (const name in enumObject) {
+            const value = enumObject[name];
+            if (typeof value === "number") {
+                result.push([value, name]);
+            }
+        }
+        return stableSort(result, (x, y) => compareValues(x[0], y[0]));
+    }
+    function formatSyntaxKind(kind) {
+        return formatEnum(kind, ts.SyntaxKind, /*isFlags*/ false);
+    }
+    Debug.formatSyntaxKind = formatSyntaxKind;
+    function formatNodeFlags(flags) {
+        return formatEnum(flags, ts.NodeFlags, /*isFlags*/ true);
+    }
+    Debug.formatNodeFlags = formatNodeFlags;
+    function formatModifierFlags(flags) {
+        return formatEnum(flags, ts.ModifierFlags, /*isFlags*/ true);
+    }
+    Debug.formatModifierFlags = formatModifierFlags;
+    function formatTransformFlags(flags) {
+        return formatEnum(flags, ts.TransformFlags, /*isFlags*/ true);
+    }
+    Debug.formatTransformFlags = formatTransformFlags;
+    function formatEmitFlags(flags) {
+        return formatEnum(flags, ts.EmitFlags, /*isFlags*/ true);
+    }
+    Debug.formatEmitFlags = formatEmitFlags;
+    function formatSymbolFlags(flags) {
+        return formatEnum(flags, ts.SymbolFlags, /*isFlags*/ true);
+    }
+    Debug.formatSymbolFlags = formatSymbolFlags;
+    let isDebugInfoEnabled = false;
+    let extendedDebugModule;
+    function extendedDebug() {
+        enableDebugInfo();
+        if (!extendedDebugModule) {
+            throw new Error("Debugging helpers could not be loaded.");
+        }
+        return extendedDebugModule;
+    }
+    function printControlFlowGraph(flowNode) {
+        return console.log(formatControlFlowGraph(flowNode));
+    }
+    Debug.printControlFlowGraph = printControlFlowGraph;
+    function formatControlFlowGraph(flowNode) {
+        return extendedDebug().formatControlFlowGraph(flowNode);
+    }
+    Debug.formatControlFlowGraph = formatControlFlowGraph;
+    function attachFlowNodeDebugInfo(flowNode) {
+        if (isDebugInfoEnabled) {
+            if (!("__debugFlowFlags" in flowNode)) { // eslint-disable-line no-in-operator
+                Object.defineProperties(flowNode, {
+                    __debugFlowFlags: { get() { return formatEnum(this.flags, ts.FlowFlags, /*isFlags*/ true); } },
+                    __debugToString: { value() { return formatControlFlowGraph(this); } }
+                });
+            }
+        }
+    }
+    Debug.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo;
+    /**
+     * Injects debug information into frequently used types.
+     */
+    function enableDebugInfo() {
+        if (isDebugInfoEnabled)
+            return;
+        // Add additional properties in debug mode to assist with debugging.
+        Object.defineProperties(objectAllocator.getSymbolConstructor().prototype, {
+            __debugFlags: { get() { return formatSymbolFlags(this.flags); } }
+        });
+        // A informação dos tipos é do checker, que cria os tipos (o `enableTypeDebugInfo` dele).
+        const nodeConstructors = [
+            objectAllocator.getNodeConstructor(),
+            objectAllocator.getIdentifierConstructor(),
+            objectAllocator.getTokenConstructor(),
+            objectAllocator.getSourceFileConstructor()
+        ];
+        for (const ctor of nodeConstructors) {
+            if (!ctor.prototype.hasOwnProperty("__debugKind")) {
+                Object.defineProperties(ctor.prototype, {
+                    __debugKind: { get() { return formatSyntaxKind(this.kind); } },
+                    __debugNodeFlags: { get() { return formatNodeFlags(this.flags); } },
+                    __debugModifierFlags: { get() { return formatModifierFlags(getModifierFlagsNoCache(this)); } },
+                    __debugTransformFlags: { get() { return formatTransformFlags(this.transformFlags); } },
+                    __debugIsParseTreeNode: { get() { return isParseTreeNode(this); } },
+                    __debugEmitFlags: { get() { return formatEmitFlags(getEmitFlags(this)); } },
+                    __debugGetText: {
+                        value(includeTrivia) {
+                            if (nodeIsSynthesized(this))
+                                return "";
+                            const parseNode = getParseTreeNode(this);
+                            const sourceFile = parseNode && getSourceFileOfNode(parseNode);
+                            return sourceFile ? getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
+                        }
+                    }
+                });
+            }
+        }
+        isDebugInfoEnabled = true;
+    }
+    Debug.enableDebugInfo = enableDebugInfo;
+})(Debug || (Debug = {}));