tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/sourcemap.js

@@ -219,8 +219,8 @@ export class SourceMapGenerator {
         const mappings = this.getMappings();
         let json = '{"version":3,"file":' +
             jsonString(this.file) +
-            ',"sourceRoot":' +
-            jsonString(this.sourceRoot) +
+            // An empty source root is left out, as tsgo's `omitzero` does.
+            (this.sourceRoot === '' ? '' : ',"sourceRoot":' + jsonString(this.sourceRoot)) +
             ',"sources":' +
             jsonStrings(this.sources) +
             ',"names":' +

package/dist/api/compiler/symbol-accessibility.js

@@ -8,7 +8,7 @@ import { ExternalModuleContainerIndex, SymbolAccessibilityCaches, fileIndexScale
 import { getEffectiveDeclarationFlags } from './checker-declarations.js';
 import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { checkExpressionCached } from './checker-expressions.js';
-import { resolveExternalModuleName, resolveExternalModuleSymbol } from './checker-modules.js';
+import { getImportAttributesTypeForModuleSpecifier, resolveExternalModuleName, resolveExternalModuleSymbol, } from './checker-modules.js';
 import { getExportsOfSymbol, getMergedSymbol, getParentOfSymbol, getSymbolFlags, getSymbolOfDeclaration, resolveAlias, resolveSymbol, } from './checker-symbols.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { compareSymbols } from './checker-type-factory.js';
@@ -116,10 +116,10 @@ export function hasNonGlobalAugmentationExternalModuleDeclaration(symbol) {
 }
 export function hasNonGlobalAugmentationExternalModuleSymbol(declaration) {
     return (isModuleWithStringLiteralName(declaration) ||
-        (declaration.kind === 307 /* SyntaxKind.SourceFile */ && isExternalOrCommonJSModule(declaration)));
+        (declaration.kind === 308 /* SyntaxKind.SourceFile */ && isExternalOrCommonJSModule(declaration)));
 }
 function isModuleWithStringLiteralName(node) {
-    if (node.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
+    if (node.kind !== 269 /* SyntaxKind.ModuleDeclaration */)
         return false;
     const name = getName(node);
     return name !== undefined && name.kind === 10 /* SyntaxKind.StringLiteral */;
@@ -214,7 +214,7 @@ function getAlternativeContainingModules(c, symbol, enclosingDeclaration) {
             // Synthesized specifiers can't be resolved.
             if ((importRef.flags & 16 /* NodeFlags.Synthesized */) !== 0)
                 continue;
-            const resolvedModule = resolveExternalModuleName(c, enclosingDeclaration, importRef, true);
+            const resolvedModule = resolveExternalModuleName(c, enclosingDeclaration, importRef, true, getImportAttributesTypeForModuleSpecifier(c, importRef));
             if (resolvedModule === undefined)
                 continue;
             if (getAliasForSymbolInContainer(c, resolvedModule, symbol) === undefined)
@@ -280,7 +280,7 @@ function externalModuleFileIndex(c, symbol) {
     if (symbol === undefined || (symbol.flags & 512 /* SymbolFlags.ValueModule */) === 0)
         return -1;
     for (const declaration of getDeclarations(symbol)) {
-        if (declaration.kind !== 307 /* SyntaxKind.SourceFile */)
+        if (declaration.kind !== 308 /* SyntaxKind.SourceFile */)
             continue;
         const file = declaration;
         if (isExternalModule(file) && getSymbolOfDeclaration(c, declaration) === symbol)
@@ -343,14 +343,14 @@ function getVariableDeclarationOfObjectLiteral(c, symbol, meaning) {
     const parent = firstDecl.parent;
     if (parent === undefined || !(parent instanceof VariableDeclaration))
         return undefined;
-    if ((firstDecl.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ && firstDecl === getInitializer(parent)) ||
-        (firstDecl.kind === 188 /* SyntaxKind.TypeLiteral */ && firstDecl === getType(parent)))
+    if ((firstDecl.kind === 212 /* SyntaxKind.ObjectLiteralExpression */ && firstDecl === getInitializer(parent)) ||
+        (firstDecl.kind === 189 /* SyntaxKind.TypeLiteral */ && firstDecl === getType(parent)))
         return getSymbolOfDeclaration(c, parent);
     return undefined;
 }
 function hasExternalModuleSymbol(declaration) {
     return (isAmbientModule(declaration) ||
-        (declaration.kind === 307 /* SyntaxKind.SourceFile */ && isExternalOrCommonJSModule(declaration)));
+        (declaration.kind === 308 /* SyntaxKind.SourceFile */ && isExternalOrCommonJSModule(declaration)));
 }
 function getExternalModuleContainer(c, declaration) {
     for (let node = declaration; node !== undefined; node = node.parent)
@@ -388,7 +388,7 @@ export function getContainersOfSymbol(c, symbol, enclosingDeclaration, meaning)
                 continue;
             }
             // The `export =` of an ambient module.
-            if (parent.kind === 269 /* SyntaxKind.ModuleBlock */ &&
+            if (parent.kind === 270 /* SyntaxKind.ModuleBlock */ &&
                 parent.parent !== undefined &&
                 resolveExternalModuleSymbol(c, getSymbolOfDeclaration(c, parent.parent), false) === symbol) {
                 addCandidate(getSymbolOfDeclaration(c, parent.parent));
@@ -545,7 +545,7 @@ class ChainSearch {
                 (this.useOnlyExternalAliasing && !hasExternalModuleImportEqualsDeclaration(fromTable)) ||
                 (isLocalNameLookup && hasNamespaceReexportDeclaration(fromTable)) ||
                 // Exports are in scope, but export specifiers aren't.
-                (!ignoreQualification && getDeclarations(fromTable).some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */)))
+                (!ignoreQualification && getDeclarations(fromTable).some((d) => d.kind === 283 /* SyntaxKind.ExportSpecifier */)))
                 continue;
             const resolved = resolveAlias(c, fromTable);
             const candidate = this.candidateListForSymbol(fromTable, resolved, ignoreQualification);
@@ -580,10 +580,23 @@ class ChainSearch {
     isAccessible(fromTable, resolvedAlias, ignoreQualification) {
         const c = this.c;
         const symbol = getMergedSymbol(c, this.symbol);
-        const likeSymbols = this.symbol === resolvedAlias ||
+        let likeSymbols = this.symbol === resolvedAlias ||
             this.symbol === fromTable ||
             (resolvedAlias !== undefined && symbol === getMergedSymbol(c, resolvedAlias)) ||
             symbol === getMergedSymbol(c, fromTable);
+        // An alias of an alias, such as `export =` of a class that a top-level export also names, resolves further.
+        if (!likeSymbols && resolvedAlias !== undefined && (resolvedAlias.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
+            const seen = new Set();
+            let alias = resolvedAlias;
+            while ((alias.flags & 2097152 /* SymbolFlags.Alias */) !== 0 && !seen.has(alias)) {
+                seen.add(alias);
+                alias = getMergedSymbol(c, resolveAlias(c, alias));
+                if (symbol === alias) {
+                    likeSymbols = true;
+                    break;
+                }
+            }
+        }
         if (!likeSymbols)
             return false;
         // An external module in the global table isn't accessible by name; otherwise the name must be qualifiable.
@@ -639,7 +652,7 @@ function compareSymbolChains(c, a, b) {
     return 0;
 }
 function isUMDExportSymbol(symbol) {
-    return declarationCount(symbol) > 0 && symbol.declaration.kind === 271 /* SyntaxKind.NamespaceExportDeclaration */;
+    return declarationCount(symbol) > 0 && symbol.declaration.kind === 272 /* SyntaxKind.NamespaceExportDeclaration */;
 }
 function hasNamespaceReexportDeclaration(symbol) {
     for (const d of getDeclarations(symbol))
@@ -648,7 +661,7 @@ function hasNamespaceReexportDeclaration(symbol) {
     return false;
 }
 function isNamespaceReexportDeclaration(node) {
-    return (node.kind === 281 /* SyntaxKind.NamespaceExport */ &&
+    return (node.kind === 282 /* SyntaxKind.NamespaceExport */ &&
         node.parent instanceof ExportDeclaration &&
         node.parent.moduleSpecifier !== undefined);
 }
@@ -659,7 +672,7 @@ function hasExternalModuleImportEqualsDeclaration(symbol) {
     return false;
 }
 function isExternalModuleImportEqualsDeclaration(node) {
-    return node instanceof ImportEqualsDeclaration && node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */;
+    return node instanceof ImportEqualsDeclaration && node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */;
 }
 /** Whether another symbol of the same name and meaning shadows `symbol` at `enclosingDeclaration`. */
 export function needsQualification(c, symbol, enclosingDeclaration, meaning) {
@@ -673,7 +686,7 @@ export function needsQualification(c, symbol, enclosingDeclaration, meaning) {
             return true;
         // Qualify if the symbol of this name has the meaning sought.
         const shouldResolveAlias = (fromTable.flags & 2097152 /* SymbolFlags.Alias */) !== 0 &&
-            !getDeclarations(fromTable).some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */);
+            !getDeclarations(fromTable).some((d) => d.kind === 283 /* SyntaxKind.ExportSpecifier */);
         if (shouldResolveAlias)
             fromTable = resolveAlias(c, fromTable);
         const flags = shouldResolveAlias ? getSymbolFlags(c, fromTable) : fromTable.flags;
@@ -690,10 +703,10 @@ function isPropertyOrMethodDeclarationSymbol(symbol) {
         return false;
     for (const declaration of getDeclarations(symbol)) {
         switch (declaration.kind) {
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 continue;
             default:
                 return false;
@@ -714,9 +727,9 @@ export function someSymbolTableInScope(c, enclosingDeclaration, callback) {
                 return true;
         }
         switch (location.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
-            case 268 /* SyntaxKind.ModuleDeclaration */: {
-                if (location.kind === 307 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(location))
+            case 308 /* SyntaxKind.SourceFile */:
+            case 269 /* SyntaxKind.ModuleDeclaration */: {
+                if (location.kind === 308 /* SyntaxKind.SourceFile */ && !isExternalOrCommonJSModule(location))
                     break;
                 const symbol = getSymbolOfDeclaration(c, location);
                 if (symbol === undefined)
@@ -726,9 +739,9 @@ export function someSymbolTableInScope(c, enclosingDeclaration, callback) {
                     return true;
                 break;
             }
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */: {
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */: {
                 // Type parameters are bound in `members` so they merge across declarations, but act like
                 // locals. Raw members suffice: they're never late bound.
                 const symbol = getSymbolOfDeclaration(c, location);
@@ -838,23 +851,23 @@ export function beginDeclarationEmitVisibility(c, file) {
 }
 function determineIfDeclarationIsVisible(c, node) {
     switch (node.kind) {
-        case 331 /* SyntaxKind.JSDocCallbackTag */:
-        case 338 /* SyntaxKind.JSDocTypedefTag */: {
+        case 332 /* SyntaxKind.JSDocCallbackTag */:
+        case 339 /* SyntaxKind.JSDocTypedefTag */: {
             // Top-level JSDoc type aliases are exported.
             const host = node.parent?.parent?.parent;
-            return host !== undefined && host.kind === 307 /* SyntaxKind.SourceFile */;
+            return host !== undefined && host.kind === 308 /* SyntaxKind.SourceFile */;
         }
-        case 209 /* SyntaxKind.BindingElement */:
+        case 210 /* SyntaxKind.BindingElement */:
             return isDeclarationVisible(c, node.parent.parent);
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */: {
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */: {
             if (node instanceof VariableDeclaration) {
                 const name = node.name;
                 if (name instanceof BindingPattern && name.elements.nodes.length === 0)
@@ -865,51 +878,51 @@ function determineIfDeclarationIsVisible(c, node) {
             const parent = getDeclarationContainer(node);
             // Unexported declarations are visible only in global files; ambient module members are exported.
             if ((getCombinedModifierFlags(node) & 32 /* ModifierFlags.Export */) === 0 &&
-                !(node.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
-                    parent.kind !== 307 /* SyntaxKind.SourceFile */ &&
+                !(node.kind !== 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+                    parent.kind !== 308 /* SyntaxKind.SourceFile */ &&
                     (parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0))
                 return isGlobalSourceFile(parent);
             return isDeclarationVisible(c, parent);
         }
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
             if (getEffectiveDeclarationFlags(node, 2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */) !== 0)
                 return false;
             return isDeclarationVisible(c, node.parent);
-        case 177 /* SyntaxKind.Constructor */:
-        case 181 /* SyntaxKind.ConstructSignature */:
-        case 180 /* SyntaxKind.CallSignature */:
-        case 182 /* SyntaxKind.IndexSignature */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 269 /* SyntaxKind.ModuleBlock */:
-        case 185 /* SyntaxKind.FunctionType */:
-        case 186 /* SyntaxKind.ConstructorType */:
-        case 188 /* SyntaxKind.TypeLiteral */:
-        case 184 /* SyntaxKind.TypeReference */:
-        case 189 /* SyntaxKind.ArrayType */:
-        case 190 /* SyntaxKind.TupleType */:
-        case 193 /* SyntaxKind.UnionType */:
-        case 194 /* SyntaxKind.IntersectionType */:
-        case 197 /* SyntaxKind.ParenthesizedType */:
-        case 203 /* SyntaxKind.NamedTupleMember */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 183 /* SyntaxKind.IndexSignature */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 270 /* SyntaxKind.ModuleBlock */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
+        case 189 /* SyntaxKind.TypeLiteral */:
+        case 185 /* SyntaxKind.TypeReference */:
+        case 190 /* SyntaxKind.ArrayType */:
+        case 191 /* SyntaxKind.TupleType */:
+        case 194 /* SyntaxKind.UnionType */:
+        case 195 /* SyntaxKind.IntersectionType */:
+        case 198 /* SyntaxKind.ParenthesizedType */:
+        case 204 /* SyntaxKind.NamedTupleMember */:
             return isDeclarationVisible(c, node.parent);
         // Imports are visible only once something refers to them.
-        case 274 /* SyntaxKind.ImportClause */:
-        case 275 /* SyntaxKind.NamespaceImport */:
-        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 275 /* SyntaxKind.ImportClause */:
+        case 276 /* SyntaxKind.NamespaceImport */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
             return false;
-        case 169 /* SyntaxKind.TypeParameter */:
-        case 307 /* SyntaxKind.SourceFile */:
-        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 170 /* SyntaxKind.TypeParameter */:
+        case 308 /* SyntaxKind.SourceFile */:
+        case 272 /* SyntaxKind.NamespaceExportDeclaration */:
             return true;
-        case 278 /* SyntaxKind.ExportAssignment */:
+        case 279 /* SyntaxKind.ExportAssignment */:
             return false;
         // `export { x }` without a module specifier re-exports `x` visibly.
-        case 282 /* SyntaxKind.ExportSpecifier */: {
+        case 283 /* SyntaxKind.ExportSpecifier */: {
             const exportDeclaration = node.parent.parent;
             if (exportDeclaration instanceof ExportDeclaration && exportDeclaration.moduleSpecifier === undefined)
                 return isDeclarationVisible(c, exportDeclaration.parent);
@@ -943,7 +956,7 @@ export function hasVisibleDeclarations(c, symbol, shouldComputeAliasesToMakeVisi
             continue;
         }
         if (declaration instanceof VariableDeclaration &&
-            declaration.parent.parent.kind === 244 /* SyntaxKind.VariableStatement */ &&
+            declaration.parent.parent.kind === 245 /* SyntaxKind.VariableStatement */ &&
             !hasSyntacticModifier(declaration.parent.parent, 32 /* ModifierFlags.Export */) &&
             isDeclarationVisible(c, declaration.parent.parent.parent)) {
             addVisibleAlias(declaration, declaration.parent.parent);
@@ -961,7 +974,7 @@ export function hasVisibleDeclarations(c, symbol, shouldComputeAliasesToMakeVisi
                 const statement = declaration.parent?.parent?.parent?.parent;
                 if (declaration.parent?.parent instanceof VariableDeclaration &&
                     statement !== undefined &&
-                    statement.kind === 244 /* SyntaxKind.VariableStatement */ &&
+                    statement.kind === 245 /* SyntaxKind.VariableStatement */ &&
                     !hasSyntacticModifier(statement, 32 /* ModifierFlags.Export */) &&
                     statement.parent !== undefined &&
                     isDeclarationVisible(c, statement.parent)) {
@@ -971,10 +984,10 @@ export function hasVisibleDeclarations(c, symbol, shouldComputeAliasesToMakeVisi
             }
             if ((symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0) {
                 const root = getRootDeclaration(declaration);
-                if (root.kind === 170 /* SyntaxKind.Parameter */)
+                if (root.kind === 171 /* SyntaxKind.Parameter */)
                     return undefined;
                 const variableStatement = root.parent?.parent;
-                if (variableStatement === undefined || variableStatement.kind !== 244 /* SyntaxKind.VariableStatement */)
+                if (variableStatement === undefined || variableStatement.kind !== 245 /* SyntaxKind.VariableStatement */)
                     return undefined;
                 // Already exported: nothing to keep.
                 if (hasSyntacticModifier(variableStatement, 32 /* ModifierFlags.Export */))

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

@@ -107,22 +107,26 @@ export declare const enum CheckFlags {
     ContainsPublic = 256,
     ContainsProtected = 512,
     ContainsPrivate = 1024,
-    ContainsStatic = 2048,
+    /** A synthetic property with public, protected or private write access in a constituent. */
+    ContainsWritePublic = 2048,
+    ContainsWriteProtected = 4096,
+    ContainsWritePrivate = 8192,
+    ContainsStatic = 16384,
     /** Late-bound from a computed property name. */
-    Late = 4096,
-    ReverseMapped = 8192,
-    OptionalParameter = 16384,
-    RestParameter = 32768,
+    Late = 32768,
+    ReverseMapped = 65536,
+    OptionalParameter = 131072,
+    RestParameter = 262144,
     /** The type is computed on demand. */
-    DeferredType = 65536,
-    HasNeverType = 131072,
-    Mapped = 262144,
-    StripOptional = 524288,
-    Unresolved = 1048576,
-    IsDiscriminantComputed = 2097152,
-    IsDiscriminant = 4194304,
+    DeferredType = 524288,
+    HasNeverType = 1048576,
+    Mapped = 2097152,
+    StripOptional = 4194304,
+    Unresolved = 8388608,
+    IsDiscriminantComputed = 16777216,
+    IsDiscriminant = 33554432,
     /** Created from an index signature. */
-    IndexSymbol = 8388608,
+    IndexSymbol = 67108864,
     Synthetic = 6,
     NonUniformAndLiteral = 192,
     Partial = 48
@@ -235,6 +239,11 @@ export declare function getMembers(symbol: Symbol): SymbolTable;
  * vanishingly unlikely in a string-literal property name.
  */
 export declare const internalSymbolNamePrefix = "\uFFFE";
+/**
+ * The module name of an ambient module symbol's name: `"name"`, or for a pattern module with import
+ * attributes, the internal symbol name prefix, `"name"pattern@` and the id of the attributes node.
+ */
+export declare function tryGetAmbientModuleNameFromSymbolName(name: string): string | undefined;
 export declare const enum InternalSymbolName {
     /** Call signatures. */
     Call = "\uFFFEcall",

package/dist/api/compiler/symbol.js

@@ -149,7 +149,7 @@ export class Symbol {
     }
     /** Whether this is the symbol of an external module, named by its quoted path. */
     isExternalModule() {
-        return (this.flags & 1536 /* SymbolFlags.Module */) !== 0 && this.name.charCodeAt(0) === 0x22;
+        return (this.flags & 1536 /* SymbolFlags.Module */) !== 0 && tryGetAmbientModuleNameFromSymbolName(this.name) !== undefined;
     }
     /** The flags of this symbol and its export symbol. */
     combinedLocalAndExportSymbolFlags() {
@@ -316,6 +316,20 @@ export function getMembers(symbol) {
  * vanishingly unlikely in a string-literal property name.
  */
 export const internalSymbolNamePrefix = '￾';
+/**
+ * The module name of an ambient module symbol's name: `"name"`, or for a pattern module with import
+ * attributes, the internal symbol name prefix, `"name"pattern@` and the id of the attributes node.
+ */
+export function tryGetAmbientModuleNameFromSymbolName(name) {
+    if (name.length >= 2 && name.charCodeAt(0) === 0x22 && name.charCodeAt(name.length - 1) === 0x22)
+        return name.substring(1, name.length - 1);
+    if (!name.startsWith(internalSymbolNamePrefix + '"'))
+        return undefined;
+    const markerIndex = name.lastIndexOf('"pattern@');
+    if (markerIndex < internalSymbolNamePrefix.length + 2)
+        return undefined;
+    return name.substring(internalSymbolNamePrefix.length + 1, markerIndex);
+}
 /** `name` with a leading internal prefix replaced by `__`. */
 export function escapeInternalSymbolName(name) {
     return name.startsWith(internalSymbolNamePrefix) ? '__' + name.substring(1) : name;