@gi-tcg/gts-transpiler 0.7.6 → 0.8.0

package/dist/index.d.ts

@@ -105,6 +105,12 @@ interface VolarMappingResult {
   mappings: CodeMapping[];
 }
 //#endregion
+//#region src/transform/volar/index.d.ts
+interface VolarTranspileOption extends TranspileOption {
+  /** Omit editor-only expressions, retaining all type validation. */
+  typeCheckingOnly: boolean;
+}
+//#endregion
 //#region src/transform/index.d.ts
 interface TranspileResult {
   code: string;
@@ -1534,6 +1540,6 @@ declare function isGtsShortcutArgumentStartingConciseBody(node: AST$1.Expression
 //#endregion
 //#region src/index.d.ts
 declare function transpile(source: string, filename: string, option: TranspileOption): TranspileResult;
-declare function transpileForVolar(source: string, filename: string, option: TranspileOption): VolarMappingResult;
+declare function transpileForVolar(source: string, filename: string, option: VolarTranspileOption): VolarMappingResult;
 //#endregion
-export { type AST, type GtsConfig, type ParseLooseOptions as GtsParseLooseOptions, type ParseOptions as GtsParseOptions, GtsTranspilerError, type PathModule, type ResolveGtsConfigAsyncOptions, type ResolveGtsConfigSyncOptions, type TranspileOption, type TranspileResult, type VolarMappingResult, isGtsShortcutArgumentStartingConciseBody, parse, parseLoose, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };
+export { type AST, type GtsConfig, type ParseLooseOptions as GtsParseLooseOptions, type ParseOptions as GtsParseOptions, GtsTranspilerError, type PathModule, type ResolveGtsConfigAsyncOptions, type ResolveGtsConfigSyncOptions, type TranspileOption, type TranspileResult, type VolarMappingResult, type VolarTranspileOption, isGtsShortcutArgumentStartingConciseBody, parse, parseLoose, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };

package/dist/index.js

@@ -1163,16 +1163,11 @@ function applyReplacements(state, code, mappings) {
 	const NamedDefinition = JSON.stringify(NamedDefinitionLit.value);
 	const Meta = JSON.stringify(MetaLit.value);
 	const matchInfos = [];
+	let cumulativeOffset = 0;
 	const result = code.replace(replacementRegex, (match, rawPayload, offset) => {
 		const payload = JSON.parse(rawPayload.replace(/\\`/g, "`"));
 		let replacement;
-		if (payload.type === "preface") replacement = dedent`
-        namespace ${state.utilNsId.name} {
-          export type UniqueKeyProbSegment = "__gts_unique_prob_seg__";
-          export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-        }
-      `;
-		else if (payload.type === "enterVMFromRoot") replacement = dedent`
+		if (payload.type === "enterVMFromRoot") replacement = dedent`
         type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition}];
         type ${payload.metaType} = ${payload.defType}[${Meta}];
       `;
@@ -1181,11 +1176,10 @@ function applyReplacements(state, code, mappings) {
         type ${payload.metaType} = ${payload.defType}[${Meta}];
       `;
 		else if (payload.type === "exitVM") {
-			const lhs = `${payload.finalMetaType}_lhs`;
 			const requiredAttrsNs = `${payload.finalMetaType}_rans`;
-			const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ") || "never"}`;
+			const collectedAttrsExpr = [...new Set(payload.collectedAttrs)].join(" | ") || "never";
 			const length = payload.errorRange ? payload.errorRange[1] - payload.errorRange[0] : 0;
-			const needleString = `"${requiredAttrsNs}_NeedleString${"0".repeat(length)}" as string as ${requiredAttrsNs}.DiagMsg`;
+			const needleString = `"${requiredAttrsNs}" as string as ${state.utilNsId.name}.RequiredMessage<${requiredAttrsNs}, ${collectedAttrsExpr}>`;
 			if (payload.errorRange) state.extraMappings.push({
 				sourceOffset: payload.errorRange[0],
 				length,
@@ -1193,19 +1187,8 @@ function applyReplacements(state, code, mappings) {
 			});
 			replacement = dedent`
         type ${payload.finalMetaType} = ${payload.metaType};
-        let ${lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${Meta}>;
-        type ${lhs} = typeof ${lhs};
-        namespace ${requiredAttrsNs} {
-          export type Collected = ${collectedAttrsExpr};
-          export type Expected = {
-            [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never;
-          }[keyof ${payload.defType}];
-          type DiagObj = {
-            [K in Expected]: K extends Collected ? never : \`'\${K}' is a required attribute but not provided\`;
-          }
-          export type DiagMsg = DiagObj[Expected];
-        };
-        ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
+        type ${requiredAttrsNs} = ${state.utilNsId.name}.RequiredAttrs<${state.utilNsId.name}.WithMeta<${payload.defType}, ${payload.metaType}>>;
+        ${state.utilNsId.name}.checkRequired<${requiredAttrsNs}, ${collectedAttrsExpr}>(${needleString});
       `;
 		} else if (payload.type === "enterAttr") {
 			const uniqueKeyLhs = `${payload.lhs}_uniqueKey_lhs`;
@@ -1214,39 +1197,20 @@ function applyReplacements(state, code, mappings) {
 			const uniqueKeyHelperIntf = `${payload.defType}_uniqueKeyProbeHelper`;
 			const omittedKeys = `${payload.lhs}_omittedKeys`;
 			replacement = dedent`
-        type ${uniqueKeyLhs} = {
-          ${Meta}: ${payload.metaType}; 
-          uniqueKey: ${payload.defType} extends { [${payload.attrName}]: { uniqueKey: infer UniqueKey } } ? UniqueKey : () => 0;
-        };
-        
-        let ${uniqueKeyLhs}!: ${uniqueKeyLhs};
+        declare const ${uniqueKeyLhs}: { ${Meta}: ${payload.metaType}; uniqueKey: ${state.utilNsId.name}.Member<${payload.defType}, ${payload.attrName}, "uniqueKey", () => 0> };
         let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
         type ${uniqueKey} = typeof ${uniqueKey};
         let ${uniqueKeyForThis}!: \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}${payload.lhs}\`;
         interface ${uniqueKeyHelperIntf} {
           [${uniqueKeyForThis}]: 1;
         }
-        type ${omittedKeys} = ${Meta} | (
-          ${uniqueKey} extends 0
-          ? never                                                 /* no unique requirement */
-            : string extends keyof ${uniqueKeyHelperIntf}
-              ? keyof ${payload.defType}                          /* too loose, disable all */
-              : ${state.utilNsId.name}.UnionToIntersection<
-                keyof ${uniqueKeyHelperIntf} & \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}\${string}\`
-              > extends never
-                ? ${payload.attrName}                             /* have duplicate, disable this */
-                : never
-        );
+        type ${omittedKeys} = ${Meta} | (${uniqueKey} extends 0 ? never : string extends keyof ${uniqueKeyHelperIntf} ? keyof ${payload.defType} : ${state.utilNsId.name}.UnionToIntersection<keyof ${uniqueKeyHelperIntf} & \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}\${string}\`> extends never ? ${payload.attrName} : never);
         let ${payload.lhs}!: ${payload.hintOnly ? `{}` : `{ ${Meta}: ${payload.metaType} }`} & Omit<${payload.defType}, ${omittedKeys}>;
       `;
 		} else if (payload.type === "createBindingTyping") {
 			const typingIdLhs = `${payload.typingId}_lhs`;
 			replacement = dedent`
-        type ${typingIdLhs} = {
-          ${Meta}: ${payload.finalMetaType};
-          as: ${payload.defType} extends { [${payload.attrName}]: { as: infer As } } ? As : unknown;
-        };
-        let ${typingIdLhs}!: ${typingIdLhs};
+        declare const ${typingIdLhs}: { ${Meta}: ${payload.finalMetaType}; as: ${state.utilNsId.name}.Member<${payload.defType}, ${payload.attrName}, "as", unknown> };
         let ${payload.typingId} = ${typingIdLhs}.as();
         type ${payload.typingId} = typeof ${payload.typingId};
       `;
@@ -1257,24 +1221,28 @@ function applyReplacements(state, code, mappings) {
 			replacement = dedent`
         type ${payload.returnType} = typeof ${payload.returnType};
         type ${rewrittenMeta} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType};
-        let ${mergeFn}!: ${payload.defType} extends {
-          [${payload.attrName}]: { mergeMeta: infer M }
-       } ? M : <const T>(x: T, y: unknown) => T;
+        declare const ${mergeFn}: ${state.utilNsId.name}.MergeMeta<${payload.defType}, ${payload.attrName}>;
         let ${mergeFnRet} = ${mergeFn}(null! as ${rewrittenMeta}, null! as ${payload.innerMetaType});
         type ${payload.newMetaType} = [typeof ${mergeFn}] extends [null] ? ${rewrittenMeta} : typeof ${mergeFnRet};
       `;
 		} else replacement = "";
+		cumulativeOffset += replacement.length - match.length;
 		matchInfos.push({
 			sourceEnd: offset + match.length,
-			lengthOffset: replacement.length - match.length
+			lengthOffset: cumulativeOffset
 		});
 		return replacement;
 	});
 	for (const mapping of mappings) for (let i = 0; i < mapping.generatedOffsets.length; i++) {
 		const orig = mapping.generatedOffsets[i];
-		let shift = 0;
-		for (const info of matchInfos) if (orig >= info.sourceEnd) shift += info.lengthOffset;
-		mapping.generatedOffsets[i] = orig + shift;
+		let low = 0;
+		let high = matchInfos.length;
+		while (low < high) {
+			const mid = low + high >>> 1;
+			if (matchInfos[mid].sourceEnd <= orig) low = mid + 1;
+			else high = mid;
+		}
+		mapping.generatedOffsets[i] = orig + (matchInfos[low - 1]?.lengthOffset ?? 0);
 	}
 	return result;
 }
@@ -1398,6 +1366,7 @@ const exitAttr = (state, attrName, innerVMFinalMetaId, returningId) => {
 	}));
 };
 const insertHintStatement = (state, whiteSpaceStart, whiteSpaceEnd) => {
+	if (state.typeCheckingOnly) return;
 	const { lhsId } = enterAttr(state, ATTR_HINT_ATTR_NAME);
 	state.typingPendingStatements.push({
 		type: "GTSAttributeNameHintStatement",
@@ -1465,21 +1434,32 @@ const gtsToTypingsWalker = {
 			attributes: []
 		}, {
 			type: "ImportDeclaration",
-			specifiers: [{
-				type: "ImportSpecifier",
-				imported: {
-					type: "Identifier",
-					name: "createDefine"
+			specifiers: [
+				{
+					type: "ImportSpecifier",
+					imported: {
+						type: "Identifier",
+						name: "createDefine"
+					},
+					local: state.createDefineFnId
 				},
-				local: state.createDefineFnId
-			}, {
-				type: "ImportSpecifier",
-				imported: {
-					type: "Identifier",
-					name: "createBinding"
+				{
+					type: "ImportSpecifier",
+					imported: {
+						type: "Identifier",
+						name: "createBinding"
+					},
+					local: state.createBindingFnId
 				},
-				local: state.createBindingFnId
-			}],
+				{
+					type: "ImportSpecifier",
+					imported: {
+						type: "Identifier",
+						name: "TypingUtils"
+					},
+					local: state.utilNsId
+				}
+			],
 			source: {
 				type: "Literal",
 				value: state.runtimeImportSource
@@ -1505,7 +1485,7 @@ const gtsToTypingsWalker = {
 				type: "Literal",
 				value: 0
 			}
-		}, lastImportDecl, createReplacementHolder(state, { type: "preface" }));
+		}, lastImportDecl);
 		return {
 			...node,
 			body
@@ -1911,6 +1891,7 @@ function transformForVolar(ast, option, sourceInfo) {
 		metaTypeIdStack: [],
 		finalMetaTypeIdStack: [],
 		attrsOfCurrentVm: [],
+		typeCheckingOnly: option.typeCheckingOnly,
 		sourceNodes: /* @__PURE__ */ new WeakSet(),
 		attributeNameNodes: /* @__PURE__ */ new WeakSet(),
 		namedAttributeCalleeLParenRange: /* @__PURE__ */ new WeakMap(),
@@ -1948,10 +1929,9 @@ function transformForVolar(ast, option, sourceInfo) {
 	for (const extraMapping of state.extraMappings) {
 		const genOffset = code.indexOf(extraMapping.generatedNeedle);
 		mappings.push({
-			sourceOffsets: [extraMapping.sourceOffset],
-			lengths: [extraMapping.length],
-			generatedOffsets: [genOffset],
-			generatedLengths: [extraMapping.generatedNeedle.length],
+			sourceOffsets: [extraMapping.sourceOffset, extraMapping.sourceOffset + extraMapping.length],
+			lengths: [0, 0],
+			generatedOffsets: [genOffset, genOffset + extraMapping.generatedNeedle.length],
 			data: VERIFICATION_ONLY_MAPPING_DATA
 		});
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gi-tcg/gts-transpiler",
-  "version": "0.7.6",
+  "version": "0.8.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/piovium/gts.git"
@@ -22,7 +22,7 @@
     "@sveltejs/acorn-typescript": "^1.0.8",
     "acorn": "^8.15.0",
     "dedent": "^1.7.2",
-    "espolar": "^0.6.5",
+    "espolar": "^0.6.7",
     "esrap": "2.2.1",
     "magic-string": "^0.30.21",
     "path-browserify-esm": "^1.0.6",

package/src/index.ts

@@ -10,7 +10,10 @@ import {
   type TranspileResult,
 } from "./transform/index.ts";
 import type { TranspileOption } from "./transform/gts.ts";
-import type { VolarMappingResult } from "./transform/volar/index.ts";
+import type {
+  VolarMappingResult,
+  VolarTranspileOption,
+} from "./transform/volar/index.ts";
 export { GtsTranspilerError } from "./error.ts";
 export type { AST } from "./types.ts";
 
@@ -29,7 +32,7 @@ export function transpile(
 export function transpileForVolar(
   source: string,
   filename: string,
-  option: TranspileOption,
+  option: VolarTranspileOption,
 ): VolarMappingResult {
   const ast = parseLoose(source, {
     recordCallLParens: true,
@@ -47,6 +50,7 @@ export type {
   TranspileOption,
   TranspileResult,
   VolarMappingResult,
+  VolarTranspileOption,
 };
 export {
   resolveGtsConfig,

package/src/transform/volar/index.ts

@@ -17,9 +17,14 @@ import {
 import { getPrintOptions } from "./printer.ts";
 import { getContentStartOffset } from "./content_start.ts";
 
+export interface VolarTranspileOption extends TranspileOption {
+  /** Omit editor-only expressions, retaining all type validation. */
+  typeCheckingOnly: boolean;
+}
+
 export function transformForVolar(
   ast: Program,
-  option: TranspileOption,
+  option: VolarTranspileOption,
   sourceInfo: Required<SourceInfo>,
 ): VolarMappingResult {
   const state: TypingTranspileState = {
@@ -39,6 +44,7 @@ export function transformForVolar(
     metaTypeIdStack: [],
     finalMetaTypeIdStack: [],
     attrsOfCurrentVm: [],
+    typeCheckingOnly: option.typeCheckingOnly,
 
     sourceNodes: new WeakSet(),
     attributeNameNodes: new WeakSet(),
@@ -92,10 +98,15 @@ export function transformForVolar(
   for (const extraMapping of state.extraMappings) {
     const genOffset = code.indexOf(extraMapping.generatedNeedle);
     mappings.push({
-      sourceOffsets: [extraMapping.sourceOffset],
-      lengths: [extraMapping.length],
-      generatedOffsets: [genOffset],
-      generatedLengths: [extraMapping.generatedNeedle.length],
+      sourceOffsets: [
+        extraMapping.sourceOffset,
+        extraMapping.sourceOffset + extraMapping.length,
+      ],
+      lengths: [0, 0],
+      generatedOffsets: [
+        genOffset,
+        genOffset + extraMapping.generatedNeedle.length,
+      ],
       data: VERIFICATION_ONLY_MAPPING_DATA,
     });
   }

package/src/transform/volar/replacements.ts

@@ -9,9 +9,6 @@ interface MatchInfo {
 }
 
 type ReplacementPayload =
-  | {
-      type: "preface";
-    }
   | {
       type: "enterVMFromRoot";
       vm: string;
@@ -95,6 +92,7 @@ export function applyReplacements(
   const NamedDefinition = JSON.stringify(NamedDefinitionLit.value);
   const Meta = JSON.stringify(MetaLit.value);
   const matchInfos: MatchInfo[] = [];
+  let cumulativeOffset = 0;
 
   const result = code.replace(
     replacementRegex,
@@ -103,14 +101,7 @@ export function applyReplacements(
         rawPayload.replace(/\\`/g, "`"),
       );
       let replacement: string;
-      if (payload.type === "preface") {
-        replacement = dedent`
-        namespace ${state.utilNsId.name} {
-          export type UniqueKeyProbSegment = "__gts_unique_prob_seg__";
-          export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-        }
-      `;
-      } else if (payload.type === "enterVMFromRoot") {
+      if (payload.type === "enterVMFromRoot") {
         replacement = dedent`
         type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition}];
         type ${payload.metaType} = ${payload.defType}[${Meta}];
@@ -121,14 +112,15 @@ export function applyReplacements(
         type ${payload.metaType} = ${payload.defType}[${Meta}];
       `;
       } else if (payload.type === "exitVM") {
-        const lhs = `${payload.finalMetaType}_lhs`;
         const requiredAttrsNs = `${payload.finalMetaType}_rans`;
-        const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ") || "never"}`;
+        const collectedAttrsExpr =
+          [...new Set(payload.collectedAttrs)].join(" | ") || "never";
         const length = payload.errorRange
           ? payload.errorRange[1] - payload.errorRange[0]
           : 0;
-        // Ensure that generated needle string is longer than error range so that error squiggle can cover all
-        const needleString = `"${requiredAttrsNs}_NeedleString${"0".repeat(length)}" as string as ${requiredAttrsNs}.DiagMsg`;
+        // Map both ends explicitly; nested blocks no longer need a copy of
+        // their entire source length as padding in every diagnostic string.
+        const needleString = `"${requiredAttrsNs}" as string as ${state.utilNsId.name}.RequiredMessage<${requiredAttrsNs}, ${collectedAttrsExpr}>`;
         if (payload.errorRange) {
           state.extraMappings.push({
             sourceOffset: payload.errorRange[0],
@@ -138,19 +130,8 @@ export function applyReplacements(
         }
         replacement = dedent`
         type ${payload.finalMetaType} = ${payload.metaType};
-        let ${lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${Meta}>;
-        type ${lhs} = typeof ${lhs};
-        namespace ${requiredAttrsNs} {
-          export type Collected = ${collectedAttrsExpr};
-          export type Expected = {
-            [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never;
-          }[keyof ${payload.defType}];
-          type DiagObj = {
-            [K in Expected]: K extends Collected ? never : \`'\${K}' is a required attribute but not provided\`;
-          }
-          export type DiagMsg = DiagObj[Expected];
-        };
-        ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
+        type ${requiredAttrsNs} = ${state.utilNsId.name}.RequiredAttrs<${state.utilNsId.name}.WithMeta<${payload.defType}, ${payload.metaType}>>;
+        ${state.utilNsId.name}.checkRequired<${requiredAttrsNs}, ${collectedAttrsExpr}>(${needleString});
       `;
       } else if (payload.type === "enterAttr") {
         const uniqueKeyLhs = `${payload.lhs}_uniqueKey_lhs`;
@@ -158,40 +139,25 @@ export function applyReplacements(
         const uniqueKeyForThis = `${payload.lhs}_uniqueKeyFor_${payload.lhs}`;
         const uniqueKeyHelperIntf = `${payload.defType}_uniqueKeyProbeHelper`;
         const omittedKeys = `${payload.lhs}_omittedKeys`;
+        // Keep Meta inside the receiver's property. Passing it to a generic
+        // receiver alias eagerly resolves later probes and can form a cycle.
         replacement = dedent`
-        type ${uniqueKeyLhs} = {
-          ${Meta}: ${payload.metaType}; 
-          uniqueKey: ${payload.defType} extends { [${payload.attrName}]: { uniqueKey: infer UniqueKey } } ? UniqueKey : () => 0;
-        };
-        
-        let ${uniqueKeyLhs}!: ${uniqueKeyLhs};
+        declare const ${uniqueKeyLhs}: { ${Meta}: ${payload.metaType}; uniqueKey: ${state.utilNsId.name}.Member<${payload.defType}, ${payload.attrName}, "uniqueKey", () => 0> };
         let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
         type ${uniqueKey} = typeof ${uniqueKey};
         let ${uniqueKeyForThis}!: \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}${payload.lhs}\`;
         interface ${uniqueKeyHelperIntf} {
           [${uniqueKeyForThis}]: 1;
         }
-        type ${omittedKeys} = ${Meta} | (
-          ${uniqueKey} extends 0
-          ? never                                                 /* no unique requirement */
-            : string extends keyof ${uniqueKeyHelperIntf}
-              ? keyof ${payload.defType}                          /* too loose, disable all */
-              : ${state.utilNsId.name}.UnionToIntersection<
-                keyof ${uniqueKeyHelperIntf} & \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}\${string}\`
-              > extends never
-                ? ${payload.attrName}                             /* have duplicate, disable this */
-                : never
-        );
+        type ${omittedKeys} = ${Meta} | (${uniqueKey} extends 0 ? never : string extends keyof ${uniqueKeyHelperIntf} ? keyof ${payload.defType} : ${state.utilNsId.name}.UnionToIntersection<keyof ${uniqueKeyHelperIntf} & \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}\${string}\`> extends never ? ${payload.attrName} : never);
         let ${payload.lhs}!: ${payload.hintOnly ? `{}` : `{ ${Meta}: ${payload.metaType} }`} & Omit<${payload.defType}, ${omittedKeys}>;
       `;
       } else if (payload.type === "createBindingTyping") {
         const typingIdLhs = `${payload.typingId}_lhs`;
+        // As with uniqueKey, an as() without a Meta-aware this parameter must
+        // not force final Meta (which may itself depend on this binding).
         replacement = dedent`
-        type ${typingIdLhs} = {
-          ${Meta}: ${payload.finalMetaType};
-          as: ${payload.defType} extends { [${payload.attrName}]: { as: infer As } } ? As : unknown;
-        };
-        let ${typingIdLhs}!: ${typingIdLhs};
+        declare const ${typingIdLhs}: { ${Meta}: ${payload.finalMetaType}; as: ${state.utilNsId.name}.Member<${payload.defType}, ${payload.attrName}, "as", unknown> };
         let ${payload.typingId} = ${typingIdLhs}.as();
         type ${payload.typingId} = typeof ${payload.typingId};
       `;
@@ -202,33 +168,39 @@ export function applyReplacements(
         replacement = dedent`
         type ${payload.returnType} = typeof ${payload.returnType};
         type ${rewrittenMeta} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType};
-        let ${mergeFn}!: ${payload.defType} extends {
-          [${payload.attrName}]: { mergeMeta: infer M }
-       } ? M : <const T>(x: T, y: unknown) => T;
+        declare const ${mergeFn}: ${state.utilNsId.name}.MergeMeta<${payload.defType}, ${payload.attrName}>;
         let ${mergeFnRet} = ${mergeFn}(null! as ${rewrittenMeta}, null! as ${payload.innerMetaType});
         type ${payload.newMetaType} = [typeof ${mergeFn}] extends [null] ? ${rewrittenMeta} : typeof ${mergeFnRet};
       `;
       } else {
         replacement = "";
       }
+      cumulativeOffset += replacement.length - match.length;
       matchInfos.push({
         sourceEnd: offset + match.length,
-        lengthOffset: replacement.length - match.length,
+        lengthOffset: cumulativeOffset,
       });
       return replacement;
     },
   );
 
+  // 调整替换后 mapping 的 generatedOffset
+  // 由于替换信息 matchInfos 的 sourceEnd 是有序的，可以二分查找到对应的 lengthOffset
   for (const mapping of mappings) {
     for (let i = 0; i < mapping.generatedOffsets.length; i++) {
       const orig = mapping.generatedOffsets[i];
-      let shift = 0;
-      for (const info of matchInfos) {
-        if (orig >= info.sourceEnd) {
-          shift += info.lengthOffset;
+      let low = 0;
+      let high = matchInfos.length;
+      while (low < high) {
+        const mid = (low + high) >>> 1;
+        if (matchInfos[mid].sourceEnd <= orig) {
+          low = mid + 1;
+        } else {
+          high = mid;
         }
       }
-      mapping.generatedOffsets[i] = orig + shift;
+      mapping.generatedOffsets[i] =
+        orig + (matchInfos[low - 1]?.lengthOffset ?? 0);
     }
   }
 

package/src/transform/volar/walker.ts

@@ -32,6 +32,7 @@ interface ExternalizedTypedBinding extends ExternalizedBinding {
 }
 
 export interface TypingTranspileState extends TranspileState {
+  typeCheckingOnly: boolean;
   externalizedBindings: ExternalizedTypedBinding[];
   idCounter: number;
   rootVmId: Identifier;
@@ -283,6 +284,10 @@ const insertHintStatement = (
   whiteSpaceStart: number,
   whiteSpaceEnd: number,
 ) => {
+  if (state.typeCheckingOnly) {
+    // type-checking do not need insert hint statement
+    return;
+  }
   const { lhsId } = enterAttr(state, ATTR_HINT_ATTR_NAME);
   state.typingPendingStatements.push({
     type: "GTSAttributeNameHintStatement",
@@ -377,6 +382,11 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
             imported: { type: "Identifier", name: "createBinding" },
             local: state.createBindingFnId,
           },
+          {
+            type: "ImportSpecifier",
+            imported: { type: "Identifier", name: "TypingUtils" },
+            local: state.utilNsId,
+          },
         ],
         source: { type: "Literal", value: state.runtimeImportSource },
         attributes: [],
@@ -410,9 +420,6 @@ export const gtsToTypingsWalker: Visitors<Node, TypingTranspileState> = {
         },
       },
       lastImportDecl,
-      createReplacementHolder(state, {
-        type: "preface",
-      }),
     );
     return {
       ...node,