tsc-ts 0.1.0 → 0.1.2

package/dist/api/compiler/jsdoc.js

@@ -7,6 +7,7 @@ import { isWhiteSpaceLike } from './character-codes.js';
 import { Diagnostic } from './diagnostics.js';
 import { Reparser } from './reparser.js';
 import { getLeadingCommentRanges, getTrailingCommentRanges } from './scanner.js';
+import { IdentifierName } from './identifier-name.js';
 /** Comment text collected while parsing, with the indentation it has reached. */
 class CommentText {
     parts = [];
@@ -1076,16 +1077,17 @@ export class JSDocParser {
                 p.parseErrorAtCurrentToken(293 /* Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here */, [
                     p.scanner.getTokenText(),
                 ]);
-            const missing = p.newIdentifier('');
+            const missing = p.newIdentifier(new IdentifierName(''));
             p.finishNode(missing, p.nodePos());
             return missing;
         }
         const pos = p.scanner.getTokenStart();
         const end = p.scanner.getTokenEnd();
         const text = p.scanner.getIdentifierValue();
+        const name = p.scanner.getIdentifierName();
         p.internIdentifier(text);
         p.nextTokenJSDoc();
-        const result = p.newIdentifier(text);
+        const result = p.newIdentifier(name);
         p.finishNodeWithEnd(result, pos, end);
         return result;
     }

package/dist/api/compiler/parser.d.ts

@@ -1,4 +1,5 @@
 import { Block, CaseBlock, CatchClause, ExternalModuleIndicatorOptions, Identifier, ImportAttributes, ImportClause, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxOpeningElement, ModifierList, Node, NodeFlags, NodeList, ObjectLiteralExpression, ParseOptions, ScriptKind, SourceFile, TemplateHead, TemplateLiteralTypeSpan, TemplateSpan, ThisTypeNode, Token, Tristate, TypeParameterDeclaration, VariableDeclaration, VariableDeclarationList, type EntityName, type Expression, type Statement, type TypeNode } from './ast.js';
+import { IdentifierName } from './identifier-name.js';
 import { OperatorPrecedence } from './ast-utilities.js';
 import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
 import { JSDocParser } from './jsdoc.js';
@@ -385,7 +386,7 @@ export declare class Parser extends ScannerErrorReporter {
      * A new identifier of the class `use` calls for. Callers create it after the identifier's token, so
      * for an element name the current token tells a shorthand property from an assignment or a method.
      */
-    newIdentifier(text: string, use?: IdentifierUse): Identifier;
+    newIdentifier(name: IdentifierName, use?: IdentifierUse): Identifier;
     /** Whether the current token ends an object literal element name that is not a shorthand property. */
     isElementNameEnd(): boolean;
     createMissingIdentifier(use?: IdentifierUse): Identifier;

package/dist/api/compiler/parser.js

@@ -6,6 +6,7 @@
 // for (const statement of file.statements.nodes) console.log(statement.kind);
 // ```
 import { appendToList, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntLiteral, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, CheckJsDirective, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, emptyCommentDirectives, emptyDiagnostics, emptyFileReferences, emptyNodes, emptyPragmas, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleIndicatorOptions, ExternalModuleReference, FileReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocAllType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, KeywordExpression, KeywordTypeNode, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, MissingNodeList, ModifierList, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NoSubstitutionTemplateLiteral, NodeList, NodeVisitor, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PostfixUnaryExpression, Pragma, PragmaArgument, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReferenceIdentifier, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisTypeNode, ThrowStatement, Token, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, getBody, getIsTypeOnly, getModifiers, getName, getPostfixToken, getQuestionToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, newCallExpression, newPropertyAssignment, } from './ast.js';
+import { IdentifierName } from './identifier-name.js';
 import { canHaveDecorators, canHaveIllegalDecorators, compareNodePositions, getBinaryOperatorPrecedence, getExternalModuleName, getImportTypeNodeLiteral, getTextOfNodeFromSourceText, isAmbientModule, isAnyImportOrReExport, isAssignmentOperator, isClassMemberModifier, isFunctionLike, isImportCall, isImportMeta, isImportPhaseMetaProperty, isInJSFile, isKeyword, isKeywordOrPunctuation, isLeftHandSideExpression, isModifierKind, isRequireCall, isReservedWord, isStringLiteralLike, modifierToFlag, modifiersToFlags, nodeIsMissing, nodeIsPresent, tagNamesAreEquivalent, tokenIsIdentifierOrKeyword, tokenIsIdentifierOrKeywordOrGreaterThan, } from './ast-utilities.js';
 import { isLineBreak } from './character-codes.js';
 import { Diagnostic, messageCode } from './diagnostics.js';
@@ -2308,7 +2309,7 @@ export class Parser extends ScannerErrorReporter {
         }
         else {
             this.parseErrorAt(skipTrivia(this.sourceText, name.pos), name.end, 1 /* Diagnostics.Identifier_expected */);
-            identifierName = this.newIdentifier('');
+            identifierName = this.newIdentifier(new IdentifierName(''));
             this.finishNode(identifierName, name.pos);
         }
         return this.checkJSSyntax(this.finishNode(new ImportSpecifier(isTypeOnly, propertyName, identifierName), pos));
@@ -2758,13 +2759,13 @@ export class Parser extends ScannerErrorReporter {
      * A new identifier of the class `use` calls for. Callers create it after the identifier's token, so
      * for an element name the current token tells a shorthand property from an assignment or a method.
      */
-    newIdentifier(text, use = 0 /* IdentifierUse.Reference */) {
+    newIdentifier(name, use = 0 /* IdentifierUse.Reference */) {
         this.identifierCount++;
-        if (text === 'await')
+        if (name.text === 'await')
             this.statementHasAwaitIdentifier = true;
         if (use === 1 /* IdentifierUse.Name */ || (use === 2 /* IdentifierUse.ElementName */ && this.isElementNameEnd()))
-            return new Identifier(text);
-        return new ReferenceIdentifier(text);
+            return new Identifier(name);
+        return new ReferenceIdentifier(name);
     }
     /** Whether the current token ends an object literal element name that is not a shorthand property. */
     isElementNameEnd() {
@@ -2772,7 +2773,7 @@ export class Parser extends ScannerErrorReporter {
         return token === 58 /* SyntaxKind.ColonToken */ || token === 20 /* SyntaxKind.OpenParenToken */ || token === 29 /* SyntaxKind.LessThanToken */;
     }
     createMissingIdentifier(use = 0 /* IdentifierUse.Reference */) {
-        const result = this.newIdentifier('', use);
+        const result = this.newIdentifier(new IdentifierName(''), use);
         this.finishNode(result, this.nodePos());
         return result;
     }
@@ -3959,7 +3960,7 @@ export class Parser extends ScannerErrorReporter {
                 // An unclosed opening element took its parent's closing element: restructure
                 // (<div>(...<span>...</div>)) into (<div>(...<span>...</>)</div>). The parent reports it.
                 const end = lastChild.children.end;
-                const missingIdentifier = this.finishNodeWithEnd(this.newIdentifier(''), end, end);
+                const missingIdentifier = this.finishNodeWithEnd(this.newIdentifier(new IdentifierName('')), end, end);
                 const newClosingElement = new JsxClosingElement(missingIdentifier);
                 this.finishNodeWithEnd(newClosingElement, end, end);
                 const newLast = new JsxElement(lastChild.openingElement, lastChild.children, newClosingElement);
@@ -4888,11 +4889,12 @@ export class Parser extends ScannerErrorReporter {
         if (isIdentifier) {
             const pos = this.scanner.hasPrecedingJSDocLeadingAsterisks() ? this.scanner.getTokenStart() : this.nodePos();
             const text = this.scanner.getIdentifierValue();
+            const name = this.scanner.getIdentifierName();
             const record = this.scanner.recordIdentifierValue(text);
             this.nextTokenWithoutCheck();
             if (record)
                 this.identifierTexts.push(text);
-            const result = this.newIdentifier(text, use);
+            const result = this.newIdentifier(name, use);
             this.finishNode(result, pos);
             return result;
         }

package/dist/api/compiler/printer/factory.js

@@ -8,6 +8,7 @@ import { NodeFactoryBase } from './factory-base.js';
 import { addDisposableResourceHelper, classPrivateFieldGetHelper, classPrivateFieldInHelper, classPrivateFieldSetHelper, disposeResourcesHelper, exportStarHelper, importDefaultHelper, importStarHelper, makeTemplateObjectHelper, rewriteRelativeImportExtensionsHelper, } from './helpers.js';
 import { formatGeneratedName, isMemberName, nodeIsSynthesized } from './utilities.js';
 import { isOuterExpression, outerExpressionOperand } from '../transformers/utilities.js';
+import { IdentifierName } from '../identifier-name.js';
 /**
  * The node factory of an emit context. The context is the factory (`EmitContext` extends it), so the two are one
  * object: a factory and a context that pointed at each other made every context a reference cycle.
@@ -36,7 +37,7 @@ export class NodeFactory extends NodeFactoryBase {
         return copy;
     }
     cloneIdentifier(node) {
-        return this.cloneNode(node, new Identifier(node.text));
+        return this.cloneNode(node, new Identifier(node.identifierName));
     }
     createNodeList(nodes) {
         return new NodeList(-1, -1, nodes);
@@ -56,7 +57,7 @@ export class NodeFactory extends NodeFactoryBase {
         return this.created(new Token(kind));
     }
     createIdentifier(text) {
-        return this.created(new Identifier(text));
+        return this.created(new Identifier(new IdentifierName(text)));
     }
     createKeywordExpression(kind) {
         return this.created(new KeywordExpression(kind));

package/dist/api/compiler/printer/printer.js

@@ -277,7 +277,7 @@ export class Printer extends NameGeneratorHost {
             case 297 /* SyntaxKind.JsxNamespacedName */:
                 // Its text either way: the source text, or the text of a node from elsewhere.
                 if (this.textIsSourceText(node))
-                    return node.text;
+                    return node instanceof Identifier ? node.text : node.text;
                 if (!canUseSourceFile || !this.isInCurrentSourceFile(node)) {
                     if (node instanceof Identifier)
                         return node.text;
@@ -311,7 +311,8 @@ export class Printer extends NameGeneratorHost {
             return false;
         if ((node.flags & (8 /* NodeFlags.Reparsed */ | 4194304 /* NodeFlags.JSDoc */ | 268435456 /* NodeFlags.ReparserTransformedLiteral */)) !== 0)
             return false;
-        const text = node.text;
+        // Natively an identifier's text is read through its name, and a private identifier's from its field.
+        const text = node instanceof Identifier ? node.text : node.text;
         const source = this.sourceText;
         const end = node.end;
         const start = end - text.length;

package/dist/api/compiler/program-checker.d.ts

@@ -88,6 +88,18 @@ export declare class CheckedProgram {
     createChecker(): Checker;
     /** Frees the checker that reports the program's diagnostics (`disposeChecker`). */
     disposeCheckers(): void;
+    /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+    addCheckerCounts(counts: readonly number[]): void;
+    /**
+     * The types, instantiations and transient symbols of every checker of the program: this thread's and
+     * the checker threads', as tsgo's `Program.TypeCount`, `InstantiationCount` and `SymbolCount` add them up.
+     * Reading them doesn't create this thread's checker.
+     */
+    checkerCounts(): {
+        types: number;
+        instantiations: number;
+        symbols: number;
+    };
     getBindDiagnostics(file: SourceFile | undefined): Diagnostic[];
     /**
      * Diagnostics of checker threads (parallel-check.ts): the semantic diagnostics of each file by file
@@ -109,6 +121,12 @@ export declare class CheckedProgram {
      */
     referenceThreads: number;
     readonly parallelGlobalDiagnostics: Diagnostic[];
+    /** The types checker threads created (`CheckerResult.counts`), which `--diagnostics` adds to `checker`'s. */
+    threadTypeCount: number;
+    /** The instantiations checker threads made. */
+    threadInstantiations: number;
+    /** The transient symbols checker threads created. */
+    threadSymbolCount: number;
     /**
      * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
      * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report

package/dist/api/compiler/program-checker.js

@@ -176,6 +176,27 @@ export class CheckedProgram {
             disposeChecker(this.reportingChecker);
         this.reportingChecker = undefined;
     }
+    /** Adds the counts a checker thread sent (`CheckerResult.counts`): types, instantiations, symbols. */
+    addCheckerCounts(counts) {
+        if (counts.length < 3)
+            return;
+        this.threadTypeCount += counts[0];
+        this.threadInstantiations += counts[1];
+        this.threadSymbolCount += counts[2];
+    }
+    /**
+     * The types, instantiations and transient symbols of every checker of the program: this thread's and
+     * the checker threads', as tsgo's `Program.TypeCount`, `InstantiationCount` and `SymbolCount` add them up.
+     * Reading them doesn't create this thread's checker.
+     */
+    checkerCounts() {
+        const own = this.reportingChecker;
+        return {
+            types: (own === undefined ? 0 : own.typeCount) + this.threadTypeCount,
+            instantiations: (own === undefined ? 0 : own.totalInstantiations) + this.threadInstantiations,
+            symbols: (own === undefined ? 0 : own.symbolCount) + this.threadSymbolCount,
+        };
+    }
     getBindDiagnostics(file) {
         return this.collect(file, (f) => f.bindDiagnostics);
     }
@@ -199,6 +220,12 @@ export class CheckedProgram {
      */
     referenceThreads = 1;
     parallelGlobalDiagnostics = [];
+    /** The types checker threads created (`CheckerResult.counts`), which `--diagnostics` adds to `checker`'s. */
+    threadTypeCount = 0;
+    /** The instantiations checker threads made. */
+    threadInstantiations = 0;
+    /** The transient symbols checker threads created. */
+    threadSymbolCount = 0;
     /**
      * Whether the semantic diagnostics of a file include the global diagnostics its checker found while
      * checking it, as an incremental program caches them (IncrementalProgram). Such a program doesn't report

package/dist/api/compiler/reparser.js

@@ -9,6 +9,7 @@
 import { ArrayTypeNode, ArrowFunction, AsExpression, BinaryExpression, CallSignatureDeclaration, ClassDeclaration, ClassExpression, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ElementAccessExpression, ExportAssignment, ExpressionStatement, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, ImportDeclaration, IndexSignatureDeclaration, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocImplementsTag, JSDocImportTag, JSDocOverloadTag, JSDocParameterOrPropertyTag, JSDocSatisfiesTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypedefTag, JSDocVariadicType, JSDocOptionalType, KeywordTypeNode, MethodDeclaration, MethodSignatureDeclaration, ModifierList, ModuleBlock, ModuleDeclaration, NodeList, NodeVisitor, NumericLiteral, ParameterDeclaration, ParenthesizedExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, StringLiteral, Token, TypeAliasDeclaration, TypeLiteralNode, TypeParameterDeclaration, VariableDeclaration, VariableStatement, getComment, getModifiers, getName, getParameters, getText, getType, getTypeExpression, getTypeParameters, FullPropertyAssignment, } from './ast.js';
 import { isAssignmentOperator, isFunctionLike, isInJSFile, isLeftHandSideExpression, isStringLiteralLike, } from './ast-utilities.js';
 import { isIdentifierPart, isIdentifierStart } from './character-codes.js';
+import { IdentifierName } from './identifier-name.js';
 /** Sets the parent of every node in a subtree. */
 class ParentInChildrenSetter extends NodeVisitor {
     parent = undefined;
@@ -219,7 +220,7 @@ export class Reparser {
                 const param = params[pi];
                 let parameter;
                 if (param instanceof JSDocThisTag) {
-                    const thisIdent = new Identifier('this');
+                    const thisIdent = new Identifier(new IdentifierName('this'));
                     thisIdent.pos = param.pos;
                     thisIdent.end = param.end;
                     thisIdent.flags = p.contextFlags | 8 /* NodeFlags.Reparsed */;
@@ -249,7 +250,7 @@ export class Reparser {
                     let name = param.name;
                     if (name instanceof Identifier && !isValidIdentifier(name.text)) {
                         // Replace invalid characters with `_`, or use `_N` for an empty name, for a valid parameter name.
-                        name = this.addTransformedReparse(new Identifier(sanitizeIdentifier(name.text, pi)), name);
+                        name = this.addTransformedReparse(new Identifier(new IdentifierName(sanitizeIdentifier(name.text, pi))), name);
                     }
                     else {
                         name = this.addDeepCloneReparse(name);
@@ -433,7 +434,7 @@ export class Reparser {
                             firstName.kind !== 109 /* SyntaxKind.ThisKeyword */ &&
                             !(firstName instanceof Identifier && firstName.text === 'this'))) {
                         // tsgo gives the `this` name no location.
-                        const thisParam = new ParameterDeclaration(undefined, undefined, new Identifier('this'), undefined, undefined, undefined);
+                        const thisParam = new ParameterDeclaration(undefined, undefined, new Identifier(new IdentifierName('this')), undefined, undefined, undefined);
                         thisParam.type = this.addDeepCloneReparse(getType(tag.typeExpression));
                         this.finishReparsedNode(thisParam, tag.tagName);
                         const newParams = [thisParam];

package/dist/api/compiler/scanner.d.ts

@@ -1,3 +1,4 @@
+import { IdentifierName } from './identifier-name.js';
 import type { DiagnosticMessage } from './diagnostics.js';
 import { EscapeSequenceScanningFlags, RegularExpressionFlags } from './regexp-checker.js';
 import { SyntaxKind } from './syntax-kind.js';
@@ -60,6 +61,7 @@ export declare class Scanner {
     /** @internal */ tokenFlags: TokenFlags;
     /** @internal */ tokenValue: string;
     /** @internal */ valueStart: number;
+    private tokenName;
     /** @internal */ valueEnd: number;
     private valueHash;
     private hashStart;
@@ -68,6 +70,7 @@ export declare class Scanner {
     /** @internal */ skipJSDocLeadingAsterisks: number;
     private readonly cutUnits;
     private readonly identifiers;
+    private lastEntry;
     private loadedBlocks;
     private textKind;
     private lineFeedFrom;
@@ -113,6 +116,11 @@ export declare class Scanner {
     recordIdentifierValue(text: string): boolean;
     /** @internal Like `getTokenValue`, but identifiers with the same text share one string. */
     getIdentifierValue(): string;
+    /**
+     * The identifier value as a name that identifiers with the same text share, after
+     * `getIdentifierValue`; a cooked value (with escapes) gets a name of its own.
+     */
+    getIdentifierName(): IdentifierName;
     getCommentDirectives(): readonly CommentDirective[];
     hasUnicodeEscape(): boolean;
     hasExtendedUnicodeEscape(): boolean;

package/dist/api/compiler/scanner.js

@@ -1,4 +1,5 @@
 import { charSize, codePointAt, isASCIILetter, isDigit, isHexDigit, isIdentifierPart, isIdentifierStart, isLineBreak, isOctalDigit, isWhiteSpaceLike, isWhiteSpaceSingleLine, } from './character-codes.js';
+import { IdentifierName } from './identifier-name.js';
 import { parsePseudoBigInt } from './pseudo-bigint.js';
 import { checkRegularExpression, regularExpressionFlag, } from './regexp-checker.js';
 import { CommentDirective, CommentRange, } from './types.js';
@@ -308,58 +309,58 @@ function rangeHash(chars, start, end) {
 function finishHash(hash) {
     return hash ^ (hash >>> 15);
 }
-/** Strings for ranges of one text, keyed by their code units: equal identifiers share one string. */
+/**
+ * Names for ranges of one text, keyed by their code units: equal identifiers share one
+ * `IdentifierName`.
+ */
 class IdentifierTable {
-    text;
     // Pairs of (entry index + 1, hash) per slot, (0, 0) when empty; linear probing.
     slots;
     // Each entry's length in code units.
     lengths;
-    texts;
+    names;
     count;
-    // Per entry: 1 once its text was recorded among the file's identifier texts (`markRecorded`).
+    // Per entry: 1 once its name was recorded among the file's identifier texts (`markRecorded`).
     recorded;
-    // The entry the last `intern` returned.
-    lastEntry;
-    constructor(text) {
-        this.text = text;
+    constructor() {
         this.slots = new Int32Array(512);
         this.lengths = new Int32Array(128);
-        this.texts = [];
+        this.names = [];
         this.count = 0;
         this.recorded = new Uint8Array(128);
-        this.lastEntry = -1;
+    }
+    /** Empties the table for a new text. */
+    clear() {
+        if (this.count === 0)
+            return;
+        this.slots.fill(0);
+        this.names.length = 0;
+        this.recorded.fill(0, 0, this.count);
+        this.count = 0;
     }
     /**
-     * Whether `text`, just returned by `intern`, still needs recording among the file's identifier
-     * texts; marks it recorded. Texts the table doesn't know are always recorded.
+     * Whether `text`, the text of the entry `entry` that `intern` returned (-1 for none), still needs
+     * recording among the file's identifier texts; marks it recorded. Texts the table doesn't know are
+     * always recorded.
      */
-    markRecorded(text) {
-        const entry = this.lastEntry;
-        if (entry < 0 || this.texts[entry] !== text)
+    markRecorded(entry, text) {
+        if (entry < 0 || this.names[entry].text !== text)
             return true;
         if (this.recorded[entry] !== 0)
             return false;
         this.recorded[entry] = 1;
         return true;
     }
-    /** Empties the table for a new text. */
-    setText(text) {
-        this.text = text;
-        if (this.count === 0)
-            return;
-        this.slots.fill(0);
-        this.recorded.fill(0, 0, this.count);
-        this.texts.length = 0;
-        this.count = 0;
-        this.lastEntry = -1;
+    /** The name of the entry `intern` returned. */
+    name(entry) {
+        return this.names[entry];
     }
     /**
-     * `text.substring(start, end)`, or the string interned for an equal range; `hash` is its `rangeHash`.
-     * A candidate of the same hash and length is compared with `startsWith`, which natively compares
-     * the bytes of both strings at once.
+     * The entry of `text.substring(start, end)`, added when the table has no equal range; `hash` is its
+     * `rangeHash`. A candidate of the same hash and length is compared with `startsWith`, which natively
+     * compares the bytes of both strings at once.
      */
-    intern(start, end, hash) {
+    intern(text, start, end, hash) {
         start = start | 0;
         end = end | 0;
         hash = hash | 0;
@@ -372,15 +373,11 @@ class IdentifierTable {
             if (entry === 0)
                 break;
             if ((slots[(slot * 2 + 1) | 0] | 0) === hash && (this.lengths[(entry - 1) | 0] | 0) === length) {
-                const candidate = this.texts[(entry - 1) | 0];
-                if (this.text.startsWith(candidate, start)) {
-                    this.lastEntry = (entry - 1) | 0;
-                    return candidate;
-                }
+                if (text.startsWith(this.names[(entry - 1) | 0].text, start))
+                    return (entry - 1) | 0;
             }
             slot = (slot + 1) & mask;
         }
-        const value = this.text.substring(start, end);
         const index = this.count | 0;
         if (index === this.lengths.length) {
             const lengths = new Int32Array(index * 2);
@@ -391,14 +388,13 @@ class IdentifierTable {
             this.recorded = recorded;
         }
         this.lengths[index] = length;
-        this.texts.push(value);
+        this.names.push(new IdentifierName(text.substring(start, end)));
         this.count = (index + 1) | 0;
-        this.lastEntry = index;
         slots[(slot * 2) | 0] = (index + 1) | 0;
         slots[(slot * 2 + 1) | 0] = hash;
         if (this.count * 2 > mask + 1)
             this.slots = rehash(slots);
-        return value;
+        return index;
     }
 }
 /** `IdentifierTable` slots in a table twice the size. */
@@ -546,6 +542,8 @@ export class Scanner {
     // so identifiers and keywords don't allocate until their value is read.
     /** @internal */ tokenValue;
     /** @internal */ valueStart;
+    // The name `getIdentifierValue` last interned, whose text `tokenValue` then holds.
+    tokenName;
     /** @internal */ valueEnd;
     // `rangeHash` of `chars[hashStart, hashEnd)`, which the ASCII identifier scan computes as it goes.
     valueHash;
@@ -556,6 +554,8 @@ export class Scanner {
     // The code units zeroed by `setTextEnd`.
     cutUnits;
     identifiers;
+    // The entry `getIdentifierValue` last interned, -1 for none.
+    lastEntry;
     // With code units on demand: per block of `unitBlockSize` code units, 1 once `chars` holds them
     // (`loadUnits`); `chars` is zero elsewhere.
     loadedBlocks;
@@ -594,6 +594,7 @@ export class Scanner {
         this.tokenFlags = 0 /* TokenFlags.None */;
         this.tokenValue = '';
         this.valueStart = -1;
+        this.tokenName = undefined;
         this.valueEnd = -1;
         this.valueHash = 0;
         this.hashStart = -1;
@@ -601,7 +602,8 @@ export class Scanner {
         this.commentDirectives = [];
         this.skipJSDocLeadingAsterisks = 0;
         this.cutUnits = new Uint16Array(4);
-        this.identifiers = new IdentifierTable(text);
+        this.identifiers = new IdentifierTable();
+        this.lastEntry = -1;
         this.textKind = 0 /* TextKind.Unknown */;
         this.lineFeedFrom = -1;
         this.lineFeedAt = -1;
@@ -613,7 +615,8 @@ export class Scanner {
         this.text = text;
         this.chars = toCodeUnits(text);
         this.loadedBlocks = undefined;
-        this.identifiers.setText(text);
+        this.identifiers.clear();
+        this.lastEntry = -1;
         this.textKind = 0 /* TextKind.Unknown */;
         this.lineFeedFrom = -1;
         this.lineFeedAt = -1;
@@ -737,7 +740,7 @@ export class Scanner {
      * file to be recorded; files record each identifier text once.
      */
     recordIdentifierValue(text) {
-        return this.identifiers.markRecorded(text);
+        return this.identifiers.markRecorded(this.lastEntry, text);
     }
     /** @internal Like `getTokenValue`, but identifiers with the same text share one string. */
     getIdentifierValue() {
@@ -745,11 +748,24 @@ export class Scanner {
         if (start >= 0) {
             const end = this.valueEnd;
             const hash = start === this.hashStart && end === this.hashEnd ? this.valueHash : rangeHash(this.chars, start, end);
-            this.tokenValue = this.identifiers.intern(start, end, hash);
+            const entry = this.identifiers.intern(this.text, start, end, hash);
+            this.lastEntry = entry;
+            this.tokenName = this.identifiers.name(entry);
+            this.tokenValue = this.tokenName.text;
             this.valueStart = -1;
         }
         return this.tokenValue;
     }
+    /**
+     * The identifier value as a name that identifiers with the same text share, after
+     * `getIdentifierValue`; a cooked value (with escapes) gets a name of its own.
+     */
+    getIdentifierName() {
+        const name = this.tokenName;
+        if (name !== undefined && name.text === this.tokenValue)
+            return name;
+        return new IdentifierName(this.tokenValue);
+    }
     getCommentDirectives() {
         return this.commentDirectives;
     }