typescript 5.4.0-dev.20231207 → 5.4.0-dev.20231209

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231207`;
+var version = `${versionMajorMinor}.0-dev.20231209`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -16362,38 +16362,231 @@ function getSetExternalModuleIndicator(options) {
       return callback;
   }
 }
-function getEmitScriptTarget(compilerOptions) {
-  return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
-}
-function getEmitModuleKind(compilerOptions) {
-  return typeof compilerOptions.module === "number" ? compilerOptions.module : getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
+function createComputedCompilerOptions(options) {
+  return options;
 }
+var computedOptions = createComputedCompilerOptions({
+  target: {
+    dependencies: ["module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
+    }
+  },
+  module: {
+    dependencies: ["target"],
+    computeValue: (compilerOptions) => {
+      return typeof compilerOptions.module === "number" ? compilerOptions.module : computedOptions.target.computeValue(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
+    }
+  },
+  moduleResolution: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      let moduleResolution = compilerOptions.moduleResolution;
+      if (moduleResolution === void 0) {
+        switch (computedOptions.module.computeValue(compilerOptions)) {
+          case 1 /* CommonJS */:
+            moduleResolution = 2 /* Node10 */;
+            break;
+          case 100 /* Node16 */:
+            moduleResolution = 3 /* Node16 */;
+            break;
+          case 199 /* NodeNext */:
+            moduleResolution = 99 /* NodeNext */;
+            break;
+          default:
+            moduleResolution = 1 /* Classic */;
+            break;
+        }
+      }
+      return moduleResolution;
+    }
+  },
+  moduleDetection: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.moduleDetection || (computedOptions.module.computeValue(compilerOptions) === 100 /* Node16 */ || computedOptions.module.computeValue(compilerOptions) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
+    }
+  },
+  isolatedModules: {
+    dependencies: ["verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.isolatedModules || compilerOptions.verbatimModuleSyntax);
+    }
+  },
+  esModuleInterop: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.esModuleInterop !== void 0) {
+        return compilerOptions.esModuleInterop;
+      }
+      switch (computedOptions.module.computeValue(compilerOptions)) {
+        case 100 /* Node16 */:
+        case 199 /* NodeNext */:
+          return true;
+      }
+      return false;
+    }
+  },
+  allowSyntheticDefaultImports: {
+    dependencies: ["module", "target", "moduleResolution"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
+        return compilerOptions.allowSyntheticDefaultImports;
+      }
+      return computedOptions.esModuleInterop.computeValue(compilerOptions) || computedOptions.module.computeValue(compilerOptions) === 4 /* System */ || computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  resolvePackageJsonExports: {
+    dependencies: ["moduleResolution"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolvePackageJsonImports: {
+    dependencies: ["moduleResolution", "resolvePackageJsonExports"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolveJsonModule: {
+    dependencies: ["moduleResolution", "module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.resolveJsonModule !== void 0) {
+        return compilerOptions.resolveJsonModule;
+      }
+      return computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  declaration: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declaration || compilerOptions.composite);
+    }
+  },
+  preserveConstEnums: {
+    dependencies: ["isolatedModules", "verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.preserveConstEnums || computedOptions.isolatedModules.computeValue(compilerOptions));
+    }
+  },
+  incremental: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.incremental || compilerOptions.composite);
+    }
+  },
+  declarationMap: {
+    dependencies: ["declaration", "composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declarationMap && computedOptions.declaration.computeValue(compilerOptions));
+    }
+  },
+  allowJs: {
+    dependencies: ["checkJs"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
+    }
+  },
+  useDefineForClassFields: {
+    dependencies: ["target", "module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.useDefineForClassFields === void 0 ? computedOptions.target.computeValue(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
+    }
+  },
+  noImplicitAny: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitAny");
+    }
+  },
+  noImplicitThis: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitThis");
+    }
+  },
+  strictNullChecks: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictNullChecks");
+    }
+  },
+  strictFunctionTypes: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictFunctionTypes");
+    }
+  },
+  strictBindCallApply: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictBindCallApply");
+    }
+  },
+  strictPropertyInitialization: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
+    }
+  },
+  alwaysStrict: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "alwaysStrict");
+    }
+  },
+  useUnknownInCatchVariables: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
+    }
+  }
+});
+var getEmitScriptTarget = computedOptions.target.computeValue;
+var getEmitModuleKind = computedOptions.module.computeValue;
+var getEmitModuleResolutionKind = computedOptions.moduleResolution.computeValue;
+var getEmitModuleDetectionKind = computedOptions.moduleDetection.computeValue;
+var getIsolatedModules = computedOptions.isolatedModules.computeValue;
+var getESModuleInterop = computedOptions.esModuleInterop.computeValue;
+var getAllowSyntheticDefaultImports = computedOptions.allowSyntheticDefaultImports.computeValue;
+var getResolvePackageJsonExports = computedOptions.resolvePackageJsonExports.computeValue;
+var getResolvePackageJsonImports = computedOptions.resolvePackageJsonImports.computeValue;
+var getResolveJsonModule = computedOptions.resolveJsonModule.computeValue;
+var getEmitDeclarations = computedOptions.declaration.computeValue;
+var shouldPreserveConstEnums = computedOptions.preserveConstEnums.computeValue;
+var isIncrementalCompilation = computedOptions.incremental.computeValue;
+var getAreDeclarationMapsEnabled = computedOptions.declarationMap.computeValue;
+var getAllowJSCompilerOption = computedOptions.allowJs.computeValue;
+var getUseDefineForClassFields = computedOptions.useDefineForClassFields.computeValue;
 function emitModuleKindIsNonNodeESM(moduleKind) {
   return moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */;
 }
-function getEmitModuleResolutionKind(compilerOptions) {
-  let moduleResolution = compilerOptions.moduleResolution;
-  if (moduleResolution === void 0) {
-    switch (getEmitModuleKind(compilerOptions)) {
-      case 1 /* CommonJS */:
-        moduleResolution = 2 /* Node10 */;
-        break;
-      case 100 /* Node16 */:
-        moduleResolution = 3 /* Node16 */;
-        break;
-      case 199 /* NodeNext */:
-        moduleResolution = 99 /* NodeNext */;
-        break;
-      default:
-        moduleResolution = 1 /* Classic */;
-        break;
-    }
-  }
-  return moduleResolution;
-}
-function getEmitModuleDetectionKind(options) {
-  return options.moduleDetection || (getEmitModuleKind(options) === 100 /* Node16 */ || getEmitModuleKind(options) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
-}
 function hasJsonModuleEmitEnabled(options) {
   switch (getEmitModuleKind(options)) {
     case 1 /* CommonJS */:
@@ -16409,81 +16602,21 @@ function hasJsonModuleEmitEnabled(options) {
       return false;
   }
 }
-function getIsolatedModules(options) {
-  return !!(options.isolatedModules || options.verbatimModuleSyntax);
-}
 function unreachableCodeIsError(options) {
   return options.allowUnreachableCode === false;
 }
 function unusedLabelIsError(options) {
   return options.allowUnusedLabels === false;
 }
-function getAreDeclarationMapsEnabled(options) {
-  return !!(getEmitDeclarations(options) && options.declarationMap);
-}
-function getESModuleInterop(compilerOptions) {
-  if (compilerOptions.esModuleInterop !== void 0) {
-    return compilerOptions.esModuleInterop;
-  }
-  switch (getEmitModuleKind(compilerOptions)) {
-    case 100 /* Node16 */:
-    case 199 /* NodeNext */:
-      return true;
-  }
-  return void 0;
-}
-function getAllowSyntheticDefaultImports(compilerOptions) {
-  if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
-    return compilerOptions.allowSyntheticDefaultImports;
-  }
-  return getESModuleInterop(compilerOptions) || getEmitModuleKind(compilerOptions) === 4 /* System */ || getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
 function moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution) {
   return moduleResolution >= 3 /* Node16 */ && moduleResolution <= 99 /* NodeNext */ || moduleResolution === 100 /* Bundler */;
 }
 function shouldResolveJsRequire(compilerOptions) {
   return !!compilerOptions.noDtsResolution || getEmitModuleResolutionKind(compilerOptions) !== 100 /* Bundler */;
 }
-function getResolvePackageJsonExports(compilerOptions) {
-  const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-  if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-    return false;
-  }
-  if (compilerOptions.resolvePackageJsonExports !== void 0) {
-    return compilerOptions.resolvePackageJsonExports;
-  }
-  switch (moduleResolution) {
-    case 3 /* Node16 */:
-    case 99 /* NodeNext */:
-    case 100 /* Bundler */:
-      return true;
-  }
-  return false;
-}
-function getResolveJsonModule(compilerOptions) {
-  if (compilerOptions.resolveJsonModule !== void 0) {
-    return compilerOptions.resolveJsonModule;
-  }
-  return getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
-function getEmitDeclarations(compilerOptions) {
-  return !!(compilerOptions.declaration || compilerOptions.composite);
-}
-function shouldPreserveConstEnums(compilerOptions) {
-  return !!(compilerOptions.preserveConstEnums || getIsolatedModules(compilerOptions));
-}
-function isIncrementalCompilation(options) {
-  return !!(options.incremental || options.composite);
-}
 function getStrictOptionValue(compilerOptions, flag) {
   return compilerOptions[flag] === void 0 ? !!compilerOptions.strict : !!compilerOptions[flag];
 }
-function getAllowJSCompilerOption(compilerOptions) {
-  return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
-}
-function getUseDefineForClassFields(compilerOptions) {
-  return compilerOptions.useDefineForClassFields === void 0 ? getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
-}
 function getEmitStandardClassFields(compilerOptions) {
   return compilerOptions.useDefineForClassFields !== false && getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */;
 }
@@ -18839,8 +18972,10 @@ function createNodeFactory(flags, baseFactory2) {
     return update(updated, original);
   }
   function createNumericLiteral(value, numericLiteralFlags = 0 /* None */) {
+    const text = typeof value === "number" ? value + "" : value;
+    Debug.assert(text.charCodeAt(0) !== 45 /* minus */, "Negative numbers should be created in combination with createPrefixUnaryExpression");
     const node = createBaseDeclaration(9 /* NumericLiteral */);
-    node.text = typeof value === "number" ? value + "" : value;
+    node.text = text;
     node.numericLiteralFlags = numericLiteralFlags;
     if (numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */)
       node.transformFlags |= 1024 /* ContainsES2015 */;
@@ -35893,7 +36028,8 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     ),
     (f) => getRelativePathFromFile(getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName)
   );
-  const optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
+  const pathOptions = { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames };
+  const optionMap = serializeCompilerOptions(configParseResult.options, pathOptions);
   const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
   const config = {
     compilerOptions: {
@@ -35918,6 +36054,18 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     } : {},
     compileOnSave: !!configParseResult.compileOnSave ? true : void 0
   };
+  const providedKeys = new Set(optionMap.keys());
+  const impliedCompilerOptions = {};
+  for (const option in computedOptions) {
+    if (!providedKeys.has(option) && some(computedOptions[option].dependencies, (dep) => providedKeys.has(dep))) {
+      const implied = computedOptions[option].computeValue(configParseResult.options);
+      const defaultValue = computedOptions[option].computeValue({});
+      if (implied !== defaultValue) {
+        impliedCompilerOptions[option] = computedOptions[option].computeValue(configParseResult.options);
+      }
+    }
+  }
+  assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
   return config;
 }
 function optionMapToObject(optionMap) {
@@ -49567,7 +49715,7 @@ function createTypeChecker(host) {
             return factory.createStringLiteral(name, !!singleQuote);
           }
           if (isNumericLiteralName(name) && startsWith(name, "-")) {
-            return factory.createComputedPropertyName(factory.createNumericLiteral(+name));
+            return factory.createComputedPropertyName(factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(-name)));
           }
           return createPropertyNameNodeForIdentifierOrLiteral(name, getEmitScriptTarget(compilerOptions), singleQuote, stringNamed, isMethod);
         }
@@ -53633,11 +53781,10 @@ function createTypeChecker(host) {
     const baseTypes = getBaseTypes(source);
     if (baseTypes.length) {
       if (source.symbol && members === getMembersOfSymbol(source.symbol)) {
-        const symbolTable = createSymbolTable();
-        for (const symbol of members.values()) {
-          if (!(symbol.flags & 262144 /* TypeParameter */)) {
-            symbolTable.set(symbol.escapedName, symbol);
-          }
+        const symbolTable = createSymbolTable(source.declaredProperties);
+        const sourceIndex = getIndexSymbol(source.symbol);
+        if (sourceIndex) {
+          symbolTable.set("__index" /* Index */, sourceIndex);
         }
         members = symbolTable;
       }
@@ -58302,7 +58449,9 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
-      const checkTuples = isSimpleTupleType(root.node.checkType) && isSimpleTupleType(root.node.extendsType) && length(root.node.checkType.elements) === length(root.node.extendsType.elements);
+      const checkTypeNode = skipTypeParentheses(root.node.checkType);
+      const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
+      const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
       const checkTypeDeferred = isDeferredType(checkType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
@@ -82648,7 +82797,7 @@ function createTypeChecker(host) {
     if (enumResult)
       return enumResult;
     const literalValue = type.value;
-    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "number" ? factory.createNumericLiteral(literalValue) : factory.createStringLiteral(literalValue);
+    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "string" ? factory.createStringLiteral(literalValue) : literalValue < 0 ? factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(-literalValue)) : factory.createNumericLiteral(literalValue);
   }
   function createLiteralConstValue(node, tracker) {
     const type = getTypeOfSymbol(getSymbolOfDeclaration(node));
@@ -89077,7 +89226,7 @@ function transformTypeScript(context) {
   function transformEnumMemberDeclarationValue(member) {
     const value = resolver.getConstantValue(member);
     if (value !== void 0) {
-      return typeof value === "string" ? factory2.createStringLiteral(value) : factory2.createNumericLiteral(value);
+      return typeof value === "string" ? factory2.createStringLiteral(value) : value < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-value)) : factory2.createNumericLiteral(value);
     } else {
       enableSubstitutionForNonQualifiedEnumMembers();
       if (member.initializer) {
@@ -89607,7 +89756,7 @@ function transformTypeScript(context) {
     const constantValue = tryGetConstEnumValue(node);
     if (constantValue !== void 0) {
       setConstantValue(node, constantValue);
-      const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(Math.abs(constantValue))) : factory2.createNumericLiteral(constantValue);
+      const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constantValue)) : factory2.createNumericLiteral(constantValue);
       if (!compilerOptions.removeComments) {
         const originalNode = getOriginalNode(node, isAccessExpression);
         addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, ` ${safeMultiLineComment(getTextOfNode(originalNode))} `);
@@ -103397,7 +103546,7 @@ function transformGenerators(context) {
       if (labelExpressions === void 0) {
         labelExpressions = [];
       }
-      const expression = factory2.createNumericLiteral(-1);
+      const expression = factory2.createNumericLiteral(Number.MAX_SAFE_INTEGER);
       if (labelExpressions[label] === void 0) {
         labelExpressions[label] = [expression];
       } else {
@@ -109272,7 +109421,8 @@ function transformDeclarations(context) {
             if (shouldStripInternal(m))
               return;
             const constValue = resolver.getConstantValue(m);
-            return preserveJsDoc(factory2.updateEnumMember(m, m.name, constValue !== void 0 ? typeof constValue === "string" ? factory2.createStringLiteral(constValue) : factory2.createNumericLiteral(constValue) : void 0), m);
+            const newInitializer = constValue === void 0 ? void 0 : typeof constValue === "string" ? factory2.createStringLiteral(constValue) : constValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constValue)) : factory2.createNumericLiteral(constValue);
+            return preserveJsDoc(factory2.updateEnumMember(m, m.name, newInitializer), m);
           }))
         ));
       }
@@ -111162,6 +111312,8 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       );
     if (hint === 3 /* MappedTypeParameter */)
       return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));
+    if (hint === 7 /* ImportTypeNodeAttributes */)
+      return emitImportTypeNodeAttributes(cast(node, isImportAttributes));
     if (hint === 5 /* EmbeddedStatement */) {
       Debug.assertNode(node, isEmptyStatement);
       return emitEmptyStatement(
@@ -112138,15 +112290,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     if (node.attributes) {
       writePunctuation(",");
       writeSpace();
-      writePunctuation("{");
-      writeSpace();
-      writeKeyword(node.attributes.token === 132 /* AssertKeyword */ ? "assert" : "with");
-      writePunctuation(":");
-      writeSpace();
-      const elements = node.attributes.elements;
-      emitList(node.attributes, elements, 526226 /* ImportAttributes */);
-      writeSpace();
-      writePunctuation("}");
+      pipelineEmit(7 /* ImportTypeNodeAttributes */, node.attributes);
     }
     writePunctuation(")");
     if (node.qualifier) {
@@ -113208,6 +113352,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     writeTrailingSemicolon();
   }
+  function emitImportTypeNodeAttributes(node) {
+    writePunctuation("{");
+    writeSpace();
+    writeKeyword(node.token === 132 /* AssertKeyword */ ? "assert" : "with");
+    writePunctuation(":");
+    writeSpace();
+    const elements = node.elements;
+    emitList(node, elements, 526226 /* ImportAttributes */);
+    writeSpace();
+    writePunctuation("}");
+  }
   function emitImportAttributes(node) {
     emitTokenWithComment(node.token, node.pos, writeKeyword, node);
     writeSpace();