tsc-ts 0.0.9 → 0.1.0

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

@@ -19,6 +19,15 @@ export declare function getRootLength(path: string): number;
 export declare function isUrl(path: string): boolean;
 /** True for `/x`, `c:/x` and other disk roots (not URLs). */
 export declare function isRootedDiskPath(path: string): boolean;
+/**
+ * Whether Windows may resolve `path` over the network: a UNC path (`//server/share`), a Win32 device path
+ * (`//?/…`, `//./…`) or an NT object path (`/??/…`), with either separator. Device and object paths count even
+ * for local volumes, since their `UNC` and `GLOBALROOT` forms reach the network redirector. Accessing one can
+ * make Windows authenticate to an arbitrary host, so such paths are never accessed on any platform.
+ */
+export declare function isNetworkPath(path: string): boolean;
+/** Whether a path written in a config or on the command line names a network location once resolved. */
+export declare function isNetworkPathValue(value: string, basePath: string): boolean;
 export declare function pathIsAbsolute(path: string): boolean;
 /** True for `.`, `..`, and paths starting with `./` or `../`. */
 export declare function pathIsRelative(path: string): boolean;

package/dist/api/compiler/path.js

@@ -128,6 +128,26 @@ export function isUrl(path) {
 export function isRootedDiskPath(path) {
     return getEncodedRootLength(path) > 0;
 }
+/**
+ * Whether Windows may resolve `path` over the network: a UNC path (`//server/share`), a Win32 device path
+ * (`//?/…`, `//./…`) or an NT object path (`/??/…`), with either separator. Device and object paths count even
+ * for local volumes, since their `UNC` and `GLOBALROOT` forms reach the network redirector. Accessing one can
+ * make Windows authenticate to an arbitrary host, so such paths are never accessed on any platform.
+ */
+export function isNetworkPath(path) {
+    if (path.length < 2 || !isAnyDirectorySeparator(path.charCodeAt(0)))
+        return false;
+    if (isAnyDirectorySeparator(path.charCodeAt(1)))
+        return true;
+    return (path.length >= 3 &&
+        path.charCodeAt(1) === 0x3f &&
+        path.charCodeAt(2) === 0x3f &&
+        (path.length === 3 || isAnyDirectorySeparator(path.charCodeAt(3))));
+}
+/** Whether a path written in a config or on the command line names a network location once resolved. */
+export function isNetworkPathValue(value, basePath) {
+    return isNetworkPath(getNormalizedAbsolutePath(value, basePath));
+}
 export function pathIsAbsolute(path) {
     return getEncodedRootLength(path) !== 0;
 }
@@ -376,9 +396,6 @@ function isNonDotDotPrefix(normalized, rootLength) {
 /** Removes `.`, `..` and duplicate separators, keeping a trailing separator. */
 export function normalizePath(path) {
     path = normalizeSlashes(path);
-    const simple = simpleNormalizePath(path);
-    if (simple !== undefined)
-        return simple;
     const normalized = getNormalizedAbsolutePath(path, '');
     return normalized !== '' && hasTrailingDirectorySeparator(path)
         ? ensureTrailingDirectorySeparator(normalized)

package/dist/api/compiler/printer/emit-context.d.ts

@@ -1,4 +1,4 @@
-import { FunctionDeclaration, Identifier, type Node, NodeList, SourceFile } from '../ast.js';
+import { Block, FunctionDeclaration, Identifier, type Node, NodeList, SourceFile } from '../ast.js';
 import { ClusteredLinkTable } from '../link-tables.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { EmitFlags } from './emit-flags.js';
@@ -91,6 +91,8 @@ export declare class EmitContext extends NodeFactory {
     getAutoGenerateInfo(node: Node): AutoGenerateInfo | undefined;
     /** The node a generated name is based on, following clones of generated names. */
     getNodeForGeneratedName(name: Node): Node;
+    /** Whether `node` has emit data: flags, ranges, helpers or synthesized comments. */
+    hasEmitNode(node: Node): boolean;
     getEmitFlags(node: Node): EmitFlags;
     setEmitFlags(node: Node, flags: EmitFlags): Node;
     addEmitFlags(node: Node, flags: EmitFlags): Node;
@@ -140,6 +142,8 @@ export declare class EmitContext extends NodeFactory {
     addLexicalDeclaration(name: Identifier): Identifier;
     addHoistedFunctionDeclaration(node: FunctionDeclaration): FunctionDeclaration;
     addInitializationStatement(node: Node): Node;
+    /** `node` as a function body: a block as it is, an expression as `{ return node; }` with the expression's range. */
+    convertToFunctionBlock(node: Node, multiLine: boolean): Block;
     /** Marks the current variable scope as visiting parameters; returns the previous flags. */
     enterParameters(): number;
     /** Restores the scope flags; returns whether a variable was hoisted while visiting the parameters. */

package/dist/api/compiler/printer/emit-context.js

@@ -1,6 +1,6 @@
 // Side tables that transforms fill in and the printer reads: original nodes, emit flags,
 // comment and source map ranges, synthesized comments, generated names and emit helpers.
-import { ExpressionStatement, FunctionDeclaration, Identifier, NodeList, PrivateIdentifier, StringLiteral, VariableDeclaration, VariableStatement, } from '../ast.js';
+import { Block, ExpressionStatement, FunctionDeclaration, Identifier, NodeList, PrivateIdentifier, StringLiteral, VariableDeclaration, VariableStatement, } from '../ast.js';
 import { ClusteredLinkTable } from '../link-tables.js';
 import { NodeFactory } from './factory.js';
 import { isParseTreeNode, isPrologueDirective } from './utilities.js';
@@ -228,6 +228,10 @@ export class EmitContext extends NodeFactory {
         return node;
     }
     // Emit data
+    /** Whether `node` has emit data: flags, ranges, helpers or synthesized comments. */
+    hasEmitNode(node) {
+        return this.lookup(node) !== undefined;
+    }
     getEmitFlags(node) {
         const emitNode = this.lookup(node);
         return emitNode === undefined ? 0 /* EmitFlags.None */ : emitNode.emitFlags;
@@ -494,6 +498,21 @@ export class EmitContext extends NodeFactory {
         this.varScopes[this.varScopes.length - 1].initializationStatements.push(node);
         return node;
     }
+    /** `node` as a function body: a block as it is, an expression as `{ return node; }` with the expression's range. */
+    convertToFunctionBlock(node, multiLine) {
+        if (node instanceof Block)
+            return node;
+        const factory = this.factory;
+        const statement = factory.createReturnStatement(node);
+        statement.pos = node.pos;
+        statement.end = node.end;
+        const block = factory.createBlock([statement], multiLine);
+        block.statements.pos = node.pos;
+        block.statements.end = node.end;
+        block.pos = node.pos;
+        block.end = node.end;
+        return block;
+    }
     /** Marks the current variable scope as visiting parameters; returns the previous flags. */
     enterParameters() {
         const scope = this.varScopes[this.varScopes.length - 1];

package/dist/api/compiler/printer/factory-base.d.ts

@@ -111,7 +111,7 @@ export declare abstract class NodeFactoryBase {
     updateMethodSignatureDeclaration(node: MethodSignatureDeclaration, modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, typeParameters: NodeList | undefined, parameters: NodeList, typeNode: TypeNode | undefined): MethodSignatureDeclaration;
     updateMissingDeclaration(node: MissingDeclaration, modifiers: ModifierList | undefined): MissingDeclaration;
     updateModuleBlock(node: ModuleBlock, statements: NodeList): ModuleBlock;
-    updateModuleDeclaration(node: ModuleDeclaration, modifiers: ModifierList | undefined, keyword: SyntaxKind, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration;
+    updateModuleDeclaration(node: ModuleDeclaration, modifiers: ModifierList | undefined, keyword: SyntaxKind, name: ModuleName, attributes: TypeLiteralNode | undefined, body: ModuleBody | undefined): ModuleDeclaration;
     updateNamedExports(node: NamedExports, elements: NodeList): NamedExports;
     updateNamedImports(node: NamedImports, elements: NodeList): NamedImports;
     updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, typeNode: TypeNode): NamedTupleMember;
@@ -132,7 +132,7 @@ export declare abstract class NodeFactoryBase {
     updatePropertyAssignment(node: PropertyAssignment, modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, typeNode: TypeNode | undefined, initializer: Expression): PropertyAssignment;
     updatePropertyDeclaration(node: PropertyDeclaration, modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, typeNode: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration;
     updatePropertySignatureDeclaration(node: PropertySignatureDeclaration, modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, typeNode: TypeNode | undefined, initializer: Expression | undefined): PropertySignatureDeclaration;
-    updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName;
+    updateQualifiedName(node: QualifiedName, left: EntityName, right: MemberName): QualifiedName;
     updateRestTypeNode(node: RestTypeNode, typeNode: TypeNode): RestTypeNode;
     updateReturnStatement(node: ReturnStatement, expression: Expression | undefined): ReturnStatement;
     updateSatisfiesExpression(node: SatisfiesExpression, expression: Expression, typeNode: TypeNode): SatisfiesExpression;

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

@@ -998,9 +998,13 @@ export class NodeFactoryBase {
         }
         return node;
     }
-    updateModuleDeclaration(node, modifiers, keyword, name, body) {
-        if (modifiers !== node.modifiers || keyword !== node.keyword || name !== node.name || body !== node.body) {
-            const updated = new ModuleDeclaration(modifiers, keyword, name, body);
+    updateModuleDeclaration(node, modifiers, keyword, name, attributes, body) {
+        if (modifiers !== node.modifiers ||
+            keyword !== node.keyword ||
+            name !== node.name ||
+            attributes !== node.attributes ||
+            body !== node.body) {
+            const updated = new ModuleDeclaration(modifiers, keyword, name, attributes, body);
             this.finishUpdate(updated, node);
             return updated;
         }

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

@@ -175,7 +175,9 @@ export class NodeFactory extends NodeFactoryBase {
     createExpressionFromEntityName(node) {
         if (node instanceof QualifiedName) {
             const left = this.createExpressionFromEntityName(node.left);
-            const right = this.cloneIdentifier(node.right);
+            const right = node.right instanceof PrivateIdentifier
+                ? this.cloneNode(node.right, new PrivateIdentifier(node.right.text))
+                : this.cloneIdentifier(node.right);
             right.pos = node.right.pos;
             right.end = node.right.end;
             right.parent = node.right.parent;

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

@@ -70,8 +70,17 @@ export const importDefaultHelper = new EmitHelper('typescript:commonjsimportdefa
 export const exportStarHelper = new EmitHelper('typescript:export-star', false, `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);
 };`, 2, [createBindingHelper], '__exportStar', '');
-export const rewriteRelativeImportExtensionsHelper = new EmitHelper('typescript:rewriteRelativeImportExtensions', false, `var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+export const rewriteRelativeImportExtensionsHelper = new EmitHelper('typescript:rewriteRelativeImportExtensions', false, `var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx, extraExtensions, ignoreCase) {
     if (typeof path === "string" && /^\\.\\.?\\//.test(path)) {
+        if (extraExtensions) {
+            for (var extension in extraExtensions) {
+                var suffix = path.slice(-extension.length);
+                if (suffix === extension || ignoreCase && suffix.toLowerCase() === extension.toLowerCase()) {
+                    var output = extraExtensions[extension];
+                    return output === extension ? path : path.slice(0, -extension.length) + output;
+                }
+            }
+        }
         return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
             return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
         });

package/dist/api/compiler/printer/name-generator.d.ts

@@ -37,5 +37,5 @@ export declare class NameGenerator {
 }
 /** Forgets the files of earlier emits. */
 export declare function forgetIdentifierSets(): void;
-/** Whether no identifier in `file` is named `name`. */
+/** Whether no identifier, private name or literal in `file` has the text `name`. */
 export declare function isFileLevelUniqueName(file: SourceFile, name: string): boolean;

package/dist/api/compiler/printer/name-generator.js

@@ -1,5 +1,5 @@
 // Chooses the text of generated identifiers (`_a`, `_i`, `name_1`, …) while printing.
-import { ClassExpression, ExportAssignment, PrivateIdentifier, StringLiteral, getLocals, getNextContainer, getText, isLocalsContainer, } from '../ast.js';
+import { ClassExpression, ExportAssignment, NodeVisitor, PrivateIdentifier, StringLiteral, getLocals, getNextContainer, getText, isLocalsContainer, } from '../ast.js';
 import { getName } from '../ast.js';
 import { getExternalModuleName } from '../ast-utilities.js';
 import { ensureLeadingHash, formatGeneratedName, makeIdentifierFromModuleName, removeLeadingHash, } from './utilities.js';
@@ -137,44 +137,44 @@ export class NameGenerator {
             case 79 /* SyntaxKind.Identifier */:
             case 80 /* SyntaxKind.PrivateIdentifier */:
                 return this.makeUniqueName(this.host.getTextOfNode(node), false, (flags & 16 /* GeneratedIdentifierFlags.Optimistic */) !== 0, (flags & 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */) !== 0, privateName, prefix, suffix);
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 267 /* SyntaxKind.EnumDeclaration */: {
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */: {
                 const name = this.host.getTextOfNode(getName(node));
                 if (isUniqueLocalName(name, node))
                     return name;
                 return this.makeUniqueName(name, false, false, false, false, '', '');
             }
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 346 /* SyntaxKind.JSImportDeclaration */:
-            case 279 /* SyntaxKind.ExportDeclaration */: {
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */: {
                 const specifier = getExternalModuleName(node);
                 const base = specifier instanceof StringLiteral ? makeIdentifierFromModuleName(specifier.text) : 'module';
                 return this.makeUniqueName(base, false, false, false, false, '', '');
             }
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 264 /* SyntaxKind.ClassDeclaration */: {
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */: {
                 const name = getName(node);
                 if (name !== undefined)
                     return this.generateNameForNode(name, false, flags, '', '');
                 return this.makeUniqueName('default', false, false, false, false, '', '');
             }
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 if (node instanceof ExportAssignment)
                     return this.makeUniqueName('default', false, false, false, false, '', '');
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 if (node instanceof ClassExpression)
                     return this.makeUniqueName('class', false, false, false, false, '', '');
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */: {
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */: {
                 const name = getName(node);
                 if (name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */)
                     return this.generateNameForNodeCached(name, privateName, 0 /* GeneratedIdentifierFlags.None */, prefix, suffix);
                 return this.makeTempVariableName(0 /* TempFlags.Auto */, false, privateName, prefix, suffix);
             }
-            case 168 /* SyntaxKind.ComputedPropertyName */:
+            case 169 /* SyntaxKind.ComputedPropertyName */:
                 return this.makeTempVariableName(0 /* TempFlags.Auto */, true, privateName, prefix, suffix);
         }
         return this.makeTempVariableName(0 /* TempFlags.Auto */, false, privateName, prefix, suffix);
@@ -270,13 +270,32 @@ const identifierSets = new Map();
 export function forgetIdentifierSets() {
     identifierSets.clear();
 }
-/** Whether no identifier in `file` is named `name`. */
+/** Collects the texts of a file's identifiers, private names and literals: the names its generated names avoid. */
+class NameTextCollector extends NodeVisitor {
+    texts = new Set();
+    visitNode(node) {
+        switch (node.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+            case 80 /* SyntaxKind.PrivateIdentifier */:
+            case 10 /* SyntaxKind.StringLiteral */:
+            case 8 /* SyntaxKind.NumericLiteral */:
+            case 9 /* SyntaxKind.BigIntLiteral */:
+            case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+                this.texts.add(getText(node));
+        }
+        node.forEachChild(this);
+        return false;
+    }
+}
+/** Whether no identifier, private name or literal in `file` has the text `name`. */
 export function isFileLevelUniqueName(file, name) {
     let set = identifierSets.get(file);
     if (set === undefined) {
         if (identifierSets.size >= 16)
             identifierSets.clear();
-        set = new Set(file.identifierTexts);
+        const collector = new NameTextCollector();
+        file.forEachChild(collector);
+        set = collector.texts;
         identifierSets.set(file, set);
     }
     return !set.has(name);

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

@@ -101,6 +101,13 @@ export declare class Printer extends NameGeneratorHost {
     currentSourceFile: SourceFile | undefined;
     private sourceText;
     private lineStarts;
+    /**
+     * The line of the last `lineOf` lookup, `lookupLine`, and the positions it spans, `[lookupLineStart, lookupLineEnd)`,
+     * with `lookupLineEnd` -1 after the last line: printing reads positions mostly in order, so most lookups fall on that line.
+     */
+    private lookupLine;
+    private lookupLineStart;
+    private lookupLineEnd;
     private writer;
     private ownWriter;
     private uniqueHelperNames;
@@ -114,8 +121,25 @@ export declare class Printer extends NameGeneratorHost {
     private commentsDisabled;
     /** Emitting the `extends` clause of a conditional or infer type. */
     private inExtends;
-    /** Saved comment state: emit flags, comment pos, comment end, container pos, container end, declaration list end. */
-    private readonly commentStack;
+    /**
+     * Saved comment state, 32-bit values: emit flags, comment pos, comment end, container pos, container end,
+     * declaration list end.
+     * Flags are `commentFreeNode` for a node that `emitCommentsBeforeNode` handled in a comment-free range.
+     */
+    private commentStack;
+    /** The used length of `commentStack`: entries are written in place and kept for reuse once popped. */
+    private commentDepth;
+    /** Start positions of `//` and `/*` in `sourceText`, ascending; made on first use for each file. */
+    private commentStarts;
+    /**
+     * A range of `sourceText`, `[freeStart, freeEnd)`, where no comment starts and the last character is not trivia,
+     * so no comment is found from any position in it; -1 when there is none. `freeOwner` is the node it was made for.
+     */
+    private freeStart;
+    private freeEnd;
+    /** Whether no trailing comment follows `freeEnd`. */
+    private freeEndTrailingNone;
+    private freeOwner;
     /** Saved source map state: emit flags, pos, end, has token range. */
     private readonly sourceMapStack;
     /** The token position after `enterToken` skipped trivia. */
@@ -143,6 +167,13 @@ export declare class Printer extends NameGeneratorHost {
     private getLiteralTextOfNode;
     /** The text of an identifier, private identifier, literal or JSX namespaced name as printed. */
     getTextOfNode(node: Node): string;
+    /**
+     * Whether the source text of an identifier or private identifier of the current file, from the end of its leading
+     * trivia to its end, is its text: the text ends the node, and the character before it is not part of the token, as
+     * it would be in an identifier written with escapes. Nodes from JSDoc may span other text, so they are left to the
+     * general path.
+     */
+    private textIsSourceText;
     private isInCurrentSourceFile;
     private write1;
     private space;
@@ -155,6 +186,8 @@ export declare class Printer extends NameGeneratorHost {
     private writeLineSeparatorsAndIndentBefore;
     private writeLineSeparatorsAfter;
     private positionsAreOnSameLine;
+    /** The zero-based line of `pos` (-1 before the first line), which becomes the line of the last lookup. */
+    private lineOf;
     private rangeStart;
     private rangeIsOnSingleLine;
     private rangeEndIsOnSameLineAsRangeStart;
@@ -323,6 +356,7 @@ export declare class Printer extends NameGeneratorHost {
     private emitImportEqualsDeclaration;
     private emitImportDeclaration;
     private emitImportClause;
+    private emitNamedImports;
     /** Import and export specifiers. */
     private emitSpecifier;
     private emitExportAssignment;
@@ -363,7 +397,20 @@ export declare class Printer extends NameGeneratorHost {
     private emitListItems;
     private emitAnyNode;
     private emitCommentsBeforeNode;
+    /** Saves the comment state of a node: its emit flags (or `commentFreeNode`), comment range and the containers. */
+    private pushCommentState;
     private emitCommentsAfterNode;
+    /**
+     * Whether `node` has no emit data and lies in a range of the source text where no comment is found, so that its
+     * comments need not be looked for. Outside such a range, a node whose own range is one starts it (`freeOwner`).
+     */
+    private inCommentFreeRange;
+    private endCommentFreeRange;
+    /** Whether the comment-free range shows that no trailing comment follows `pos`. */
+    private noCommentsAfter;
+    /** Makes `[pos, end)` the comment-free range if no comment starts in it and its last character is not trivia. */
+    private startCommentFreeRange;
+    private commentStartsOfFile;
     /** Emits comments before a token; returns whether `emitCommentsAfterToken` applies, with the token's position in `tokenPos`. */
     private emitCommentsBeforeToken;
     private emitCommentsAfterToken;