@gi-tcg/gts-transpiler 0.3.2 → 0.3.4

package/dist/index.js

@@ -3,7 +3,8 @@ import { tsPlugin } from "@sveltejs/acorn-typescript";
 import { walk } from "zimmerframe";
 import { print } from "esrap";
 import jsPrinter from "esrap/languages/ts";
-import { decode } from "@jridgewell/sourcemap-codec";
+import { defaultPrinters, print as print$1 } from "espolar";
+import dedent from "dedent";
 import path from "path-browserify-esm";
 //#region src/keywords.ts
 const specialIdentifiers = [
@@ -77,7 +78,7 @@ function loosePlugin() {
 				return value;
 			} });
 			createDummyIdentifier() {
-				const dummy = this.startNode();
+				const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
 				dummy.name = "✖";
 				dummy.isDummy = true;
 				return this.finishNode(dummy, "Identifier");
@@ -197,7 +198,7 @@ function gtsPlugin(options = {}) {
 					return this.gts_parseShortcutFunction();
 				}
 				if (this.gtsOptions.allowEmptyPositionalAttribute && (this.type === tokTypes.comma || this.type === tokTypes.braceR || this.type === tokTypes.semi || this.canInsertSemicolon() || this.isContextual("as"))) {
-					const dummy = this.startNode();
+					const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
 					dummy.name = "✖";
 					dummy.isDummy = true;
 					return this.finishNode(dummy, "Identifier");
@@ -228,7 +229,7 @@ function gtsPlugin(options = {}) {
 					const node = this.startNode();
 					this.next();
 					if (this.gtsOptions.allowEmptyShortcutMember && this.type !== tokTypes.name) {
-						const dummy = this.startNode();
+						const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
 						dummy.name = "✖";
 						dummy.isDummy = true;
 						node.property = this.finishNode(dummy, "Identifier");
@@ -475,35 +476,29 @@ var GtsTranspilerError = class extends Error {
 //#endregion
 //#region src/parse/record_call_lparen_plugin.ts
 /**
-* A plugin that records the location of the left parenthesis in CallExpression and 
+* A plugin that records the location of the left parenthesis in CallExpression and
 * NewExpression.
-* 
-* This is useful for Language tooling, that we can maps the '(' token from its location, 
-* to provide  * a signature help for user when they press `(` after a function name.
 *
-* The recorded location will be stored in `lParenLoc` property of the 
+* This is useful for Language tooling, that we can maps the '(' token from its location,
+* to provide a signature help for user when they press `(` after a function name.
+*
+* The recorded location will be stored in `lParenLoc` property of the
 * CallExpression/NewExpression node.
-* @returns
+* @returns the plugin function
 */
 function recordCallLParenPlugin() {
 	return function recordCallLParenPluginTransformer(parser) {
 		return class RecordCallLParenParser extends parser {
 			parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
 				let recordedLParenLoc = null;
-				if (!noCalls && this.type === tokTypes.parenL) recordedLParenLoc = {
-					start: this.startLoc,
-					end: this.endLoc
-				};
+				if (!noCalls && this.type === tokTypes.parenL) recordedLParenLoc = [this.start, this.end];
 				const result = super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
-				if (recordedLParenLoc && result.type === "CallExpression") result.lParenLoc = recordedLParenLoc;
+				if (recordedLParenLoc && result.type === "CallExpression") result.lParenRange = recordedLParenLoc;
 				return result;
 			}
-			_capturedLParenLocFromNew = null;
+			_capturedLParenRangeFromNew = null;
 			_patchedEat = (type) => {
-				if (type === tokTypes.parenL) this._capturedLParenLocFromNew = {
-					start: this.startLoc,
-					end: this.endLoc
-				};
+				if (type === tokTypes.parenL) this._capturedLParenRangeFromNew = [this.start, this.end];
 				return this.eat(type);
 			};
 			#proxiedThis = new Proxy(this, { get: (target, prop) => {
@@ -514,9 +509,9 @@ function recordCallLParenPlugin() {
 			} });
 			parseNew() {
 				const result = super.parseNew.apply(this.#proxiedThis);
-				if (this._capturedLParenLocFromNew && result.type === "NewExpression") {
-					result.lParenLoc = this._capturedLParenLocFromNew;
-					this._capturedLParenLocFromNew = null;
+				if (this._capturedLParenRangeFromNew && result.type === "NewExpression") {
+					result.lParenRange = this._capturedLParenRangeFromNew;
+					this._capturedLParenRangeFromNew = null;
 				}
 				return result;
 			}
@@ -531,7 +526,8 @@ function parse(input, options) {
 		return TsParser.extend(gtsPlugin(options)).parse(input, {
 			ecmaVersion: "latest",
 			sourceType: "module",
-			locations: true
+			locations: true,
+			ranges: true
 		});
 	} catch (e) {
 		if (e instanceof SyntaxError && "loc" in e) {
@@ -557,6 +553,7 @@ function parseLoose(input, options) {
 			ecmaVersion: "latest",
 			sourceType: "module",
 			locations: true,
+			ranges: true,
 			onComment
 		});
 		addComments(ast);
@@ -744,7 +741,8 @@ const commonGtsVisitor = {
 					method: false,
 					shorthand: false,
 					value: state.ActionLit,
-					loc: node.loc
+					loc: node.loc,
+					range: node.range
 				},
 				{
 					type: "Property",
@@ -790,7 +788,8 @@ const commonGtsVisitor = {
 					}
 				}
 			],
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		};
 	},
 	GTSShortcutFunctionExpression(node, { visit, state }) {
@@ -799,7 +798,8 @@ const commonGtsVisitor = {
 			params: state.shortcutFunctionParameters,
 			body: visit(node.body),
 			expression: node.expression,
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		};
 	},
 	GTSShortcutArgumentExpression(node, { state, visit }) {
@@ -809,50 +809,29 @@ const commonGtsVisitor = {
 			computed: false,
 			optional: false,
 			property: visit(node.property),
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		};
 	},
 	GTSQueryExpression(node, { state, visit }) {
-		state.hasQueryExpressions = true;
 		return {
 			...node,
 			type: "CallExpression",
 			optional: false,
-			callee: state.queryFnId,
+			callee: {
+				type: "MemberExpression",
+				object: state.fnArgId,
+				property: node.star ? state.QueryAllLit : state.QueryLit,
+				computed: true,
+				optional: false
+			},
 			arguments: [{
 				type: "ArrowFunctionExpression",
 				body: visit(node.argument),
 				params: state.queryParameters,
 				expression: true,
-				loc: node.argument.loc
-			}, {
-				type: "ObjectExpression",
-				properties: [{
-					type: "Property",
-					key: {
-						type: "Identifier",
-						name: "star"
-					},
-					computed: false,
-					kind: "init",
-					method: false,
-					shorthand: false,
-					value: {
-						type: "Literal",
-						value: !!node.star
-					}
-				}, {
-					type: "Property",
-					key: {
-						type: "Identifier",
-						name: "context"
-					},
-					computed: false,
-					kind: "init",
-					method: false,
-					shorthand: false,
-					value: state.fnArgId
-				}]
+				loc: node.argument.loc,
+				range: node.argument.range
 			}]
 		};
 	}
@@ -866,18 +845,6 @@ const gtsVisitor = {
 		}
 		body.unshift(...state.bindingStatements);
 		state.bindingStatements = [];
-		if (state.hasQueryExpressions) body.unshift({
-			type: "ImportDeclaration",
-			specifiers: [{
-				type: "ImportDefaultSpecifier",
-				local: state.queryFnId
-			}],
-			source: {
-				type: "Literal",
-				value: `${state.providerImportSource}/query`
-			},
-			attributes: []
-		});
 		body.unshift({
 			type: "ImportDeclaration",
 			specifiers: [{
@@ -938,7 +905,8 @@ const gtsVisitor = {
 				id: nodeVarId,
 				init: rootAttr
 			}],
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		});
 		state.bindingStatements.push({
 			type: "VariableDeclaration",
@@ -953,7 +921,8 @@ const gtsVisitor = {
 					arguments: [state.rootVmId, nodeVarId]
 				}
 			}],
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		});
 		for (let i = 0; i < newBindings.length; i++) {
 			const binding = newBindings[i];
@@ -991,7 +960,8 @@ const gtsVisitor = {
 				callee: state.createDefineFnId,
 				arguments: [state.rootVmId, nodeVarId]
 			},
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		};
 	},
 	GTSNamedAttributeDefinition(node, { visit, state }) {
@@ -1013,7 +983,8 @@ const gtsVisitor = {
 			method: false,
 			shorthand: false,
 			value: nameValue,
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		});
 		const body = {
 			...namedBody,
@@ -1067,9 +1038,11 @@ const gtsVisitor = {
 					params: [],
 					body: positionals,
 					expression: true,
-					loc: positionals.loc
+					loc: positionals.loc,
+					range: positionals.range
 				},
-				loc: positionals.loc
+				loc: positionals.loc,
+				range: positionals.range
 			}, {
 				type: "Property",
 				key: {
@@ -1081,9 +1054,11 @@ const gtsVisitor = {
 				method: false,
 				shorthand: false,
 				value: named,
-				loc: named.loc
+				loc: named.loc,
+				range: named.range
 			}],
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		};
 	},
 	GTSPositionalAttributeList(node, { visit }) {
@@ -1097,7 +1072,8 @@ const gtsVisitor = {
 				};
 				else return visit(attr);
 			}),
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		};
 	},
 	GTSNamedAttributeBlock(node, { visit }) {
@@ -1120,7 +1096,8 @@ const gtsVisitor = {
 					elements: attributes
 				}
 			}],
-			loc: node.loc
+			loc: node.loc,
+			range: node.range
 		};
 	},
 	...commonGtsVisitor
@@ -1183,10 +1160,6 @@ const initialTranspileState = (option = {}) => {
 			type: "Identifier",
 			name: "__gts_rootVm"
 		},
-		queryFnId: {
-			type: "Identifier",
-			name: "__gts_query"
-		},
 		queryParameters: [{
 			type: "ObjectPattern",
 			properties: queryBindings.map((name) => ({
@@ -1205,28 +1178,17 @@ const initialTranspileState = (option = {}) => {
 				shorthand: true
 			}))
 		}],
+		QueryLit: {
+			type: "Literal",
+			value: "~query"
+		},
+		QueryAllLit: {
+			type: "Literal",
+			value: "~queryAll"
+		},
 		runtimeImportSource: option.runtimeImportSource ?? "@gi-tcg/gts-runtime",
 		providerImportSource: option.providerImportSource ?? "@gi-tcg/core/gts",
-		queryArg: {
-			type: "ObjectPattern",
-			properties: (option.queryBindings ?? []).map((name) => ({
-				type: "Property",
-				key: {
-					type: "Identifier",
-					name
-				},
-				computed: false,
-				kind: "init",
-				method: false,
-				shorthand: true,
-				value: {
-					type: "Identifier",
-					name
-				}
-			}))
-		},
 		externalizedBindings: [],
-		hasQueryExpressions: false,
 		defineIdCounter: 0,
 		bindingStatements: []
 	};
@@ -1255,25 +1217,26 @@ const createReplacementHolder = (state, value) => {
 		}
 	};
 };
-function applyReplacements(state, code) {
-	const replacementRegex = new RegExp("\\b" + state.replacementTag.name + "`(.*?)`", "gm");
+function applyReplacements(state, code, mappings) {
+	const replacementRegex = new RegExp("\\b" + state.replacementTag.name + "`(.*?)(?<!\\\\)`", "gm");
 	const { NamedDefinitionLit, MetaLit } = state;
 	const NamedDefinition = JSON.stringify(NamedDefinitionLit.value);
 	const Meta = JSON.stringify(MetaLit.value);
-	const oneLine = (strings, ...values) => strings.reduce((result, chunk, index) => result + chunk + (index < values.length ? values[index] : ""), "").replace(/\n[ \t]*/g, " ").trim();
-	return code.replace(replacementRegex, (_, rawPayload) => {
-		const payload = JSON.parse(rawPayload);
-		if (payload.type === "preface") return oneLine`
+	const matchInfos = [];
+	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") return oneLine`
+		else if (payload.type === "enterVMFromRoot") replacement = dedent`
         type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition}];
         type ${payload.metaType} = ${payload.defType}[${Meta}];
       `;
-		else if (payload.type === "enterVMFromAttr") return oneLine`
+		else if (payload.type === "enterVMFromAttr") replacement = dedent`
         type ${payload.defType} = ${payload.returnType} extends { namedDefinition: infer Def } ? Def : { ${Meta}: unknown };
         type ${payload.metaType} = ${payload.defType}[${Meta}];
       `;
@@ -1282,8 +1245,12 @@ function applyReplacements(state, code) {
 			const requiredAttrsNs = `${payload.finalMetaType}_rans`;
 			const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ")}`;
 			const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
-			if (payload.errorLoc) state.extraMappings.set(payload.errorLoc, needleString);
-			return oneLine`
+			if (payload.errorRange) state.extraMappings.push({
+				sourceOffset: payload.errorRange[0],
+				length: payload.errorRange[1] - payload.errorRange[0],
+				generatedNeedle: needleString
+			});
+			replacement = dedent`
         type ${payload.finalMetaType} = ${payload.metaType};
         let ${lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${Meta}>;
         type ${lhs} = typeof ${lhs};
@@ -1299,10 +1266,11 @@ function applyReplacements(state, code) {
 			const uniqueKeyForThis = `${payload.lhs}_uniqueKeyFor_${payload.lhs}`;
 			const uniqueKeyHelperIntf = `${payload.defType}_uniqueKeyProbeHelper`;
 			const omittedKeys = `${payload.lhs}_omittedKeys`;
-			return oneLine`
+			replacement = dedent`
         type ${uniqueKeyLhs} = {
           ${Meta}: ${payload.metaType}; 
           uniqueKey: ${payload.defType} extends { [${payload.attrName}]: { uniqueKey: infer UniqueKey } } ? UniqueKey : () => 0;
+        };
         
         let ${uniqueKeyLhs}!: ${uniqueKeyLhs};
         let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
@@ -1326,7 +1294,7 @@ function applyReplacements(state, code) {
       `;
 		} else if (payload.type === "createBindingTyping") {
 			const typingIdLhs = `${payload.typingId}_lhs`;
-			return oneLine`
+			replacement = dedent`
         type ${typingIdLhs} = {
           ${Meta}: ${payload.finalMetaType};
           as: ${payload.defType} extends { [${payload.attrName}]: { as: infer As } } ? As : unknown;
@@ -1335,24 +1303,28 @@ function applyReplacements(state, code) {
         let ${payload.typingId} = ${typingIdLhs}.as();
         type ${payload.typingId} = typeof ${payload.typingId};
       `;
-		} else if (payload.type === "exitAttr") return oneLine`
+		} else if (payload.type === "exitAttr") replacement = dedent`
         type ${payload.returnType} = typeof ${payload.returnType};
         type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}
       `;
-		else return "";
+		else replacement = "";
+		matchInfos.push({
+			sourceEnd: offset + match.length,
+			lengthOffset: replacement.length - match.length
+		});
+		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;
+	}
+	return result;
 }
 //#endregion
 //#region src/transform/volar/walker.ts
 const EMPTY = { type: "EmptyStatement" };
-const ANY_INIT = {
-	type: "TSAsExpression",
-	expression: {
-		type: "Literal",
-		value: 0
-	},
-	typeAnnotation: { type: "TSAnyKeyword" }
-};
 const enterVMFromRoot = (state) => {
 	let defTypeId = {
 		type: "Identifier",
@@ -1401,7 +1373,7 @@ const enterVMFromAttr = (state, returningId) => {
 	state.finalMetaTypeIdStack.push(finalMetaTypeId);
 	state.attrsOfCurrentVm.push([]);
 };
-const exitVM = (state, errorLoc) => {
+const exitVM = (state, errorRange) => {
 	const currentDefTypeId = state.vmDefTypeIdStack.pop();
 	const currentMetaId = state.metaTypeIdStack.pop();
 	const finalMetaId = state.finalMetaTypeIdStack.pop();
@@ -1412,7 +1384,7 @@ const exitVM = (state, errorLoc) => {
 		defType: currentDefTypeId.name,
 		finalMetaType: finalMetaId.name,
 		collectedAttrs: collectedAttrNames,
-		errorLoc
+		errorRange
 	}));
 };
 const enterAttr = (state, attrName) => {
@@ -1420,7 +1392,7 @@ const enterAttr = (state, attrName) => {
 	const metaTypeId = state.metaTypeIdStack.at(-1);
 	if (!defTypeId || !metaTypeId) return { lhsId: {
 		type: "Identifier",
-		name: "__invalid_attr_obj"
+		name: "__gts_invalid_attr_obj"
 	} };
 	state.attrsOfCurrentVm.at(-1).push(attrName);
 	const lhsId = {
@@ -1480,13 +1452,19 @@ const gtsToTypingsWalker = {
 				declarations: [{
 					type: "VariableDeclarator",
 					id: extBinding.bindingName,
-					init: ANY_INIT,
 					typeAnnotation: {
 						type: "TSTypeAnnotation",
 						typeAnnotation: {
 							type: "TSTypeReference",
 							typeName: extBinding.typingId
 						}
+					},
+					init: {
+						type: "TSNonNullExpression",
+						expression: {
+							type: "Literal",
+							value: null
+						}
 					}
 				}]
 			};
@@ -1503,32 +1481,61 @@ const gtsToTypingsWalker = {
 				body.unshift(varDecl);
 			}
 		}
-		if (state.hasQueryExpressions) body.unshift({
+		const importDecls = [];
+		importDecls.push({
 			type: "ImportDeclaration",
-			diagnosticsOnTop: true,
 			specifiers: [{
 				type: "ImportDefaultSpecifier",
-				local: state.queryFnId
+				local: state.rootVmId
 			}],
 			source: {
 				type: "Literal",
-				value: `${state.providerImportSource}/query`
+				value: `${state.providerImportSource}/vm`
 			},
 			attributes: []
-		});
-		body.unshift({
+		}, {
 			type: "ImportDeclaration",
-			diagnosticsOnTop: true,
 			specifiers: [{
-				type: "ImportDefaultSpecifier",
-				local: state.rootVmId
+				type: "ImportSpecifier",
+				imported: {
+					type: "Identifier",
+					name: "createDefine"
+				},
+				local: state.createDefineFnId
+			}, {
+				type: "ImportSpecifier",
+				imported: {
+					type: "Identifier",
+					name: "createBinding"
+				},
+				local: state.createBindingFnId
 			}],
 			source: {
 				type: "Literal",
-				value: `${state.providerImportSource}/vm`
+				value: state.runtimeImportSource
+			},
+			attributes: []
+		});
+		for (const importDecl of importDecls) {
+			state.diagnosticsOnTopNodes.add(importDecl.source);
+			for (const specifier of importDecl.specifiers) state.diagnosticsOnTopNodes.add(specifier);
+		}
+		const lastImportDecl = importDecls.pop() ?? {
+			type: "ImportDeclaration",
+			specifiers: [],
+			source: {
+				type: "Literal",
+				value: ""
 			},
 			attributes: []
-		}, createReplacementHolder(state, { type: "preface" }));
+		};
+		body.unshift(...importDecls, {
+			type: "ExpressionStatement",
+			expression: {
+				type: "Literal",
+				value: 0
+			}
+		}, lastImportDecl, createReplacementHolder(state, { type: "preface" }));
 		return {
 			...node,
 			body
@@ -1543,28 +1550,41 @@ const gtsToTypingsWalker = {
 	GTSNamedAttributeDefinition(node, { visit, state }) {
 		const { name, body, bindingName } = node;
 		const attrName = JSON.stringify(name.type === "Literal" ? String(name.value) : name.name);
-		const attributeNameToken = state.leafTokens.find((t) => t.loc === name.loc);
-		if (attributeNameToken) attributeNameToken.sourceLengthOffset = 1;
 		const { lhsId } = enterAttr(state, attrName);
-		state.extraMappings.set(`${name.loc?.start.line}:${name.loc?.start.column}`, `${lhsId.name}${name.type === "Literal" ? `[` : `.`}`);
 		const positionals = body.positionalAttributes.attributes.map((attr) => {
 			if (attr.type === "Identifier" && /^[a-z_]/.test(attr.name)) {
-				const token = state.leafTokens.find((t) => t.loc === attr.loc);
-				if (token) {
-					token.generatedStartOffset = 1;
-					token.generatedLength = attr.name.length + 2;
-				}
-				return {
+				const lit = {
 					type: "Literal",
 					value: attr.name,
-					loc: attr.loc
+					loc: attr.loc,
+					range: attr.range
 				};
-			} else return visit(attr);
+				state.literalFromIdentifier.add(lit);
+				return lit;
+			} else return { ...visit(attr) };
 		});
 		const returnValue = {
 			type: "Identifier",
 			name: `__gts_attrRet_${state.idCounter++}`
 		};
+		const callee = {
+			type: "MemberExpression",
+			object: lhsId,
+			property: name,
+			computed: name.type === "Literal",
+			optional: false
+		};
+		if (name.range) {
+			state.extraMappings.push({
+				sourceOffset: name.range[0],
+				length: name.range[1] - name.range[0],
+				generatedNeedle: `${lhsId.name}${name.type === "Literal" ? `[` : `.`}`
+			});
+			state.namedAttributeCalleeLParenRange.set(callee, {
+				start: name.range[1],
+				end: name.range[1] + 1
+			});
+		}
 		state.typingPendingStatements.push({
 			type: "VariableDeclaration",
 			kind: "const",
@@ -1574,13 +1594,7 @@ const gtsToTypingsWalker = {
 				init: {
 					type: "CallExpression",
 					optional: false,
-					callee: {
-						type: "MemberExpression",
-						object: lhsId,
-						property: name,
-						computed: name.type === "Literal",
-						optional: false
-					},
+					callee,
 					arguments: positionals
 				}
 			}]
@@ -1588,13 +1602,13 @@ const gtsToTypingsWalker = {
 		if (body.namedAttributes) {
 			enterVMFromAttr(state, returnValue);
 			visit(body.namedAttributes);
-			exitVM(state, `${body.namedAttributes.loc?.start.line}:${body.namedAttributes.loc?.start.column}`);
+			exitVM(state, body.namedAttributes.range);
 		}
 		if (bindingName) {
 			const export_ = node.bindingAccessModifier !== "private";
 			const typingId = {
 				type: "Identifier",
-				name: `gts_binding_type_${state.externalizedBindings.length}`
+				name: `__gts_binding_type_${state.externalizedBindings.length}`
 			};
 			genBindingTyping(state, {
 				attrName,
@@ -1625,8 +1639,11 @@ const gtsToTypingsWalker = {
 			const attrName = JSON.stringify(state.ActionLit.value);
 			const { lhsId } = enterAttr(state, attrName);
 			const actionNotExistsReplacementStr = `${lhsId.name}[${attrName}]`;
-			const actionNotExistsErrorLoc = `${node.directAction.loc?.start.line}:${node.directAction.loc?.start.column}`;
-			state.extraMappings.set(actionNotExistsErrorLoc, actionNotExistsReplacementStr);
+			if (node.directAction.range) state.extraMappings.push({
+				sourceOffset: node.directAction.range[0],
+				length: node.directAction.range[1] - node.directAction.range[0],
+				generatedNeedle: actionNotExistsReplacementStr
+			});
 			const fn = {
 				type: "ArrowFunctionExpression",
 				params: state.shortcutFunctionParameters,
@@ -1663,16 +1680,7 @@ const gtsToTypingsWalker = {
 		}
 		return EMPTY;
 	},
-	...commonGtsVisitor,
-	GTSShortcutArgumentExpression(node, { state, visit }) {
-		return {
-			type: "MemberExpression",
-			object: { ...state.fnArgId },
-			computed: false,
-			optional: false,
-			property: visit(node.property)
-		};
-	}
+	...commonGtsVisitor
 };
 //#endregion
 //#region src/transform/volar/mappings.ts
@@ -1684,291 +1692,151 @@ const DEFAULT_VOLAR_MAPPING_DATA = {
 	structure: true,
 	verification: true
 };
-/**
-* Build a source-to-generated position lookup map from an esrap source map
-* Applies post-processing adjustments during map building for efficiency
-* @param source_map - The source map object from esrap (v3 format)
-* @param line_offsets - Pre-computed line offsets array
-* @param generated_code - The final generated code (after post-processing)
-* @returns source-to-generated map
-*/
-function buildSrcToGenMap(source_map, line_offsets, generated_code) {
-	const map = /* @__PURE__ */ new Map();
-	const decoded = decode(source_map.mappings);
-	/**
-	* Convert line/column position to byte offset
-	* @param {number} line - 1-based line number
-	* @param {number} column - 0-based column number
-	* @returns {number} Byte offset
-	*/
-	const line_col_to_byte_offset = (line, column) => {
-		return line_offsets[line - 1] + column;
-	};
-	const adjusted_segments = [];
-	for (let generated_line = 0; generated_line < decoded.length; generated_line++) {
-		const line = decoded[generated_line];
-		adjusted_segments[generated_line] = [];
-		for (const segment of line) if (segment.length >= 4) {
-			let adjusted_line = generated_line + 1;
-			let adjusted_column = segment[0];
-			adjusted_segments[generated_line].push({
-				line: adjusted_line,
-				column: adjusted_column,
-				sourceLine: segment[2],
-				sourceColumn: segment[3]
-			});
-		}
-	}
-	for (let line_idx = 0; line_idx < adjusted_segments.length; line_idx++) {
-		const line_segments = adjusted_segments[line_idx];
-		for (let seg_idx = 0; seg_idx < line_segments.length; seg_idx++) {
-			const segment = line_segments[seg_idx];
-			const line = segment.line;
-			const column = segment.column;
-			let end_line = line;
-			let end_column = column;
-			if (seg_idx + 1 < line_segments.length) {
-				const next_segment = line_segments[seg_idx + 1];
-				end_line = next_segment.line;
-				end_column = next_segment.column;
-			} else if (line_idx + 1 < adjusted_segments.length && adjusted_segments[line_idx + 1].length > 0) {
-				const next_segment = adjusted_segments[line_idx + 1][0];
-				end_line = next_segment.line;
-				end_column = next_segment.column;
+const VERIFICATION_ONLY_MAPPING_DATA = { verification: true };
+Object.freeze(DEFAULT_VOLAR_MAPPING_DATA);
+Object.freeze(VERIFICATION_ONLY_MAPPING_DATA);
+//#endregion
+//#region src/transform/volar/printer.ts
+function getPrintOptions(source, state) {
+	return {
+		source,
+		isUntouched: (node) => {
+			if (node.type === "Identifier" && node.isDummy) return false;
+			return state.sourceNodes.has(node);
+		},
+		getLeadingComments: (node) => node.leadingComments,
+		getTrailingComments: (node) => node.trailingComments,
+		getMappingData: () => DEFAULT_VOLAR_MAPPING_DATA,
+		printers: {
+			Identifier(node, context) {
+				const identifier = node;
+				if (identifier.isDummy && identifier.range) {
+					const text = state.lastArgNodes.has(identifier) ? "," : "";
+					let firstNonWhiteSpaceIndex = context.source.slice(identifier.range[1]).search(/\S/);
+					const rangeEnd = firstNonWhiteSpaceIndex === -1 ? context.source.length : identifier.range[1] + firstNonWhiteSpaceIndex;
+					context.writeMapped(text, identifier.range[0], rangeEnd);
+				} else return defaultPrinters.Identifier(node, context);
+			},
+			Literal(node, context) {
+				const generatedStart = context.generatedOffset;
+				if (state.literalFromIdentifier.has(node) && node.range) {
+					const text = JSON.stringify(node.value);
+					context.write("\"");
+					context.writeMapped(text.slice(1, -1), node.range[0], node.range[1]);
+					context.write("\"");
+				} else defaultPrinters.Literal(node, context);
+				if (state.diagnosticsOnTopNodes.has(node)) {
+					const generatedEnd = context.generatedOffset;
+					context.createExtraMapping({
+						start: 0,
+						end: 1
+					}, generatedStart, generatedEnd, VERIFICATION_ONLY_MAPPING_DATA);
+				}
+			},
+			ImportDefaultSpecifier(node, context) {
+				const generatedStart = context.generatedOffset;
+				defaultPrinters.ImportDefaultSpecifier(node, context);
+				if (state.diagnosticsOnTopNodes.has(node)) {
+					const generatedEnd = context.generatedOffset;
+					context.createExtraMapping({
+						start: 0,
+						end: 1
+					}, generatedStart, generatedEnd, VERIFICATION_ONLY_MAPPING_DATA);
+				}
+			},
+			ImportSpecifier(node, context) {
+				const generatedStart = context.generatedOffset;
+				defaultPrinters.ImportSpecifier(node, context);
+				if (state.diagnosticsOnTopNodes.has(node)) {
+					const generatedEnd = context.generatedOffset;
+					context.createExtraMapping({
+						start: 0,
+						end: 1
+					}, generatedStart, generatedEnd, VERIFICATION_ONLY_MAPPING_DATA);
+				}
+			},
+			ImportDeclaration(node, context) {
+				defaultPrinters.ImportDeclaration(node, context);
+				if (state.lastImportDeclarationIfGen === node) {
+					context.write("\n");
+					context.createExtraMapping({
+						start: state.contentStartOffset,
+						end: state.contentStartOffset + 1
+					}, context.generatedOffset, context.generatedOffset + 1, DEFAULT_VOLAR_MAPPING_DATA);
+				}
 			}
-			const start_offset = line_col_to_byte_offset(line, column);
-			const end_offset = line_col_to_byte_offset(end_line, end_column);
-			const code_snippet = generated_code.slice(start_offset, end_offset);
-			segment.sourceLine += 1;
-			const key = `${segment.sourceLine}:${segment.sourceColumn}`;
-			const gen_pos = {
-				line,
-				column,
-				end_line,
-				end_column,
-				code: code_snippet,
-				metadata: {}
+		},
+		experimentalGetLeftParenSourceRange: (node) => {
+			const callLike = node;
+			if (callLike.lParenRange) return {
+				start: callLike.lParenRange[0],
+				end: callLike.lParenRange[1]
 			};
-			if (!map.has(key)) map.set(key, []);
-			map.get(key).push(gen_pos);
+			return state.namedAttributeCalleeLParenRange.get(callLike.callee);
 		}
-	}
-	return map;
-}
-/**
-* Look up generated position for a given source position
-* @param src_line - 1-based line number in source
-* @param src_column - 0-based column number in source
-* @param srcToGenMap - Lookup map
-* @returns Generated position
-*/
-function getGeneratedPosition(src_line, src_column, srcToGenMap) {
-	const key = `${src_line}:${src_column}`;
-	return srcToGenMap.get(key) || [];
-}
-function createLineOffsets(content) {
-	const lines = content.split("\n");
-	const offsets = [];
-	let currentOffset = 0;
-	for (const line of lines) {
-		offsets.push(currentOffset);
-		currentOffset += line.length + 1;
-	}
-	return offsets;
+	};
 }
+//#endregion
+//#region src/transform/volar/content_start.ts
 /**
-* Convert line/column to byte offset
-* @param line
-* @param column
-* @param line_offsets
-* @returns
+* Get the character offset after hashbang and file-scope leading comments.
+* This is for simulating the behavior of TSServer insert auto-imports if no
+* imports are present.
+* @param source 
+* @returns 
 */
-function locToOffset(line, column, line_offsets) {
-	if (line < 1 || line > line_offsets.length) {}
-	return line_offsets[line - 1] + column;
-}
-function convertToVolarMappings(generated, source, sourceMap, tokens, extraMappings) {
-	const sourceLineOffsets = createLineOffsets(source);
-	const generatedLineOffsets = createLineOffsets(generated);
-	const srcToGenMap = buildSrcToGenMap(sourceMap, generatedLineOffsets, generated);
-	const mappings = [];
-	for (const token of tokens) {
-		let sourceStart = locToOffset(token.loc.start.line, token.loc.start.column, sourceLineOffsets);
-		sourceStart += token.sourceStartOffset ?? 0;
-		const sourceEnd = locToOffset(token.loc.end.line, token.loc.end.column, sourceLineOffsets);
-		let sourceLength = token.sourceLength ?? sourceEnd - sourceStart;
-		sourceLength += token.sourceLengthOffset ?? 0;
-		const [genLineCol] = getGeneratedPosition(token.loc.start.line, token.loc.start.column, srcToGenMap);
-		if (!genLineCol) continue;
-		let genStart = locToOffset(genLineCol.line, genLineCol.column, generatedLineOffsets);
-		if (token.isDummy) while (sourceStart > 0 && /\s/.test(source[sourceStart - 1])) {
-			sourceStart--;
-			sourceLength++;
-		}
-		const generatedLength = token.generatedLength ?? sourceLength;
-		if (typeof token.generatedStartOffset === "number" && token.generatedStartOffset > 0) {
-			mappings.push({
-				sourceOffsets: [sourceStart],
-				generatedOffsets: [genStart],
-				lengths: [0],
-				generatedLengths: [generatedLength],
-				data: { verification: true }
-			});
-			genStart += token.generatedStartOffset;
-		}
-		mappings.push({
-			sourceOffsets: [sourceStart],
-			generatedOffsets: [genStart],
-			lengths: [sourceLength],
-			generatedLengths: [generatedLength],
-			data: DEFAULT_VOLAR_MAPPING_DATA
-		});
-	}
-	const locMapsToTop = getGeneratedPosition(1, 0, srcToGenMap);
-	for (const loc of locMapsToTop) {
-		const offset = locToOffset(loc.line, loc.column, generatedLineOffsets);
-		mappings.push({
-			sourceOffsets: [0],
-			generatedOffsets: [offset],
-			lengths: [0],
-			generatedLengths: [0],
-			data: { verification: true }
-		});
-	}
-	for (const [loc, codeSnippet] of extraMappings) {
-		const generatedStart = generated.indexOf(codeSnippet);
-		if (generatedStart === -1) continue;
-		const [lineStr, columnStr] = loc.split(":");
-		const sourceStart = locToOffset(Number(lineStr), Number(columnStr), sourceLineOffsets);
-		const sourceLength = 1;
-		const generatedLength = codeSnippet.length;
-		mappings.push({
-			sourceOffsets: [sourceStart],
-			generatedOffsets: [generatedStart],
-			lengths: [sourceLength],
-			generatedLengths: [generatedLength],
-			data: { verification: true }
-		});
+function getContentStartOffset(source) {
+	let result = 0;
+	/** Current visiting character */
+	let pos = 0;
+	if (source.startsWith("#!")) {
+		const nl = source.indexOf("\n", pos);
+		if (nl === -1) return source.length;
+		pos = nl + 1;
 	}
-	mappings.sort((a, b) => a.sourceOffsets[0] - b.sourceOffsets[0]);
-	return mappings;
-}
-//#endregion
-//#region src/transform/volar/collect_tokens.ts
-function isLeafNode(node) {
-	for (const key in node) {
-		const val = node[key];
-		if (key === "loc" || key === "start" || key === "end" || key === "range") continue;
-		if (val && typeof val === "object" && typeof val.type === "string") return false;
-		if (Array.isArray(val) && val.length > 0 && typeof val[0].type === "string") return false;
-	}
-	return true;
-}
-function collectLeafTokens(ast) {
-	const state = { tokens: [] };
-	walk(ast, state, {
-		_(node, { state, next }) {
-			if (isLeafNode(node) && node.loc) {
-				const token = { loc: node.loc };
-				if ("isDummy" in node && node.isDummy) {
-					token.isDummy = true;
-					token.sourceLength = 0;
-					token.generatedLength = 1;
-				}
-				state.tokens.push(token);
+	const skipWhitespaces = () => {
+		let newlineCount = 0;
+		for (; pos < source.length; pos++) {
+			const ch = source[pos];
+			if (ch === " " || ch === "	" || ch === "\r") continue;
+			if (ch === "\n") {
+				newlineCount++;
+				continue;
 			}
-			next();
-		},
-		NewExpression(node, { state, next }) {
-			const lParenLoc = node.lParenLoc;
-			if (lParenLoc) state.tokens.push({ loc: lParenLoc });
-			next();
-		},
-		CallExpression(node, { state, next }) {
-			const lParenLoc = node.lParenLoc;
-			if (lParenLoc) state.tokens.push({ loc: lParenLoc });
-			next();
-		}
-	});
-	return state.tokens;
-}
-//#endregion
-//#region src/transform/volar/printer.ts
-const printer = jsPrinter({
-	getLeadingComments: (node) => node.leadingComments,
-	getTrailingComments: (node) => node.trailingComments
-});
-const prevIdentifier = printer.Identifier;
-printer.Identifier = function(node, context) {
-	if (node.isDummy) {
-		const text = Reflect.get(node, "lastArg") ? "," : "";
-		context.write(text, node);
-	} else prevIdentifier(node, context);
-};
-const prevCallNewExpression = printer.CallExpression;
-const newCallNewExpression = function(node, context) {
-	const lastArg = node.arguments.at(-1);
-	if (lastArg) Reflect.set(lastArg, "lastArg", true);
-	if (!node.lParenLoc) return prevCallNewExpression(node, context);
-	let hasDeferredWrite = false;
-	let interceptionDone = false;
-	const lParenFakeNode = { loc: node.lParenLoc };
-	const patchedWrite = (text, node) => {
-		if (text === "(") hasDeferredWrite = true;
-		else context.write(text, node);
-	};
-	const patchedVisit = (node) => {
-		if (hasDeferredWrite) context.write("(");
-		return context.visit(node);
-	};
-	const patchedAppend = (subcontext) => {
-		if (hasDeferredWrite) {
-			context.write("(", lParenFakeNode);
-			interceptionDone = true;
+			break;
 		}
-		return context.append(subcontext);
+		return newlineCount;
 	};
-	return prevCallNewExpression(node, new Proxy(context, { get(target, prop) {
-		if (!interceptionDone) {
-			if (prop === "write") return patchedWrite;
-			if (prop === "visit") return patchedVisit;
-			if (prop === "append") return patchedAppend;
-		}
-		const value = Reflect.get(target, prop);
-		if (typeof value === "function") return value.bind(target);
-		return value;
-	} }));
-};
-printer.CallExpression = newCallNewExpression;
-printer.NewExpression = newCallNewExpression;
-const prevWildcard = printer._;
-printer._ = (node, context, visit) => {
-	const contextProto = Object.getPrototypeOf(context);
-	const prevContextWrite = contextProto.write;
-	if ("diagnosticsOnTop" in node && node.diagnosticsOnTop) contextProto.write = function(text, node) {
-		node ??= {};
-		node.loc ??= {
-			start: {
-				line: 1,
-				column: 0
-			},
-			end: {
-				line: 1,
-				column: 0
+	skipWhitespaces();
+	while (pos < source.length) {
+		let newlineCount = 0;
+		if (source[pos] === "/" && pos + 1 < source.length) {
+			if (source[pos + 1] === "/") {
+				const nl = source.indexOf("\n", pos);
+				pos = nl === -1 ? source.length : nl + 1;
+				newlineCount++;
+			} else if (source[pos + 1] === "*") {
+				pos += 2;
+				while (pos < source.length) {
+					if (source[pos] === "*" && pos + 1 < source.length && source[pos + 1] === "/") {
+						pos += 2;
+						break;
+					}
+					pos++;
+				}
 			}
-		};
-		return prevContextWrite.call(this, text, node);
-	};
-	prevWildcard(node, context, visit);
-	contextProto.write = prevContextWrite;
-};
-const patchedPrinter = printer;
+			result = pos;
+			newlineCount += skipWhitespaces();
+			if (newlineCount >= 2) break;
+		} else break;
+	}
+	return result;
+}
 //#endregion
 //#region src/transform/volar/index.ts
-function gtsToTypings(ast, option) {
+function transformForVolar(ast, option, sourceInfo) {
 	const state = {
 		...initialTranspileState(option),
-		leafTokens: option.leafTokens,
 		idCounter: 0,
 		typingPendingStatements: [],
 		rootVmId: {
@@ -1996,25 +1864,50 @@ function gtsToTypings(ast, option) {
 		metaTypeIdStack: [],
 		finalMetaTypeIdStack: [],
 		attrsOfCurrentVm: [],
-		extraMappings: option.extraMappings
-	};
-	const { code, map } = print(walk(ast, state, gtsToTypingsWalker), patchedPrinter, { indent: "  " });
-	return {
-		code: applyReplacements(state, code),
-		sourceMap: map
+		sourceNodes: /* @__PURE__ */ new WeakSet(),
+		namedAttributeCalleeLParenRange: /* @__PURE__ */ new WeakMap(),
+		literalFromIdentifier: /* @__PURE__ */ new WeakSet(),
+		lastArgNodes: /* @__PURE__ */ new WeakSet(),
+		lastImportDeclarationIfGen: null,
+		diagnosticsOnTopNodes: /* @__PURE__ */ new WeakSet(),
+		extraMappings: [],
+		contentStartOffset: getContentStartOffset(sourceInfo.content)
 	};
-}
-function transformForVolar(ast, option, sourceInfo) {
-	const tokens = collectLeafTokens(ast);
-	const extraMappings = /* @__PURE__ */ new Map();
-	const { code, sourceMap } = gtsToTypings(ast, {
-		...option,
-		leafTokens: tokens,
-		extraMappings
+	walk(ast, state, { _(node, { state, next }) {
+		if (node.range) state.sourceNodes.add(node);
+		next();
+	} });
+	const newAst = walk(ast, state, gtsToTypingsWalker);
+	walk(newAst, state, {
+		CallExpression(node, { state }) {
+			const lastArg = node.arguments.at(-1);
+			if (lastArg) state.lastArgNodes.add(lastArg);
+		},
+		ImportDeclaration(node, { state }) {
+			if (!state.sourceNodes.has(node)) state.lastImportDeclarationIfGen = node;
+		}
 	});
+	let { code, mappings } = print$1(newAst, getPrintOptions(sourceInfo.content, state));
+	code = applyReplacements(state, code, mappings);
+	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],
+			data: VERIFICATION_ONLY_MAPPING_DATA
+		});
+	}
+	walk(newAst, null, { ImportDeclaration(node) {
+		if (!node.range) return;
+		const endOffset = node.range[1];
+		const mappingEndsWithThisImport = mappings.find((m) => m.sourceOffsets[0] + m.lengths[0] === endOffset);
+		if (mappingEndsWithThisImport?.lengths[0]) mappingEndsWithThisImport.lengths[0] += 1;
+	} });
 	return {
 		code,
-		mappings: convertToVolarMappings(code, sourceInfo.content, sourceMap, tokens, extraMappings)
+		mappings
 	};
 }
 //#endregion