@gi-tcg/gts-transpiler 0.3.1 → 0.3.3

package/dist/index.js

@@ -1,1384 +1,1306 @@
-// packages/transpiler/src/parse/index.ts
-import { Parser } from "acorn";
+import { Parser, tokTypes } from "acorn";
 import { tsPlugin } from "@sveltejs/acorn-typescript";
-
-// packages/transpiler/src/parse/gts_plugin.ts
-import { tokTypes as tokTypes2 } from "acorn";
-
-// packages/transpiler/src/keywords.ts
-var specialIdentifiers = [
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "null",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "let",
-  "static",
-  "yield",
-  "await",
-  "enum",
-  "implements",
-  "interface",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "as",
-  "async",
-  "from",
-  "get",
-  "of",
-  "set",
-  "type",
-  "define",
-  "query"
+import { walk } from "zimmerframe";
+import { print } from "esrap";
+import jsPrinter from "esrap/languages/ts";
+import { defaultPrinters, print as print$1 } from "espolar";
+import dedent from "dedent";
+import path from "path-browserify-esm";
+//#region src/keywords.ts
+const specialIdentifiers = [
+	"break",
+	"case",
+	"catch",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"function",
+	"if",
+	"import",
+	"in",
+	"instanceof",
+	"new",
+	"null",
+	"return",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"while",
+	"with",
+	"let",
+	"static",
+	"yield",
+	"await",
+	"enum",
+	"implements",
+	"interface",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"as",
+	"async",
+	"from",
+	"get",
+	"of",
+	"set",
+	"type",
+	"define",
+	"query"
 ];
-
-// packages/transpiler/src/parse/loose_plugin.ts
-import { tokTypes } from "acorn";
-var DUMMY_PLACEHOLDER = "✖";
 function loosePlugin() {
-  return function loosePluginTransformer(parser) {
-    return class LooseParser extends parser {
-      _patchedParseIdent = (liberal) => {
-        if (this.type !== tokTypes.name) {
-          return this.createDummyIdentifier();
-        } else {
-          return super.parseIdent(liberal);
-        }
-      };
-      #proxiedThis = new Proxy(this, {
-        get: (target, prop) => {
-          if (prop === "parseIdent") {
-            return this._patchedParseIdent;
-          }
-          const value = Reflect.get(target, prop);
-          if (typeof value === "function") {
-            return value.bind(target);
-          }
-          return value;
-        }
-      });
-      createDummyIdentifier() {
-        const dummy = this.startNode();
-        dummy.name = DUMMY_PLACEHOLDER;
-        dummy.isDummy = true;
-        return this.finishNode(dummy, "Identifier");
-      }
-      parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
-        return super.parseSubscript.call(this.#proxiedThis, base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
-      }
-    };
-  };
+	return function loosePluginTransformer(parser) {
+		return class LooseParser extends parser {
+			_patchedParseIdent = (liberal) => {
+				if (this.type !== tokTypes.name) return this.createDummyIdentifier();
+				else return super.parseIdent(liberal);
+			};
+			#proxiedThis = new Proxy(this, { get: (target, prop) => {
+				if (prop === "parseIdent") return this._patchedParseIdent;
+				const value = Reflect.get(target, prop);
+				if (typeof value === "function") return value.bind(target);
+				return value;
+			} });
+			createDummyIdentifier() {
+				const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+				dummy.name = "✖";
+				dummy.isDummy = true;
+				return this.finishNode(dummy, "Identifier");
+			}
+			parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
+				return super.parseSubscript.call(this.#proxiedThis, base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+			}
+		};
+	};
 }
-
-// packages/transpiler/src/parse/gts_plugin.ts
+//#endregion
+//#region src/parse/gts_plugin.ts
 function gtsPlugin(options = {}) {
-  return function gtsPluginTransformer(Parser) {
-    const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
-    const lineBreak = /\r\n?|\n|\u2028|\u2029/;
-    const acornScope = {
-      SCOPE_TOP: 1,
-      SCOPE_FUNCTION: 2,
-      SCOPE_ASYNC: 4,
-      SCOPE_GENERATOR: 8,
-      SCOPE_ARROW: 16
-    };
-    return class GtsParser extends Parser {
-      gtsOptions = options;
-      isShortcutContext = false;
-      parseStatement(context, topLevel, exports) {
-        if (topLevel && this.gts_isDefineStatement()) {
-          const node = this.startNode();
-          this.next();
-          node.body = this.gts_parseNamedAttributeDefinition();
-          return this.finishNode(node, "GTSDefineStatement");
-        }
-        return super.parseStatement(context, topLevel, exports);
-      }
-      gts_isDefineStatement() {
-        if (!this.isContextual("define")) {
-          return false;
-        }
-        skipWhiteSpace.lastIndex = this.pos;
-        const skip = skipWhiteSpace.exec(this.input);
-        const next = this.pos + skip[0].length;
-        return !lineBreak.test(this.input.slice(this.pos, next));
-      }
-      gts_parseNamedAttributeDefinition() {
-        const node = this.startNode();
-        const start = this.start;
-        let name;
-        if (this.type.label === "string") {
-          name = this.parseExprAtom();
-          if (typeof name.value === "string" && name.value.startsWith("~")) {
-            this.raise(start, `Attribute name starts with '~' is reserved for internal use.`);
-          }
-        } else if (this.type.label === "name") {
-          name = this.parseIdent();
-        } else {
-          this.raise(start, "Expected attribute name");
-        }
-        node.name = name;
-        node.body = this.gts_parseAttributeBody();
-        if (this.eatContextual("as")) {
-          if (this.eatContextual("public")) {
-            node.bindingAccessModifier = "public";
-          } else if (this.eatContextual("protected")) {
-            node.bindingAccessModifier = "protected";
-          } else if (this.eatContextual("private")) {
-            node.bindingAccessModifier = "private";
-          }
-          node.bindingName = this.parseIdent();
-        }
-        this.semicolon();
-        return this.finishNode(node, "GTSNamedAttributeDefinition");
-      }
-      gts_parseAttributeBody() {
-        const node = this.startNode();
-        node.positionalAttributes = this.gts_parsePositionalAttributeList();
-        if (this.type === tokTypes2.braceL) {
-          node.namedAttributes = this.gts_parseNamedAttributeBlock();
-        }
-        return this.finishNode(node, "GTSAttributeBody");
-      }
-      gts_parsePositionalAttributeList() {
-        const node = this.startNode();
-        node.attributes = [];
-        let first = true;
-        while (true) {
-          if (this.type === tokTypes2.braceL) {
-            break;
-          }
-          if (this.type === tokTypes2.semi || this.canInsertSemicolon()) {
-            break;
-          }
-          if (this.isContextual("as")) {
-            break;
-          }
-          if (!first) {
-            this.expect(tokTypes2.comma);
-          } else {
-            first = false;
-          }
-          node.attributes.push(this.gts_parseAttributeExpression());
-        }
-        return this.finishNode(node, "GTSPositionalAttributeList");
-      }
-      gts_parseNamedAttributeBlock() {
-        const node = this.startNode();
-        node.attributes = [];
-        this.expect(tokTypes2.braceL);
-        while (this.type !== tokTypes2.braceR && this.type !== tokTypes2.eof) {
-          if (specialIdentifiers.includes(this.value) || this.type === tokTypes2.colon) {
-            node.directAction = this.gts_parseDirectFunction();
-            break;
-          }
-          node.attributes.push(this.gts_parseNamedAttributeDefinition());
-        }
-        this.expect(tokTypes2.braceR);
-        return this.finishNode(node, "GTSNamedAttributeBlock");
-      }
-      gts_parseDirectFunction() {
-        const node = this.startNode();
-        node.body = [];
-        this.enterScope(acornScope.SCOPE_FUNCTION | acornScope.SCOPE_ARROW);
-        const oldShortcutContext = this.isShortcutContext;
-        this.isShortcutContext = true;
-        while (this.type !== tokTypes2.braceR && this.type !== tokTypes2.eof) {
-          const startPos = this.pos;
-          const stmt = this.parseStatement(null);
-          if (stmt.type === "GTSDefineStatement") {
-            this.raise(startPos, "DefineStatement is not allowed in direct function.");
-          }
-          node.body.push(stmt);
-        }
-        this.exitScope();
-        this.isShortcutContext = oldShortcutContext;
-        return this.finishNode(node, "GTSDirectFunction");
-      }
-      gts_parseAttributeExpression() {
-        if (this.type === tokTypes2.braceL) {
-          this.raise(this.start, "Expected attribute expression, got '{'.");
-        }
-        if (this.type === tokTypes2.colon) {
-          this.next();
-          return this.gts_parseShortcutFunction();
-        }
-        if (this.gtsOptions.allowEmptyPositionalAttribute && (this.type === tokTypes2.comma || this.type === tokTypes2.braceR || this.type === tokTypes2.semi || this.canInsertSemicolon() || this.isContextual("as"))) {
-          const dummy = this.startNode();
-          dummy.name = DUMMY_PLACEHOLDER;
-          dummy.isDummy = true;
-          return this.finishNode(dummy, "Identifier");
-        }
-        return this.parseExprAtom();
-      }
-      gts_parseShortcutFunction() {
-        const node = this.startNode();
-        this.enterScope(acornScope.SCOPE_FUNCTION | acornScope.SCOPE_ARROW);
-        const oldShortcutContext = this.isShortcutContext;
-        this.isShortcutContext = true;
-        if (this.type === tokTypes2.parenL) {
-          this.next();
-          node.expression = true;
-          node.body = this.parseExpression();
-          this.expect(tokTypes2.parenR);
-        } else if (this.type === tokTypes2.braceL) {
-          node.expression = false;
-          node.body = this.parseBlock();
-        }
-        this.exitScope();
-        this.isShortcutContext = oldShortcutContext;
-        return this.finishNode(node, "GTSShortcutFunctionExpression");
-      }
-      parseExprAtom(refDestructuringErrors, forInit, forNew) {
-        if (this.type === tokTypes2.colon) {
-          if (!this.isShortcutContext) {
-            this.raise(this.start, "ShortcutArgumentExpression ':' must be inside ShortcutFunction or DirectShortcutFunction.");
-          }
-          const node = this.startNode();
-          this.next();
-          if (this.gtsOptions.allowEmptyShortcutMember && this.type !== tokTypes2.name) {
-            const dummy = this.startNode();
-            dummy.name = DUMMY_PLACEHOLDER;
-            dummy.isDummy = true;
-            node.property = this.finishNode(dummy, "Identifier");
-          } else {
-            node.property = this.parseIdent();
-          }
-          return this.finishNode(node, "GTSShortcutArgumentExpression");
-        }
-        return super.parseExprAtom(refDestructuringErrors, forInit, forNew);
-      }
-      parseMaybeUnary(refDestructuringErrors, sawUnary, incDec, forInit) {
-        if (this.isShortcutContext && this.isContextual("query")) {
-          const expr = this.gts_parseQueryExpression();
-          if (!incDec && this.eat(tokTypes2.starstar)) {
-            this.unexpected(this.lastTokStart);
-          }
-          return expr;
-        }
-        return super.parseMaybeUnary(refDestructuringErrors, sawUnary, incDec, forInit);
-      }
-      gts_parseQueryExpression(forInit) {
-        const node = this.startNode();
-        this.next();
-        if (this.eat(tokTypes2.star)) {
-          node.star = true;
-        }
-        node.argument = this.parseMaybeUnary(null, true, false, forInit);
-        return this.finishNode(node, "GTSQueryExpression");
-      }
-    };
-  };
+	return function gtsPluginTransformer(Parser) {
+		const skipWhiteSpace = /(?:\s|\/\/.*|\/\*[^]*?\*\/)*/g;
+		const lineBreak = /\r\n?|\n|\u2028|\u2029/;
+		const acornScope = {
+			SCOPE_TOP: 1,
+			SCOPE_FUNCTION: 2,
+			SCOPE_ASYNC: 4,
+			SCOPE_GENERATOR: 8,
+			SCOPE_ARROW: 16
+		};
+		return class GtsParser extends Parser {
+			gtsOptions = options;
+			isShortcutContext = false;
+			parseStatement(context, topLevel, exports) {
+				if (topLevel && this.gts_isDefineStatement()) {
+					const node = this.startNode();
+					this.next();
+					node.body = this.gts_parseNamedAttributeDefinition();
+					return this.finishNode(node, "GTSDefineStatement");
+				}
+				return super.parseStatement(context, topLevel, exports);
+			}
+			gts_isDefineStatement() {
+				if (!this.isContextual("define")) return false;
+				skipWhiteSpace.lastIndex = this.pos;
+				const skip = skipWhiteSpace.exec(this.input);
+				const next = this.pos + skip[0].length;
+				return !lineBreak.test(this.input.slice(this.pos, next));
+			}
+			gts_parseNamedAttributeDefinition() {
+				const node = this.startNode();
+				const start = this.start;
+				let name;
+				if (this.type.label === "string") {
+					name = this.parseExprAtom();
+					if (typeof name.value === "string" && name.value.startsWith("~")) this.raise(start, `Attribute name starts with '~' is reserved for internal use.`);
+				} else if (this.type.label === "name") name = this.parseIdent();
+				else this.raise(start, "Expected attribute name");
+				node.name = name;
+				node.body = this.gts_parseAttributeBody();
+				if (this.eatContextual("as")) {
+					if (this.eatContextual("public")) node.bindingAccessModifier = "public";
+					else if (this.eatContextual("protected")) node.bindingAccessModifier = "protected";
+					else if (this.eatContextual("private")) node.bindingAccessModifier = "private";
+					node.bindingName = this.parseIdent();
+				}
+				this.semicolon();
+				return this.finishNode(node, "GTSNamedAttributeDefinition");
+			}
+			gts_parseAttributeBody() {
+				const node = this.startNode();
+				node.positionalAttributes = this.gts_parsePositionalAttributeList();
+				if (this.type === tokTypes.braceL) node.namedAttributes = this.gts_parseNamedAttributeBlock();
+				return this.finishNode(node, "GTSAttributeBody");
+			}
+			gts_parsePositionalAttributeList() {
+				const node = this.startNode();
+				node.attributes = [];
+				let first = true;
+				while (true) {
+					if (this.type === tokTypes.braceL) break;
+					if (this.type === tokTypes.semi || this.canInsertSemicolon()) break;
+					if (this.isContextual("as")) break;
+					if (!first) this.expect(tokTypes.comma);
+					else first = false;
+					node.attributes.push(this.gts_parseAttributeExpression());
+				}
+				return this.finishNode(node, "GTSPositionalAttributeList");
+			}
+			gts_parseNamedAttributeBlock() {
+				const node = this.startNode();
+				node.attributes = [];
+				this.expect(tokTypes.braceL);
+				while (this.type !== tokTypes.braceR && this.type !== tokTypes.eof) {
+					if (specialIdentifiers.includes(this.value) || this.type === tokTypes.colon) {
+						node.directAction = this.gts_parseDirectFunction();
+						break;
+					}
+					node.attributes.push(this.gts_parseNamedAttributeDefinition());
+				}
+				this.expect(tokTypes.braceR);
+				return this.finishNode(node, "GTSNamedAttributeBlock");
+			}
+			gts_parseDirectFunction() {
+				const node = this.startNode();
+				node.body = [];
+				this.enterScope(acornScope.SCOPE_FUNCTION | acornScope.SCOPE_ARROW);
+				const oldShortcutContext = this.isShortcutContext;
+				this.isShortcutContext = true;
+				while (this.type !== tokTypes.braceR && this.type !== tokTypes.eof) {
+					const startPos = this.pos;
+					const stmt = this.parseStatement(null);
+					if (stmt.type === "GTSDefineStatement") this.raise(startPos, "DefineStatement is not allowed in direct function.");
+					node.body.push(stmt);
+				}
+				this.exitScope();
+				this.isShortcutContext = oldShortcutContext;
+				return this.finishNode(node, "GTSDirectFunction");
+			}
+			gts_parseAttributeExpression() {
+				if (this.type === tokTypes.braceL) this.raise(this.start, "Expected attribute expression, got '{'.");
+				if (this.type === tokTypes.colon) {
+					this.next();
+					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.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+					dummy.name = "✖";
+					dummy.isDummy = true;
+					return this.finishNode(dummy, "Identifier");
+				}
+				return this.parseExprAtom();
+			}
+			gts_parseShortcutFunction() {
+				const node = this.startNode();
+				this.enterScope(acornScope.SCOPE_FUNCTION | acornScope.SCOPE_ARROW);
+				const oldShortcutContext = this.isShortcutContext;
+				this.isShortcutContext = true;
+				if (this.type === tokTypes.parenL) {
+					this.next();
+					node.expression = true;
+					node.body = this.parseExpression();
+					this.expect(tokTypes.parenR);
+				} else if (this.type === tokTypes.braceL) {
+					node.expression = false;
+					node.body = this.parseBlock();
+				}
+				this.exitScope();
+				this.isShortcutContext = oldShortcutContext;
+				return this.finishNode(node, "GTSShortcutFunctionExpression");
+			}
+			parseExprAtom(refDestructuringErrors, forInit, forNew) {
+				if (this.type === tokTypes.colon) {
+					if (!this.isShortcutContext) this.raise(this.start, "ShortcutArgumentExpression ':' must be inside ShortcutFunction or DirectShortcutFunction.");
+					const node = this.startNode();
+					this.next();
+					if (this.gtsOptions.allowEmptyShortcutMember && this.type !== tokTypes.name) {
+						const dummy = this.startNodeAt(this.lastTokEnd, this.lastTokEndLoc);
+						dummy.name = "✖";
+						dummy.isDummy = true;
+						node.property = this.finishNode(dummy, "Identifier");
+					} else node.property = this.parseIdent();
+					return this.finishNode(node, "GTSShortcutArgumentExpression");
+				}
+				return super.parseExprAtom(refDestructuringErrors, forInit, forNew);
+			}
+			parseMaybeUnary(refDestructuringErrors, sawUnary, incDec, forInit) {
+				if (this.isShortcutContext && this.isContextual("query")) {
+					const expr = this.gts_parseQueryExpression();
+					if (!incDec && this.eat(tokTypes.starstar)) this.unexpected(this.lastTokStart);
+					return expr;
+				}
+				return super.parseMaybeUnary(refDestructuringErrors, sawUnary, incDec, forInit);
+			}
+			gts_parseQueryExpression(forInit) {
+				const node = this.startNode();
+				this.next();
+				if (this.eat(tokTypes.star)) node.star = true;
+				node.argument = this.parseMaybeUnary(null, true, false, forInit);
+				return this.finishNode(node, "GTSQueryExpression");
+			}
+		};
+	};
 }
-
-// packages/transpiler/src/parse/comment.js
-import { walk } from "zimmerframe";
+//#endregion
+//#region src/parse/comment.js
+/**
+* @import { AST, Parse } from '../types.js'
+*/
+/**
+* Acorn doesn't add comments to the AST by itself. This factory returns the capabilities
+* to add them after the fact. They are needed in order to support `ripple-ignore` comments
+* in JS code and so that `prettier-plugin` doesn't remove all comments when formatting.
+* @param {string} source
+* @param {AST.CommentWithLocation[]} comments
+* @param {number} [index=0] - Starting index
+* @returns {{onComment: Parse.Options['onComment'], addComments: (ast: AST.Node) => void}}
+*/
 function getCommentHandlers(source, comments, index = 0) {
-  function getNextNonWhitespaceCharacter(text, startIndex) {
-    for (let i = startIndex;i < text.length; i++) {
-      const char = text[i];
-      if (char !== " " && char !== "\t" && char !== `
-` && char !== "\r") {
-        return char;
-      }
-    }
-    return null;
-  }
-  return {
-    onComment: (block, value, start, end, start_loc, end_loc, metadata) => {
-      if (block && /\n/.test(value)) {
-        let a = start;
-        while (a > 0 && source[a - 1] !== `
-`)
-          a -= 1;
-        let b = a;
-        while (/[ \t]/.test(source[b]))
-          b += 1;
-        const indentation = source.slice(a, b);
-        value = value.replace(new RegExp(`^${indentation}`, "gm"), "");
-      }
-      comments.push({
-        type: block ? "Block" : "Line",
-        value,
-        start,
-        end,
-        loc: {
-          start: start_loc,
-          end: end_loc
-        },
-        context: metadata ?? null
-      });
-    },
-    addComments: (ast) => {
-      if (comments.length === 0)
-        return;
-      comments = comments.filter((comment) => comment.start >= index).map(({ type, value, start, end, loc, context }) => ({
-        type,
-        value,
-        start,
-        end,
-        loc,
-        context
-      }));
-      walk(ast, null, {
-        _(node, { next, path }) {
-          const metadata = node?.metadata;
-          if (metadata && metadata.commentContainerId !== undefined) {
-            while (comments[0] && comments[0].context && comments[0].context.containerId === metadata.commentContainerId && comments[0].context.beforeMeaningfulChild) {
-              const elementComment = comments.shift();
-              (metadata.elementLeadingComments ||= []).push(elementComment);
-            }
-          }
-          while (comments[0] && comments[0].start < node.start) {
-            const comment = comments.shift();
-            if (node.type === "BlockStatement") {
-              const parent = path.at(-1);
-              if (parent && (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && parent.body === node) {
-                (parent.comments ||= []).push(comment);
-                continue;
-              }
-            }
-            const ancestorElements = path.filter((ancestor) => ancestor && ancestor.type === "Element" && ancestor.loc).sort((a, b) => a.loc.start.line - b.loc.start.line);
-            const targetAncestor = ancestorElements.find((ancestor) => comment.loc.start.line < ancestor.loc.start.line);
-            if (targetAncestor) {
-              targetAncestor.metadata ??= { path: [] };
-              (targetAncestor.metadata.elementLeadingComments ||= []).push(comment);
-              continue;
-            }
-            (node.leadingComments ||= []).push(comment);
-          }
-          next();
-          if (comments[0]) {
-            if (node.type === "BlockStatement" && node.body.length === 0) {
-              while (comments[0] && comments[0].start < node.end && comments[0].end < node.end) {
-                const comment = comments.shift();
-                (node.innerComments ||= []).push(comment);
-              }
-              if (node.innerComments && node.innerComments.length > 0) {
-                return;
-              }
-            }
-            if (node.type === "JSXEmptyExpression") {
-              while (comments[0] && comments[0].start >= node.start && comments[0].end <= node.end) {
-                const comment = comments.shift();
-                (node.innerComments ||= []).push(comment);
-              }
-              if (node.innerComments && node.innerComments.length > 0) {
-                return;
-              }
-            }
-            if (node.type === "Element" && (!node.children || node.children.length === 0)) {
-              while (comments[0] && comments[0].start < node.end && comments[0].end < node.end) {
-                const comment = comments.shift();
-                (node.innerComments ||= []).push(comment);
-              }
-              if (node.innerComments && node.innerComments.length > 0) {
-                return;
-              }
-            }
-            const parent = path.at(-1);
-            if (parent === undefined || node.end !== parent.end) {
-              const slice = source.slice(node.end, comments[0].start);
-              let is_last_in_array = false;
-              let node_array = null;
-              let isParam = false;
-              let isArgument = false;
-              let isSwitchCaseSibling = false;
-              if (parent.type === "BlockStatement" || parent.type === "Program" || parent.type === "Component" || parent.type === "ClassBody") {
-                node_array = parent.body;
-              } else if (parent.type === "SwitchStatement") {
-                node_array = parent.cases;
-                isSwitchCaseSibling = true;
-              } else if (parent.type === "SwitchCase") {
-                node_array = parent.consequent;
-              } else if (parent.type === "ArrayExpression" || parent.type === "TrackedArrayExpression") {
-                node_array = parent.elements;
-              } else if (parent.type === "ObjectExpression" || parent.type === "TrackedObjectExpression") {
-                node_array = parent.properties;
-              } else if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") {
-                node_array = parent.params;
-                isParam = true;
-              } else if (parent.type === "CallExpression" || parent.type === "NewExpression") {
-                node_array = parent.arguments;
-                isArgument = true;
-              }
-              if (node_array && Array.isArray(node_array)) {
-                is_last_in_array = node_array.indexOf(node) === node_array.length - 1;
-              }
-              if (is_last_in_array) {
-                if (isParam || isArgument) {
-                  while (comments.length) {
-                    const potentialComment = comments[0];
-                    if (parent && potentialComment.start >= parent.end) {
-                      break;
-                    }
-                    const nextChar = getNextNonWhitespaceCharacter(source, potentialComment.end);
-                    if (nextChar === ")") {
-                      (node.trailingComments ||= []).push(comments.shift());
-                      continue;
-                    }
-                    break;
-                  }
-                } else {
-                  let end = node.end;
-                  while (comments.length) {
-                    const comment = comments[0];
-                    if (parent && comment.start >= parent.end)
-                      break;
-                    (node.trailingComments ||= []).push(comment);
-                    comments.shift();
-                    end = comment.end;
-                  }
-                }
-              } else if (node.end <= comments[0].start) {
-                const onlySimpleWhitespace = /^[,) \t]*$/.test(slice);
-                const onlyWhitespace = /^\s*$/.test(slice);
-                const hasBlankLine = /\n\s*\n/.test(slice);
-                const nodeEndLine = node.loc?.end?.line ?? null;
-                const commentStartLine = comments[0].loc?.start?.line ?? null;
-                const isImmediateNextLine = nodeEndLine !== null && commentStartLine !== null && commentStartLine === nodeEndLine + 1;
-                if (isSwitchCaseSibling && !is_last_in_array) {
-                  if (nodeEndLine !== null && commentStartLine !== null && nodeEndLine === commentStartLine) {
-                    node.trailingComments = [
-                      comments.shift()
-                    ];
-                  }
-                  return;
-                }
-                if (onlySimpleWhitespace || onlyWhitespace && !hasBlankLine && isImmediateNextLine) {
-                  if (comments[0].type === "Block" && !is_last_in_array && node_array) {
-                    const currentIndex = node_array.indexOf(node);
-                    const nextSibling = node_array[currentIndex + 1];
-                    if (nextSibling && nextSibling.loc) {
-                      const commentEndLine = comments[0].loc?.end?.line;
-                      const nextSiblingStartLine = nextSibling.loc?.start?.line;
-                      if (commentEndLine === nextSiblingStartLine) {
-                        return;
-                      }
-                    }
-                  }
-                  if (isParam) {
-                    const nodeEndLine2 = source.slice(0, node.end).split(`
-`).length;
-                    const commentStartLine2 = source.slice(0, comments[0].start).split(`
-`).length;
-                    if (nodeEndLine2 === commentStartLine2) {
-                      node.trailingComments = [
-                        comments.shift()
-                      ];
-                    }
-                  } else {
-                    node.trailingComments = [
-                      comments.shift()
-                    ];
-                  }
-                } else if (hasBlankLine && onlyWhitespace && node_array) {
-                  const isStatementContext = parent.type === "BlockStatement" || parent.type === "Program";
-                  if (!isStatementContext) {
-                    return;
-                  }
-                  const currentIndex = node_array.indexOf(node);
-                  const nextSibling = node_array[currentIndex + 1];
-                  if (nextSibling && nextSibling.loc) {
-                    let lastCommentIndex = 0;
-                    let lastCommentEnd = comments[0].end;
-                    while (comments[lastCommentIndex + 1]) {
-                      const currentComment = comments[lastCommentIndex];
-                      const nextComment = comments[lastCommentIndex + 1];
-                      const sliceBetween = source.slice(currentComment.end, nextComment.start);
-                      if (/\n\s*\n/.test(sliceBetween)) {
-                        break;
-                      }
-                      lastCommentIndex++;
-                      lastCommentEnd = nextComment.end;
-                    }
-                    const sliceAfterComments = source.slice(lastCommentEnd, nextSibling.start);
-                    const hasBlankLineAfter = /\n\s*\n/.test(sliceAfterComments);
-                    if (hasBlankLineAfter) {
-                      const nextIsElement = nextSibling.type === "Element";
-                      const commentsInsideElement = nextIsElement && nextSibling.loc && comments.some((c) => {
-                        if (!c.loc)
-                          return false;
-                        return c.loc.start.line >= nextSibling.loc.start.line && c.loc.end.line <= nextSibling.loc.end.line;
-                      });
-                      if (!commentsInsideElement) {
-                        for (let i = 0;i <= lastCommentIndex; i++) {
-                          (node.trailingComments ||= []).push(comments.shift());
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      });
-    }
-  };
-}
-
-// packages/transpiler/src/error.ts
-class GtsTranspilerError extends Error {
-  position;
-  constructor(message, position) {
-    super(message);
-    this.position = position;
-    this.name = "GtsTranspilerError";
-  }
+	/**
+	* @param {string} text
+	* @param {number} startIndex
+	* @returns {string | null}
+	*/
+	function getNextNonWhitespaceCharacter(text, startIndex) {
+		for (let i = startIndex; i < text.length; i++) {
+			const char = text[i];
+			if (char !== " " && char !== "	" && char !== "\n" && char !== "\r") return char;
+		}
+		return null;
+	}
+	return {
+		/**
+		* @type {Parse.Options['onComment']}
+		*/
+		onComment: (block, value, start, end, start_loc, end_loc, metadata) => {
+			if (block && /\n/.test(value)) {
+				let a = start;
+				while (a > 0 && source[a - 1] !== "\n") a -= 1;
+				let b = a;
+				while (/[ \t]/.test(source[b])) b += 1;
+				const indentation = source.slice(a, b);
+				value = value.replace(new RegExp(`^${indentation}`, "gm"), "");
+			}
+			comments.push({
+				type: block ? "Block" : "Line",
+				value,
+				start,
+				end,
+				loc: {
+					start: start_loc,
+					end: end_loc
+				},
+				context: metadata ?? null
+			});
+		},
+		/**
+		* @param {AST.Node} ast
+		*/
+		addComments: (ast) => {
+			if (comments.length === 0) return;
+			comments = comments.filter((comment) => comment.start >= index).map(({ type, value, start, end, loc, context }) => ({
+				type,
+				value,
+				start,
+				end,
+				loc,
+				context
+			}));
+			walk(ast, null, { _(node, { next, path }) {
+				const metadata = node?.metadata;
+				if (metadata && metadata.commentContainerId !== void 0) while (comments[0] && comments[0].context && comments[0].context.containerId === metadata.commentContainerId && comments[0].context.beforeMeaningfulChild) {
+					const elementComment = comments.shift();
+					(metadata.elementLeadingComments ||= []).push(elementComment);
+				}
+				while (comments[0] && comments[0].start < node.start) {
+					const comment = comments.shift();
+					if (node.type === "BlockStatement") {
+						const parent = path.at(-1);
+						if (parent && (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && parent.body === node) {
+							(parent.comments ||= []).push(comment);
+							continue;
+						}
+					}
+					const targetAncestor = path.filter((ancestor) => ancestor && ancestor.type === "Element" && ancestor.loc).sort((a, b) => a.loc.start.line - b.loc.start.line).find((ancestor) => comment.loc.start.line < ancestor.loc.start.line);
+					if (targetAncestor) {
+						targetAncestor.metadata ??= { path: [] };
+						(targetAncestor.metadata.elementLeadingComments ||= []).push(comment);
+						continue;
+					}
+					(node.leadingComments ||= []).push(comment);
+				}
+				next();
+				if (comments[0]) {
+					if (node.type === "BlockStatement" && node.body.length === 0) {
+						while (comments[0] && comments[0].start < node.end && comments[0].end < node.end) {
+							const comment = comments.shift();
+							(node.innerComments ||= []).push(comment);
+						}
+						if (node.innerComments && node.innerComments.length > 0) return;
+					}
+					if (node.type === "JSXEmptyExpression") {
+						while (comments[0] && comments[0].start >= node.start && comments[0].end <= node.end) {
+							const comment = comments.shift();
+							(node.innerComments ||= []).push(comment);
+						}
+						if (node.innerComments && node.innerComments.length > 0) return;
+					}
+					if (node.type === "Element" && (!node.children || node.children.length === 0)) {
+						while (comments[0] && comments[0].start < node.end && comments[0].end < node.end) {
+							const comment = comments.shift();
+							(node.innerComments ||= []).push(comment);
+						}
+						if (node.innerComments && node.innerComments.length > 0) return;
+					}
+					const parent = path.at(-1);
+					if (parent === void 0 || node.end !== parent.end) {
+						const slice = source.slice(node.end, comments[0].start);
+						let is_last_in_array = false;
+						/** @type {(AST.Node | null)[] | null} */
+						let node_array = null;
+						let isParam = false;
+						let isArgument = false;
+						let isSwitchCaseSibling = false;
+						if (parent.type === "BlockStatement" || parent.type === "Program" || parent.type === "Component" || parent.type === "ClassBody") node_array = parent.body;
+						else if (parent.type === "SwitchStatement") {
+							node_array = parent.cases;
+							isSwitchCaseSibling = true;
+						} else if (parent.type === "SwitchCase") node_array = parent.consequent;
+						else if (parent.type === "ArrayExpression" || parent.type === "TrackedArrayExpression") node_array = parent.elements;
+						else if (parent.type === "ObjectExpression" || parent.type === "TrackedObjectExpression") node_array = parent.properties;
+						else if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") {
+							node_array = parent.params;
+							isParam = true;
+						} else if (parent.type === "CallExpression" || parent.type === "NewExpression") {
+							node_array = parent.arguments;
+							isArgument = true;
+						}
+						if (node_array && Array.isArray(node_array)) is_last_in_array = node_array.indexOf(node) === node_array.length - 1;
+						if (is_last_in_array) if (isParam || isArgument) while (comments.length) {
+							const potentialComment = comments[0];
+							if (parent && potentialComment.start >= parent.end) break;
+							if (getNextNonWhitespaceCharacter(source, potentialComment.end) === ")") {
+								(node.trailingComments ||= []).push(comments.shift());
+								continue;
+							}
+							break;
+						}
+						else {
+							node.end;
+							while (comments.length) {
+								const comment = comments[0];
+								if (parent && comment.start >= parent.end) break;
+								(node.trailingComments ||= []).push(comment);
+								comments.shift();
+								comment.end;
+							}
+						}
+						else if (node.end <= comments[0].start) {
+							const onlySimpleWhitespace = /^[,) \t]*$/.test(slice);
+							const onlyWhitespace = /^\s*$/.test(slice);
+							const hasBlankLine = /\n\s*\n/.test(slice);
+							const nodeEndLine = node.loc?.end?.line ?? null;
+							const commentStartLine = comments[0].loc?.start?.line ?? null;
+							const isImmediateNextLine = nodeEndLine !== null && commentStartLine !== null && commentStartLine === nodeEndLine + 1;
+							if (isSwitchCaseSibling && !is_last_in_array) {
+								if (nodeEndLine !== null && commentStartLine !== null && nodeEndLine === commentStartLine) node.trailingComments = [comments.shift()];
+								return;
+							}
+							if (onlySimpleWhitespace || onlyWhitespace && !hasBlankLine && isImmediateNextLine) {
+								if (comments[0].type === "Block" && !is_last_in_array && node_array) {
+									const currentIndex = node_array.indexOf(node);
+									const nextSibling = node_array[currentIndex + 1];
+									if (nextSibling && nextSibling.loc) {
+										if (comments[0].loc?.end?.line === nextSibling.loc?.start?.line) return;
+									}
+								}
+								if (isParam) {
+									if (source.slice(0, node.end).split("\n").length === source.slice(0, comments[0].start).split("\n").length) node.trailingComments = [comments.shift()];
+								} else node.trailingComments = [comments.shift()];
+							} else if (hasBlankLine && onlyWhitespace && node_array) {
+								if (!(parent.type === "BlockStatement" || parent.type === "Program")) return;
+								const currentIndex = node_array.indexOf(node);
+								const nextSibling = node_array[currentIndex + 1];
+								if (nextSibling && nextSibling.loc) {
+									let lastCommentIndex = 0;
+									let lastCommentEnd = comments[0].end;
+									while (comments[lastCommentIndex + 1]) {
+										const currentComment = comments[lastCommentIndex];
+										const nextComment = comments[lastCommentIndex + 1];
+										const sliceBetween = source.slice(currentComment.end, nextComment.start);
+										if (/\n\s*\n/.test(sliceBetween)) break;
+										lastCommentIndex++;
+										lastCommentEnd = nextComment.end;
+									}
+									const sliceAfterComments = source.slice(lastCommentEnd, nextSibling.start);
+									if (/\n\s*\n/.test(sliceAfterComments)) {
+										if (!(nextSibling.type === "Element" && nextSibling.loc && comments.some((c) => {
+											if (!c.loc) return false;
+											return c.loc.start.line >= nextSibling.loc.start.line && c.loc.end.line <= nextSibling.loc.end.line;
+										}))) for (let i = 0; i <= lastCommentIndex; i++) (node.trailingComments ||= []).push(comments.shift());
+									}
+								}
+							}
+						}
+					}
+				}
+			} });
+		}
+	};
 }
-
-// packages/transpiler/src/parse/record_call_lparen_plugin.ts
-import { tokTypes as tokTypes3 } from "acorn";
+//#endregion
+//#region src/error.ts
+var GtsTranspilerError = class extends Error {
+	position;
+	constructor(message, position) {
+		super(message);
+		this.name = "GtsTranspilerError";
+		this.position = position;
+	}
+};
+//#endregion
+//#region src/parse/record_call_lparen_plugin.ts
+/**
+* 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
+* CallExpression/NewExpression node.
+* @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 === tokTypes3.parenL) {
-          recordedLParenLoc = {
-            start: this.startLoc,
-            end: this.endLoc
-          };
-        }
-        const result = super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
-        if (recordedLParenLoc && result.type === "CallExpression") {
-          result.lParenLoc = recordedLParenLoc;
-        }
-        return result;
-      }
-      _capturedLParenLocFromNew = null;
-      _patchedEat = (type) => {
-        if (type === tokTypes3.parenL) {
-          this._capturedLParenLocFromNew = {
-            start: this.startLoc,
-            end: this.endLoc
-          };
-        }
-        return this.eat(type);
-      };
-      #proxiedThis = new Proxy(this, {
-        get: (target, prop) => {
-          if (prop === "eat") {
-            return this._patchedEat;
-          }
-          const value = Reflect.get(target, prop);
-          if (typeof value === "function") {
-            return value.bind(target);
-          }
-          return value;
-        }
-      });
-      parseNew() {
-        const result = super.parseNew.apply(this.#proxiedThis);
-        if (this._capturedLParenLocFromNew && result.type === "NewExpression") {
-          result.lParenLoc = this._capturedLParenLocFromNew;
-          this._capturedLParenLocFromNew = null;
-        }
-        return result;
-      }
-    };
-  };
+	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 = [this.start, this.end];
+				const result = super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+				if (recordedLParenLoc && result.type === "CallExpression") result.lParenRange = recordedLParenLoc;
+				return result;
+			}
+			_capturedLParenRangeFromNew = null;
+			_patchedEat = (type) => {
+				if (type === tokTypes.parenL) this._capturedLParenRangeFromNew = [this.start, this.end];
+				return this.eat(type);
+			};
+			#proxiedThis = new Proxy(this, { get: (target, prop) => {
+				if (prop === "eat") return this._patchedEat;
+				const value = Reflect.get(target, prop);
+				if (typeof value === "function") return value.bind(target);
+				return value;
+			} });
+			parseNew() {
+				const result = super.parseNew.apply(this.#proxiedThis);
+				if (this._capturedLParenRangeFromNew && result.type === "NewExpression") {
+					result.lParenRange = this._capturedLParenRangeFromNew;
+					this._capturedLParenRangeFromNew = null;
+				}
+				return result;
+			}
+		};
+	};
 }
-
-// packages/transpiler/src/parse/index.ts
-var TsParser = Parser.extend(tsPlugin());
+//#endregion
+//#region src/parse/index.ts
+const TsParser = Parser.extend(tsPlugin());
 function parse(input, options) {
-  try {
-    const GtsParser = TsParser.extend(gtsPlugin(options));
-    return GtsParser.parse(input, {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      locations: true
-    });
-  } catch (e) {
-    if (e instanceof SyntaxError && "loc" in e) {
-      const loc = e.loc;
-      throw new GtsTranspilerError(e.message, {
-        start: loc,
-        end: { line: loc.line, column: loc.column + 1 }
-      });
-    } else {
-      throw new GtsTranspilerError(e?.message, null);
-    }
-  }
+	try {
+		return TsParser.extend(gtsPlugin(options)).parse(input, {
+			ecmaVersion: "latest",
+			sourceType: "module",
+			locations: true,
+			ranges: true
+		});
+	} catch (e) {
+		if (e instanceof SyntaxError && "loc" in e) {
+			const loc = e.loc;
+			throw new GtsTranspilerError(e.message, {
+				start: loc,
+				end: {
+					line: loc.line,
+					column: loc.column + 1
+				}
+			});
+		} else throw new GtsTranspilerError(e?.message, null);
+	}
 }
 function parseLoose(input, options) {
-  try {
-    const GtsParser = TsParser.extend(loosePlugin(), ...options?.recordCallLParens ? [recordCallLParenPlugin()] : [], gtsPlugin({
-      allowEmptyShortcutMember: options?.allowEmptyPositionalAttribute || true,
-      allowEmptyPositionalAttribute: options?.allowEmptyPositionalAttribute || true
-    }));
-    const { onComment, addComments } = getCommentHandlers(input, []);
-    const ast = GtsParser.parse(input, {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      locations: true,
-      onComment
-    });
-    addComments(ast);
-    return ast;
-  } catch (e) {
-    if (e instanceof SyntaxError && "loc" in e) {
-      const loc = e.loc;
-      throw new GtsTranspilerError(e.message, {
-        start: loc,
-        end: { line: loc.line, column: loc.column + 1 }
-      });
-    } else {
-      throw new GtsTranspilerError(e?.message, null);
-    }
-  }
+	try {
+		const GtsParser = TsParser.extend(loosePlugin(), ...options?.recordCallLParens ? [recordCallLParenPlugin()] : [], gtsPlugin({
+			allowEmptyShortcutMember: options?.allowEmptyPositionalAttribute || true,
+			allowEmptyPositionalAttribute: options?.allowEmptyPositionalAttribute || true
+		}));
+		const { onComment, addComments } = getCommentHandlers(input, []);
+		const ast = GtsParser.parse(input, {
+			ecmaVersion: "latest",
+			sourceType: "module",
+			locations: true,
+			ranges: true,
+			onComment
+		});
+		addComments(ast);
+		return ast;
+	} catch (e) {
+		if (e instanceof SyntaxError && "loc" in e) {
+			const loc = e.loc;
+			throw new GtsTranspilerError(e.message, {
+				start: loc,
+				end: {
+					line: loc.line,
+					column: loc.column + 1
+				}
+			});
+		} else throw new GtsTranspilerError(e?.message, null);
+	}
 }
-
-// packages/transpiler/src/transform/erase_ts.ts
-import { walk as walk2 } from "zimmerframe";
-var empty = {
-  type: "EmptyStatement"
-};
+//#endregion
+//#region src/transform/erase_ts.ts
+const empty = { type: "EmptyStatement" };
 function removeThisParameter(node, context) {
-  if (node.params[0]?.type === "Identifier" && node.params[0].name === "this") {
-    node.params.shift();
-  }
-  return context.next();
+	if (node.params[0]?.type === "Identifier" && node.params[0].name === "this") node.params.shift();
+	return context.next();
 }
-var throwInvalidFeature = (node, feature) => {
-  throw new GtsTranspilerError(`TypeScript feature not supported: ${feature}`, node.loc ?? null);
+const throwInvalidFeature = (node, feature) => {
+	throw new GtsTranspilerError(`TypeScript feature not supported: ${feature}`, node.loc ?? null);
 };
-var eraseTsVisitor = {
-  _(node, context) {
-    const n = context.next() ?? node;
-    delete n.typeAnnotation;
-    delete n.typeParameters;
-    delete n.typeArguments;
-    delete n.returnType;
-    delete n.accessibility;
-    delete n.readonly;
-    delete n.definite;
-    delete n.override;
-  },
-  Decorator(node) {
-    throwInvalidFeature(node, "decorators (related TSC proposal is not stage 4 yet)");
-  },
-  ImportDeclaration(node) {
-    if (node.importKind === "type")
-      return empty;
-    if (node.specifiers?.length > 0) {
-      const specifiers = node.specifiers.filter((s) => s.importKind !== "type");
-      if (specifiers.length === 0)
-        return empty;
-      return { ...node, specifiers };
-    }
-    return node;
-  },
-  ExportNamedDeclaration(node, context) {
-    if (node.exportKind === "type")
-      return empty;
-    if (node.declaration) {
-      const result = context.next();
-      if (result?.declaration?.type === "EmptyStatement") {
-        return empty;
-      }
-      return result;
-    }
-    if (node.specifiers) {
-      const specifiers = node.specifiers.filter((s) => s.exportKind !== "type");
-      if (specifiers.length === 0)
-        return empty;
-      return { ...node, specifiers };
-    }
-    return node;
-  },
-  ExportDefaultDeclaration(node) {
-    if (node.exportKind === "type")
-      return empty;
-    return node;
-  },
-  ExportAllDeclaration(node) {
-    if (node.exportKind === "type")
-      return empty;
-    return node;
-  },
-  PropertyDefinition(node, { next }) {
-    if (node.accessor) {
-      throwInvalidFeature(node, "accessor fields (related TSC proposal is not stage 4 yet)");
-    }
-    return next();
-  },
-  TSAsExpression(node, context) {
-    return context.visit(node.expression);
-  },
-  TSSatisfiesExpression(node, context) {
-    return context.visit(node.expression);
-  },
-  TSNonNullExpression(node, context) {
-    return context.visit(node.expression);
-  },
-  TSInterfaceDeclaration() {
-    return empty;
-  },
-  TSTypeAliasDeclaration() {
-    return empty;
-  },
-  TSTypeAssertion(node, context) {
-    return context.visit(node.expression);
-  },
-  TSEnumDeclaration(node) {
-    throwInvalidFeature(node, "enums");
-  },
-  TSParameterProperty(node, context) {
-    if ((node.readonly || node.accessibility) && context.path.at(-2)?.kind === "constructor") {
-      throwInvalidFeature(node, "accessibility modifiers on constructor parameters");
-    }
-    return context.visit(node.parameter);
-  },
-  TSInstantiationExpression(node, context) {
-    return context.visit(node.expression);
-  },
-  FunctionExpression: removeThisParameter,
-  FunctionDeclaration: removeThisParameter,
-  TSDeclareFunction() {
-    return empty;
-  },
-  ClassBody(node, context) {
-    const body = [];
-    for (const _child of node.body) {
-      const child = context.visit(_child);
-      if (child.type !== "PropertyDefinition" || !child.declare) {
-        body.push(child);
-      }
-    }
-    return {
-      ...node,
-      body
-    };
-  },
-  ClassDeclaration(node, context) {
-    if (node.declare) {
-      return empty;
-    }
-    delete node.abstract;
-    delete node.implements;
-    delete node.superTypeArguments;
-    return context.next();
-  },
-  ClassExpression(node, context) {
-    delete node.implements;
-    delete node.superTypeArguments;
-    return context.next();
-  },
-  MethodDefinition(node, context) {
-    if (node.abstract) {
-      return empty;
-    }
-    return context.next();
-  },
-  VariableDeclaration(node, context) {
-    if (node.declare) {
-      return empty;
-    }
-    return context.next();
-  },
-  TSModuleDeclaration(node, context) {
-    if (!node.body)
-      return empty;
-    const cleaned = node.body.body.map((entry) => context.visit(entry));
-    if (cleaned.some((entry) => entry !== empty)) {
-      throwInvalidFeature(node, "namespaces with non-type nodes");
-    }
-    return empty;
-  }
+const eraseTsVisitor = {
+	_(node, context) {
+		const n = context.next() ?? node;
+		delete n.typeAnnotation;
+		delete n.typeParameters;
+		delete n.typeArguments;
+		delete n.returnType;
+		delete n.accessibility;
+		delete n.readonly;
+		delete n.definite;
+		delete n.override;
+	},
+	Decorator(node) {
+		throwInvalidFeature(node, "decorators (related TSC proposal is not stage 4 yet)");
+	},
+	ImportDeclaration(node) {
+		if (node.importKind === "type") return empty;
+		if (node.specifiers?.length > 0) {
+			const specifiers = node.specifiers.filter((s) => s.importKind !== "type");
+			if (specifiers.length === 0) return empty;
+			return {
+				...node,
+				specifiers
+			};
+		}
+		return node;
+	},
+	ExportNamedDeclaration(node, context) {
+		if (node.exportKind === "type") return empty;
+		if (node.declaration) {
+			const result = context.next();
+			if (result?.declaration?.type === "EmptyStatement") return empty;
+			return result;
+		}
+		if (node.specifiers) {
+			const specifiers = node.specifiers.filter((s) => s.exportKind !== "type");
+			if (specifiers.length === 0) return empty;
+			return {
+				...node,
+				specifiers
+			};
+		}
+		return node;
+	},
+	ExportDefaultDeclaration(node) {
+		if (node.exportKind === "type") return empty;
+		return node;
+	},
+	ExportAllDeclaration(node) {
+		if (node.exportKind === "type") return empty;
+		return node;
+	},
+	PropertyDefinition(node, { next }) {
+		if (node.accessor) throwInvalidFeature(node, "accessor fields (related TSC proposal is not stage 4 yet)");
+		return next();
+	},
+	TSAsExpression(node, context) {
+		return context.visit(node.expression);
+	},
+	TSSatisfiesExpression(node, context) {
+		return context.visit(node.expression);
+	},
+	TSNonNullExpression(node, context) {
+		return context.visit(node.expression);
+	},
+	TSInterfaceDeclaration() {
+		return empty;
+	},
+	TSTypeAliasDeclaration() {
+		return empty;
+	},
+	TSTypeAssertion(node, context) {
+		return context.visit(node.expression);
+	},
+	TSEnumDeclaration(node) {
+		throwInvalidFeature(node, "enums");
+	},
+	TSParameterProperty(node, context) {
+		if ((node.readonly || node.accessibility) && context.path.at(-2)?.kind === "constructor") throwInvalidFeature(node, "accessibility modifiers on constructor parameters");
+		return context.visit(node.parameter);
+	},
+	TSInstantiationExpression(node, context) {
+		return context.visit(node.expression);
+	},
+	FunctionExpression: removeThisParameter,
+	FunctionDeclaration: removeThisParameter,
+	TSDeclareFunction() {
+		return empty;
+	},
+	ClassBody(node, context) {
+		const body = [];
+		for (const _child of node.body) {
+			const child = context.visit(_child);
+			if (child.type !== "PropertyDefinition" || !child.declare) body.push(child);
+		}
+		return {
+			...node,
+			body
+		};
+	},
+	ClassDeclaration(node, context) {
+		if (node.declare) return empty;
+		delete node.abstract;
+		delete node.implements;
+		delete node.superTypeArguments;
+		return context.next();
+	},
+	ClassExpression(node, context) {
+		delete node.implements;
+		delete node.superTypeArguments;
+		return context.next();
+	},
+	MethodDefinition(node, context) {
+		if (node.abstract) return empty;
+		return context.next();
+	},
+	VariableDeclaration(node, context) {
+		if (node.declare) return empty;
+		return context.next();
+	},
+	TSModuleDeclaration(node, context) {
+		if (!node.body) return empty;
+		if (node.body.body.map((entry) => context.visit(entry)).some((entry) => entry !== empty)) throwInvalidFeature(node, "namespaces with non-type nodes");
+		return empty;
+	}
 };
-var eraseTs = (ast) => {
-  return walk2(ast, null, eraseTsVisitor);
+const eraseTs = (ast) => {
+	return walk(ast, null, eraseTsVisitor);
 };
-
-// packages/transpiler/src/transform/index.ts
-import { print as print2 } from "esrap";
-import jsPrinter from "esrap/languages/ts";
-
-// packages/transpiler/src/transform/gts.ts
-import { walk as walk3 } from "zimmerframe";
-
-// packages/transpiler/src/transform/constants.ts
-var DEFAULT_SHORTCUT_FUNCTION_PRELUDES = [
-  "cryo",
-  "hydro",
-  "pyro",
-  "electro",
-  "anemo",
-  "geo",
-  "dendro",
-  "omni"
+//#endregion
+//#region src/transform/constants.ts
+const DEFAULT_SHORTCUT_FUNCTION_PRELUDES = [
+	"cryo",
+	"hydro",
+	"pyro",
+	"electro",
+	"anemo",
+	"geo",
+	"dendro",
+	"omni"
 ];
-var DEFAULT_QUERY_BINDINGS = ["my", "opp"];
-
-// packages/transpiler/src/transform/gts.ts
-var commonGtsVisitor = {
-  GTSDirectFunction(node, { visit, state }) {
-    return {
-      type: "ObjectExpression",
-      properties: [
-        {
-          type: "Property",
-          key: { type: "Identifier", name: "name" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: state.ActionLit,
-          loc: node.loc
-        },
-        {
-          type: "Property",
-          key: { type: "Identifier", name: "positionals" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: {
-            type: "ArrowFunctionExpression",
-            params: [],
-            body: {
-              type: "ArrayExpression",
-              elements: [
-                {
-                  type: "ArrowFunctionExpression",
-                  params: state.shortcutFunctionParameters,
-                  body: {
-                    type: "BlockStatement",
-                    body: node.body.map((stmt) => visit(stmt))
-                  },
-                  expression: false
-                }
-              ]
-            },
-            expression: true
-          }
-        },
-        {
-          type: "Property",
-          key: { type: "Identifier", name: "named" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: {
-            type: "Literal",
-            value: null
-          }
-        }
-      ],
-      loc: node.loc
-    };
-  },
-  GTSShortcutFunctionExpression(node, { visit, state }) {
-    return {
-      type: "ArrowFunctionExpression",
-      params: state.shortcutFunctionParameters,
-      body: visit(node.body),
-      expression: node.expression,
-      loc: node.loc
-    };
-  },
-  GTSShortcutArgumentExpression(node, { state, visit }) {
-    return {
-      type: "MemberExpression",
-      object: state.fnArgId,
-      computed: false,
-      optional: false,
-      property: visit(node.property),
-      loc: node.loc
-    };
-  },
-  GTSQueryExpression(node, { state, visit }) {
-    state.hasQueryExpressions = true;
-    return {
-      ...node,
-      type: "CallExpression",
-      optional: false,
-      callee: state.queryFnId,
-      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
-            }
-          ]
-        }
-      ]
-    };
-  }
+const DEFAULT_QUERY_BINDINGS = ["my", "opp"];
+//#endregion
+//#region src/transform/gts.ts
+const commonGtsVisitor = {
+	GTSDirectFunction(node, { visit, state }) {
+		return {
+			type: "ObjectExpression",
+			properties: [
+				{
+					type: "Property",
+					key: {
+						type: "Identifier",
+						name: "name"
+					},
+					computed: false,
+					kind: "init",
+					method: false,
+					shorthand: false,
+					value: state.ActionLit,
+					loc: node.loc,
+					range: node.range
+				},
+				{
+					type: "Property",
+					key: {
+						type: "Identifier",
+						name: "positionals"
+					},
+					computed: false,
+					kind: "init",
+					method: false,
+					shorthand: false,
+					value: {
+						type: "ArrowFunctionExpression",
+						params: [],
+						body: {
+							type: "ArrayExpression",
+							elements: [{
+								type: "ArrowFunctionExpression",
+								params: state.shortcutFunctionParameters,
+								body: {
+									type: "BlockStatement",
+									body: node.body.map((stmt) => visit(stmt))
+								},
+								expression: false
+							}]
+						},
+						expression: true
+					}
+				},
+				{
+					type: "Property",
+					key: {
+						type: "Identifier",
+						name: "named"
+					},
+					computed: false,
+					kind: "init",
+					method: false,
+					shorthand: false,
+					value: {
+						type: "Literal",
+						value: null
+					}
+				}
+			],
+			loc: node.loc,
+			range: node.range
+		};
+	},
+	GTSShortcutFunctionExpression(node, { visit, state }) {
+		return {
+			type: "ArrowFunctionExpression",
+			params: state.shortcutFunctionParameters,
+			body: visit(node.body),
+			expression: node.expression,
+			loc: node.loc,
+			range: node.range
+		};
+	},
+	GTSShortcutArgumentExpression(node, { state, visit }) {
+		return {
+			type: "MemberExpression",
+			object: state.fnArgId,
+			computed: false,
+			optional: false,
+			property: visit(node.property),
+			loc: node.loc,
+			range: node.range
+		};
+	},
+	GTSQueryExpression(node, { state, visit }) {
+		state.hasQueryExpressions = true;
+		return {
+			...node,
+			type: "CallExpression",
+			optional: false,
+			callee: state.queryFnId,
+			arguments: [{
+				type: "ArrowFunctionExpression",
+				body: visit(node.argument),
+				params: state.queryParameters,
+				expression: true,
+				loc: node.argument.loc,
+				range: node.argument.range
+			}, {
+				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
+				}]
+			}]
+		};
+	}
 };
-var gtsVisitor = {
-  Program(node, { state, visit }) {
-    const body = [];
-    for (const stmt of node.body) {
-      const visited = visit(stmt);
-      body.push(visited);
-    }
-    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: [
-        {
-          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.runtimeImportSource },
-      attributes: []
-    }, {
-      type: "ImportDeclaration",
-      specifiers: [
-        {
-          type: "ImportDefaultSpecifier",
-          local: state.rootVmId
-        }
-      ],
-      source: {
-        type: "Literal",
-        value: `${state.providerImportSource}/vm`
-      },
-      attributes: []
-    });
-    return {
-      ...node,
-      body
-    };
-  },
-  GTSDefineStatement(node, { state, visit }) {
-    const defineId = state.defineIdCounter++;
-    const rootAttr = visit(node.body);
-    const nodeVarId = {
-      type: "Identifier",
-      name: `__gts_node_${defineId}`
-    };
-    const bindingsVarId = {
-      type: "Identifier",
-      name: `__gts_bindings_${defineId}`
-    };
-    const newBindings = state.externalizedBindings;
-    state.externalizedBindings = [];
-    state.bindingStatements.push({
-      type: "VariableDeclaration",
-      kind: "const",
-      declarations: [
-        {
-          type: "VariableDeclarator",
-          id: nodeVarId,
-          init: rootAttr
-        }
-      ],
-      loc: node.loc
-    });
-    state.bindingStatements.push({
-      type: "VariableDeclaration",
-      kind: "const",
-      declarations: [
-        {
-          type: "VariableDeclarator",
-          id: bindingsVarId,
-          init: {
-            type: "CallExpression",
-            optional: false,
-            callee: state.createBindingFnId,
-            arguments: [state.rootVmId, nodeVarId]
-          }
-        }
-      ],
-      loc: node.loc
-    });
-    for (let i = 0;i < newBindings.length; i++) {
-      const binding = newBindings[i];
-      const decl = {
-        type: "VariableDeclaration",
-        kind: "const",
-        declarations: [
-          {
-            type: "VariableDeclarator",
-            id: binding.bindingName,
-            init: {
-              type: "MemberExpression",
-              object: bindingsVarId,
-              property: { type: "Literal", value: i },
-              computed: true,
-              optional: false
-            }
-          }
-        ]
-      };
-      if (binding.export) {
-        state.bindingStatements.push({
-          type: "ExportNamedDeclaration",
-          declaration: decl,
-          specifiers: [],
-          attributes: []
-        });
-      } else {
-        state.bindingStatements.push(decl);
-      }
-    }
-    return {
-      type: "ExpressionStatement",
-      expression: {
-        type: "CallExpression",
-        optional: false,
-        callee: state.createDefineFnId,
-        arguments: [state.rootVmId, nodeVarId]
-      },
-      loc: node.loc
-    };
-  },
-  GTSNamedAttributeDefinition(node, { visit, state }) {
-    const namedBody = visit(node.body);
-    const properties = [...namedBody.properties];
-    const nameValue = node.name.type === "Literal" ? node.name : {
-      ...node.name,
-      type: "Literal",
-      value: node.name.name
-    };
-    properties.unshift({
-      type: "Property",
-      key: {
-        type: "Identifier",
-        name: "name"
-      },
-      computed: false,
-      kind: "init",
-      method: false,
-      shorthand: false,
-      value: nameValue,
-      loc: node.loc
-    });
-    const body = { ...namedBody, properties };
-    if (node.bindingName) {
-      if (node.bindingAccessModifier === "protected") {
-        throw new GtsTranspilerError("Protected bindings are not supported in this context.", node.loc ?? null);
-      }
-      const export_ = node.bindingAccessModifier !== "private";
-      state.externalizedBindings.push({
-        bindingName: node.bindingName,
-        export: export_
-      });
-      body.properties.push({
-        type: "Property",
-        key: { type: "Identifier", name: "binding" },
-        computed: false,
-        kind: "init",
-        method: false,
-        shorthand: false,
-        value: {
-          type: "Literal",
-          value: export_ ? "public" : "private"
-        }
-      });
-    }
-    return body;
-  },
-  GTSAttributeBody(node, { visit }) {
-    const positionals = visit(node.positionalAttributes);
-    const named = node.namedAttributes ? visit(node.namedAttributes) : { type: "Literal", value: null };
-    const partialBody = {
-      type: "ObjectExpression",
-      properties: [
-        {
-          type: "Property",
-          key: { type: "Identifier", name: "positionals" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: {
-            type: "ArrowFunctionExpression",
-            params: [],
-            body: positionals,
-            expression: true,
-            loc: positionals.loc
-          },
-          loc: positionals.loc
-        },
-        {
-          type: "Property",
-          key: { type: "Identifier", name: "named" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: named,
-          loc: named.loc
-        }
-      ],
-      loc: node.loc
-    };
-    return partialBody;
-  },
-  GTSPositionalAttributeList(node, { visit }) {
-    return {
-      type: "ArrayExpression",
-      elements: node.attributes.map((attr) => {
-        if (attr.type === "Identifier" && /^[a-z_]/.test(attr.name)) {
-          return {
-            ...attr,
-            type: "Literal",
-            value: attr.name
-          };
-        } else {
-          return visit(attr);
-        }
-      }),
-      loc: node.loc
-    };
-  },
-  GTSNamedAttributeBlock(node, { visit }) {
-    const attributes = node.attributes.map((node2) => visit(node2));
-    if (node.directAction) {
-      attributes.push(visit(node.directAction));
-    }
-    return {
-      type: "ObjectExpression",
-      properties: [
-        {
-          type: "Property",
-          key: { type: "Identifier", name: "attributes" },
-          computed: false,
-          kind: "init",
-          method: false,
-          shorthand: false,
-          value: {
-            type: "ArrayExpression",
-            elements: attributes
-          }
-        }
-      ],
-      loc: node.loc
-    };
-  },
-  ...commonGtsVisitor
+const gtsVisitor = {
+	Program(node, { state, visit }) {
+		const body = [];
+		for (const stmt of node.body) {
+			const visited = visit(stmt);
+			body.push(visited);
+		}
+		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: [{
+				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.runtimeImportSource
+			},
+			attributes: []
+		}, {
+			type: "ImportDeclaration",
+			specifiers: [{
+				type: "ImportDefaultSpecifier",
+				local: state.rootVmId
+			}],
+			source: {
+				type: "Literal",
+				value: `${state.providerImportSource}/vm`
+			},
+			attributes: []
+		});
+		return {
+			...node,
+			body
+		};
+	},
+	GTSDefineStatement(node, { state, visit }) {
+		const defineId = state.defineIdCounter++;
+		const rootAttr = visit(node.body);
+		const nodeVarId = {
+			type: "Identifier",
+			name: `__gts_node_${defineId}`
+		};
+		const bindingsVarId = {
+			type: "Identifier",
+			name: `__gts_bindings_${defineId}`
+		};
+		const newBindings = state.externalizedBindings;
+		state.externalizedBindings = [];
+		state.bindingStatements.push({
+			type: "VariableDeclaration",
+			kind: "const",
+			declarations: [{
+				type: "VariableDeclarator",
+				id: nodeVarId,
+				init: rootAttr
+			}],
+			loc: node.loc,
+			range: node.range
+		});
+		state.bindingStatements.push({
+			type: "VariableDeclaration",
+			kind: "const",
+			declarations: [{
+				type: "VariableDeclarator",
+				id: bindingsVarId,
+				init: {
+					type: "CallExpression",
+					optional: false,
+					callee: state.createBindingFnId,
+					arguments: [state.rootVmId, nodeVarId]
+				}
+			}],
+			loc: node.loc,
+			range: node.range
+		});
+		for (let i = 0; i < newBindings.length; i++) {
+			const binding = newBindings[i];
+			const decl = {
+				type: "VariableDeclaration",
+				kind: "const",
+				declarations: [{
+					type: "VariableDeclarator",
+					id: binding.bindingName,
+					init: {
+						type: "MemberExpression",
+						object: bindingsVarId,
+						property: {
+							type: "Literal",
+							value: i
+						},
+						computed: true,
+						optional: false
+					}
+				}]
+			};
+			if (binding.export) state.bindingStatements.push({
+				type: "ExportNamedDeclaration",
+				declaration: decl,
+				specifiers: [],
+				attributes: []
+			});
+			else state.bindingStatements.push(decl);
+		}
+		return {
+			type: "ExpressionStatement",
+			expression: {
+				type: "CallExpression",
+				optional: false,
+				callee: state.createDefineFnId,
+				arguments: [state.rootVmId, nodeVarId]
+			},
+			loc: node.loc,
+			range: node.range
+		};
+	},
+	GTSNamedAttributeDefinition(node, { visit, state }) {
+		const namedBody = visit(node.body);
+		const properties = [...namedBody.properties];
+		const nameValue = node.name.type === "Literal" ? node.name : {
+			...node.name,
+			type: "Literal",
+			value: node.name.name
+		};
+		properties.unshift({
+			type: "Property",
+			key: {
+				type: "Identifier",
+				name: "name"
+			},
+			computed: false,
+			kind: "init",
+			method: false,
+			shorthand: false,
+			value: nameValue,
+			loc: node.loc,
+			range: node.range
+		});
+		const body = {
+			...namedBody,
+			properties
+		};
+		if (node.bindingName) {
+			if (node.bindingAccessModifier === "protected") throw new GtsTranspilerError("Protected bindings are not supported in this context.", node.loc ?? null);
+			const export_ = node.bindingAccessModifier !== "private";
+			state.externalizedBindings.push({
+				bindingName: node.bindingName,
+				export: export_
+			});
+			body.properties.push({
+				type: "Property",
+				key: {
+					type: "Identifier",
+					name: "binding"
+				},
+				computed: false,
+				kind: "init",
+				method: false,
+				shorthand: false,
+				value: {
+					type: "Literal",
+					value: export_ ? "public" : "private"
+				}
+			});
+		}
+		return body;
+	},
+	GTSAttributeBody(node, { visit }) {
+		const positionals = visit(node.positionalAttributes);
+		const named = node.namedAttributes ? visit(node.namedAttributes) : {
+			type: "Literal",
+			value: null
+		};
+		return {
+			type: "ObjectExpression",
+			properties: [{
+				type: "Property",
+				key: {
+					type: "Identifier",
+					name: "positionals"
+				},
+				computed: false,
+				kind: "init",
+				method: false,
+				shorthand: false,
+				value: {
+					type: "ArrowFunctionExpression",
+					params: [],
+					body: positionals,
+					expression: true,
+					loc: positionals.loc,
+					range: positionals.range
+				},
+				loc: positionals.loc,
+				range: positionals.range
+			}, {
+				type: "Property",
+				key: {
+					type: "Identifier",
+					name: "named"
+				},
+				computed: false,
+				kind: "init",
+				method: false,
+				shorthand: false,
+				value: named,
+				loc: named.loc,
+				range: named.range
+			}],
+			loc: node.loc,
+			range: node.range
+		};
+	},
+	GTSPositionalAttributeList(node, { visit }) {
+		return {
+			type: "ArrayExpression",
+			elements: node.attributes.map((attr) => {
+				if (attr.type === "Identifier" && /^[a-z_]/.test(attr.name)) return {
+					...attr,
+					type: "Literal",
+					value: attr.name
+				};
+				else return visit(attr);
+			}),
+			loc: node.loc,
+			range: node.range
+		};
+	},
+	GTSNamedAttributeBlock(node, { visit }) {
+		const attributes = node.attributes.map((node) => visit(node));
+		if (node.directAction) attributes.push(visit(node.directAction));
+		return {
+			type: "ObjectExpression",
+			properties: [{
+				type: "Property",
+				key: {
+					type: "Identifier",
+					name: "attributes"
+				},
+				computed: false,
+				kind: "init",
+				method: false,
+				shorthand: false,
+				value: {
+					type: "ArrayExpression",
+					elements: attributes
+				}
+			}],
+			loc: node.loc,
+			range: node.range
+		};
+	},
+	...commonGtsVisitor
 };
-var initialTranspileState = (option = {}) => {
-  const shortcutFunctionPreludes = option.shortcutFunctionPreludes ?? DEFAULT_SHORTCUT_FUNCTION_PRELUDES;
-  const queryBindings = option.queryBindings ?? DEFAULT_QUERY_BINDINGS;
-  const fnArgId = { type: "Identifier", name: "__gts_fnArg" };
-  const PreludeLit = {
-    type: "Literal",
-    value: "~prelude"
-  };
-  const shortcutFunctionParameters = [
-    fnArgId,
-    {
-      type: "AssignmentPattern",
-      left: {
-        type: "ObjectPattern",
-        properties: shortcutFunctionPreludes.map((name) => ({
-          type: "Property",
-          computed: false,
-          key: { type: "Identifier", name },
-          value: { type: "Identifier", name },
-          kind: "init",
-          method: false,
-          shorthand: true
-        }))
-      },
-      right: {
-        type: "MemberExpression",
-        object: fnArgId,
-        property: PreludeLit,
-        computed: true,
-        optional: false
-      }
-    }
-  ];
-  const queryParameters = [
-    {
-      type: "ObjectPattern",
-      properties: queryBindings.map((name) => ({
-        type: "Property",
-        computed: false,
-        key: { type: "Identifier", name },
-        value: { type: "Identifier", name },
-        kind: "init",
-        method: false,
-        shorthand: true
-      }))
-    }
-  ];
-  return {
-    createDefineFnId: { type: "Identifier", name: "__gts_createDefine" },
-    createBindingFnId: { type: "Identifier", name: "__gts_createBinding" },
-    ActionLit: { type: "Literal", value: "~action" },
-    PreludeLit,
-    fnArgId,
-    shortcutFunctionParameters,
-    rootVmId: { type: "Identifier", name: "__gts_rootVm" },
-    queryFnId: { type: "Identifier", name: "__gts_query" },
-    queryParameters,
-    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: []
-  };
+const initialTranspileState = (option = {}) => {
+	const shortcutFunctionPreludes = option.shortcutFunctionPreludes ?? DEFAULT_SHORTCUT_FUNCTION_PRELUDES;
+	const queryBindings = option.queryBindings ?? DEFAULT_QUERY_BINDINGS;
+	const fnArgId = {
+		type: "Identifier",
+		name: "__gts_fnArg"
+	};
+	const PreludeLit = {
+		type: "Literal",
+		value: "~prelude"
+	};
+	return {
+		createDefineFnId: {
+			type: "Identifier",
+			name: "__gts_createDefine"
+		},
+		createBindingFnId: {
+			type: "Identifier",
+			name: "__gts_createBinding"
+		},
+		ActionLit: {
+			type: "Literal",
+			value: "~action"
+		},
+		PreludeLit,
+		fnArgId,
+		shortcutFunctionParameters: [fnArgId, {
+			type: "AssignmentPattern",
+			left: {
+				type: "ObjectPattern",
+				properties: shortcutFunctionPreludes.map((name) => ({
+					type: "Property",
+					computed: false,
+					key: {
+						type: "Identifier",
+						name
+					},
+					value: {
+						type: "Identifier",
+						name
+					},
+					kind: "init",
+					method: false,
+					shorthand: true
+				}))
+			},
+			right: {
+				type: "MemberExpression",
+				object: fnArgId,
+				property: PreludeLit,
+				computed: true,
+				optional: false
+			}
+		}],
+		rootVmId: {
+			type: "Identifier",
+			name: "__gts_rootVm"
+		},
+		queryFnId: {
+			type: "Identifier",
+			name: "__gts_query"
+		},
+		queryParameters: [{
+			type: "ObjectPattern",
+			properties: queryBindings.map((name) => ({
+				type: "Property",
+				computed: false,
+				key: {
+					type: "Identifier",
+					name
+				},
+				value: {
+					type: "Identifier",
+					name
+				},
+				kind: "init",
+				method: false,
+				shorthand: true
+			}))
+		}],
+		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: []
+	};
 };
-var gtsToTs = (ast, option = {}) => {
-  const state = initialTranspileState(option);
-  return walk3(ast, state, gtsVisitor);
+const gtsToTs = (ast, option = {}) => {
+	return walk(ast, initialTranspileState(option), gtsVisitor);
 };
-
-// packages/transpiler/src/transform/volar/index.ts
-import { walk as walk5 } from "zimmerframe";
-import { print } from "esrap";
-
-// packages/transpiler/src/transform/volar/replacements.ts
-var createReplacementHolder = (state, value) => {
-  const rawValue = JSON.stringify(value);
-  return {
-    type: "ExpressionStatement",
-    expression: {
-      type: "TaggedTemplateExpression",
-      tag: state.replacementTag,
-      quasi: {
-        type: "TemplateLiteral",
-        expressions: [],
-        quasis: [
-          {
-            type: "TemplateElement",
-            value: { raw: rawValue },
-            tail: true
-          }
-        ]
-      }
-    }
-  };
+//#endregion
+//#region src/transform/volar/replacements.ts
+const createReplacementHolder = (state, value) => {
+	const rawValue = JSON.stringify(value);
+	return {
+		type: "ExpressionStatement",
+		expression: {
+			type: "TaggedTemplateExpression",
+			tag: state.replacementTag,
+			quasi: {
+				type: "TemplateLiteral",
+				expressions: [],
+				quasis: [{
+					type: "TemplateElement",
+					value: { raw: rawValue },
+					tail: true
+				}]
+			}
+		}
+	};
 };
-function applyReplacements(state, code) {
-  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`
+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 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}];
       `;
-    } else if (payload.type === "exitVM") {
-      const lhs = `${payload.finalMetaType}_lhs`;
-      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`
+		else if (payload.type === "exitVM") {
+			const lhs = `${payload.finalMetaType}_lhs`;
+			const requiredAttrsNs = `${payload.finalMetaType}_rans`;
+			const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ")}`;
+			const needleString = `"${requiredAttrsNs}_NeedleString" as any as "required attributes are missing"`;
+			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};
@@ -1388,16 +1310,17 @@ function applyReplacements(state, code) {
         };
         ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
       `;
-    } else if (payload.type === "enterAttr") {
-      const uniqueKeyLhs = `${payload.lhs}_uniqueKey_lhs`;
-      const uniqueKey = `${payload.lhs}_uniqueKey`;
-      const uniqueKeyForThis = `${payload.lhs}_uniqueKeyFor_${payload.lhs}`;
-      const uniqueKeyHelperIntf = `${payload.defType}_uniqueKeyProbeHelper`;
-      const omittedKeys = `${payload.lhs}_omittedKeys`;
-      return oneLine`
+		} else if (payload.type === "enterAttr") {
+			const uniqueKeyLhs = `${payload.lhs}_uniqueKey_lhs`;
+			const uniqueKey = `${payload.lhs}_uniqueKey`;
+			const uniqueKeyForThis = `${payload.lhs}_uniqueKeyFor_${payload.lhs}`;
+			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};
         let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
@@ -1419,9 +1342,9 @@ function applyReplacements(state, code) {
         );
         let ${payload.lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${omittedKeys}>;
       `;
-    } else if (payload.type === "createBindingTyping") {
-      const typingIdLhs = `${payload.typingId}_lhs`;
-      return oneLine`
+		} 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;
@@ -1430,861 +1353,597 @@ 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;
 }
-
-// packages/transpiler/src/transform/volar/walker.ts
-var EMPTY = { type: "EmptyStatement" };
-var ANY = {
-  type: "TSAnyKeyword"
-};
-var ANY_INIT = {
-  type: "TSAsExpression",
-  expression: { type: "Literal", value: 0 },
-  typeAnnotation: ANY
+//#endregion
+//#region src/transform/volar/walker.ts
+const EMPTY = { type: "EmptyStatement" };
+const ANY_INIT = {
+	type: "TSAsExpression",
+	expression: {
+		type: "Literal",
+		value: 0
+	},
+	typeAnnotation: { type: "TSAnyKeyword" }
 };
-var enterVMFromRoot = (state) => {
-  let defTypeId = {
-    type: "Identifier",
-    name: `__gts_rootVmDefType_${state.idCounter++}`
-  };
-  let metaTypeId = {
-    type: "Identifier",
-    name: `__gts_rootVmInitMetaType_${state.idCounter++}`
-  };
-  let finalMetaTypeId = {
-    type: "Identifier",
-    name: `__gts_rootVmFinalMetaType_${state.idCounter++}`
-  };
-  state.typingPendingStatements.push(createReplacementHolder(state, {
-    type: "enterVMFromRoot",
-    vm: state.rootVmId.name,
-    defType: defTypeId.name,
-    metaType: metaTypeId.name
-  }));
-  state.vmDefTypeIdStack.push(defTypeId);
-  state.metaTypeIdStack.push(metaTypeId);
-  state.finalMetaTypeIdStack.push(finalMetaTypeId);
-  state.attrsOfCurrentVm.push([]);
+const enterVMFromRoot = (state) => {
+	let defTypeId = {
+		type: "Identifier",
+		name: `__gts_rootVmDefType_${state.idCounter++}`
+	};
+	let metaTypeId = {
+		type: "Identifier",
+		name: `__gts_rootVmInitMetaType_${state.idCounter++}`
+	};
+	let finalMetaTypeId = {
+		type: "Identifier",
+		name: `__gts_rootVmFinalMetaType_${state.idCounter++}`
+	};
+	state.typingPendingStatements.push(createReplacementHolder(state, {
+		type: "enterVMFromRoot",
+		vm: state.rootVmId.name,
+		defType: defTypeId.name,
+		metaType: metaTypeId.name
+	}));
+	state.vmDefTypeIdStack.push(defTypeId);
+	state.metaTypeIdStack.push(metaTypeId);
+	state.finalMetaTypeIdStack.push(finalMetaTypeId);
+	state.attrsOfCurrentVm.push([]);
 };
-var enterVMFromAttr = (state, returningId) => {
-  const defTypeId = {
-    type: "Identifier",
-    name: `__gts_nestedVm_${state.idCounter++}`
-  };
-  const metaTypeId = {
-    type: "Identifier",
-    name: `__gts_nestedVmInitMetaType_${state.idCounter++}`
-  };
-  const finalMetaTypeId = {
-    type: "Identifier",
-    name: `__gts_nestedVmFinalMetaType_${state.idCounter++}`
-  };
-  state.typingPendingStatements.push(createReplacementHolder(state, {
-    type: "enterVMFromAttr",
-    returnType: returningId.name,
-    defType: defTypeId.name,
-    metaType: metaTypeId.name
-  }));
-  state.vmDefTypeIdStack.push(defTypeId);
-  state.metaTypeIdStack.push(metaTypeId);
-  state.finalMetaTypeIdStack.push(finalMetaTypeId);
-  state.attrsOfCurrentVm.push([]);
+const enterVMFromAttr = (state, returningId) => {
+	const defTypeId = {
+		type: "Identifier",
+		name: `__gts_nestedVm_${state.idCounter++}`
+	};
+	const metaTypeId = {
+		type: "Identifier",
+		name: `__gts_nestedVmInitMetaType_${state.idCounter++}`
+	};
+	const finalMetaTypeId = {
+		type: "Identifier",
+		name: `__gts_nestedVmFinalMetaType_${state.idCounter++}`
+	};
+	state.typingPendingStatements.push(createReplacementHolder(state, {
+		type: "enterVMFromAttr",
+		returnType: returningId.name,
+		defType: defTypeId.name,
+		metaType: metaTypeId.name
+	}));
+	state.vmDefTypeIdStack.push(defTypeId);
+	state.metaTypeIdStack.push(metaTypeId);
+	state.finalMetaTypeIdStack.push(finalMetaTypeId);
+	state.attrsOfCurrentVm.push([]);
 };
-var exitVM = (state, errorLoc) => {
-  const currentDefTypeId = state.vmDefTypeIdStack.pop();
-  const currentMetaId = state.metaTypeIdStack.pop();
-  const finalMetaId = state.finalMetaTypeIdStack.pop();
-  const collectedAttrNames = state.attrsOfCurrentVm.pop();
-  state.typingPendingStatements.push(createReplacementHolder(state, {
-    type: "exitVM",
-    metaType: currentMetaId.name,
-    defType: currentDefTypeId.name,
-    finalMetaType: finalMetaId.name,
-    collectedAttrs: collectedAttrNames,
-    errorLoc
-  }));
+const exitVM = (state, errorRange) => {
+	const currentDefTypeId = state.vmDefTypeIdStack.pop();
+	const currentMetaId = state.metaTypeIdStack.pop();
+	const finalMetaId = state.finalMetaTypeIdStack.pop();
+	const collectedAttrNames = state.attrsOfCurrentVm.pop();
+	state.typingPendingStatements.push(createReplacementHolder(state, {
+		type: "exitVM",
+		metaType: currentMetaId.name,
+		defType: currentDefTypeId.name,
+		finalMetaType: finalMetaId.name,
+		collectedAttrs: collectedAttrNames,
+		errorRange
+	}));
 };
-var enterAttr = (state, attrName) => {
-  const defTypeId = state.vmDefTypeIdStack.at(-1);
-  const metaTypeId = state.metaTypeIdStack.at(-1);
-  if (!defTypeId || !metaTypeId) {
-    return { lhsId: { type: "Identifier", name: "__invalid_attr_obj" } };
-  }
-  state.attrsOfCurrentVm.at(-1).push(attrName);
-  const lhsId = {
-    type: "Identifier",
-    name: `__gts_attr_obj_${state.idCounter++}`
-  };
-  state.typingPendingStatements.push(createReplacementHolder(state, {
-    type: "enterAttr",
-    defType: defTypeId.name,
-    metaType: metaTypeId.name,
-    lhs: lhsId.name,
-    attrName
-  }));
-  return { lhsId };
+const enterAttr = (state, attrName) => {
+	const defTypeId = state.vmDefTypeIdStack.at(-1);
+	const metaTypeId = state.metaTypeIdStack.at(-1);
+	if (!defTypeId || !metaTypeId) return { lhsId: {
+		type: "Identifier",
+		name: "__gts_invalid_attr_obj"
+	} };
+	state.attrsOfCurrentVm.at(-1).push(attrName);
+	const lhsId = {
+		type: "Identifier",
+		name: `__gts_attr_obj_${state.idCounter++}`
+	};
+	state.typingPendingStatements.push(createReplacementHolder(state, {
+		type: "enterAttr",
+		defType: defTypeId.name,
+		metaType: metaTypeId.name,
+		lhs: lhsId.name,
+		attrName
+	}));
+	return { lhsId };
 };
-var genBindingTyping = (state, info) => {
-  const finalMetaId = state.finalMetaTypeIdStack.at(-1);
-  const defTypeId = state.vmDefTypeIdStack.at(-1);
-  if (!finalMetaId || !defTypeId) {
-    return;
-  }
-  state.typingPendingStatements.push(createReplacementHolder(state, {
-    type: "createBindingTyping",
-    finalMetaType: finalMetaId.name,
-    defType: defTypeId.name,
-    attrName: info.attrName,
-    typingId: info.typingId.name
-  }));
+const genBindingTyping = (state, info) => {
+	const finalMetaId = state.finalMetaTypeIdStack.at(-1);
+	const defTypeId = state.vmDefTypeIdStack.at(-1);
+	if (!finalMetaId || !defTypeId) return;
+	state.typingPendingStatements.push(createReplacementHolder(state, {
+		type: "createBindingTyping",
+		finalMetaType: finalMetaId.name,
+		defType: defTypeId.name,
+		attrName: info.attrName,
+		typingId: info.typingId.name
+	}));
 };
-var exitAttr = (state, returningId) => {
-  const currentDefId = state.vmDefTypeIdStack.at(-1);
-  if (!currentDefId) {
-    return;
-  }
-  const newMetaTypeId = {
-    type: "Identifier",
-    name: `__gts_newMeta__${state.idCounter++}`
-  };
-  const [oldMetaTypeId] = state.metaTypeIdStack.splice(-1, 1, newMetaTypeId);
-  state.typingPendingStatements.push(createReplacementHolder(state, {
-    type: "exitAttr",
-    defType: currentDefId.name,
-    oldMetaType: oldMetaTypeId.name,
-    newMetaType: newMetaTypeId.name,
-    returnType: returningId.name
-  }));
+const exitAttr = (state, returningId) => {
+	const currentDefId = state.vmDefTypeIdStack.at(-1);
+	if (!currentDefId) return;
+	const newMetaTypeId = {
+		type: "Identifier",
+		name: `__gts_newMeta__${state.idCounter++}`
+	};
+	const [oldMetaTypeId] = state.metaTypeIdStack.splice(-1, 1, newMetaTypeId);
+	state.typingPendingStatements.push(createReplacementHolder(state, {
+		type: "exitAttr",
+		defType: currentDefId.name,
+		oldMetaType: oldMetaTypeId.name,
+		newMetaType: newMetaTypeId.name,
+		returnType: returningId.name
+	}));
 };
-var gtsToTypingsWalker = {
-  Program(node, { state, visit }) {
-    const body = [];
-    for (const stmt of node.body) {
-      if (stmt.type === "GTSDefineStatement") {
-        state.defineLeadingComments = stmt.leadingComments;
-        visit(stmt);
-        body.push(...state.typingPendingStatements);
-        state.typingPendingStatements = [];
-      } else {
-        body.push(visit(stmt));
-      }
-    }
-    for (const extBinding of state.externalizedBindings) {
-      const varDecl = {
-        type: "VariableDeclaration",
-        kind: "const",
-        declarations: [
-          {
-            type: "VariableDeclarator",
-            id: extBinding.bindingName,
-            init: ANY_INIT,
-            typeAnnotation: {
-              type: "TSTypeAnnotation",
-              typeAnnotation: {
-                type: "TSTypeReference",
-                typeName: extBinding.typingId
-              }
-            }
-          }
-        ]
-      };
-      if (extBinding.export) {
-        body.unshift({
-          type: "ExportNamedDeclaration",
-          declaration: varDecl,
-          specifiers: [],
-          source: null,
-          attributes: [],
-          leadingComments: extBinding.leadingComments
-        });
-      } else {
-        varDecl.leadingComments = extBinding.leadingComments;
-        body.unshift(varDecl);
-      }
-    }
-    if (state.hasQueryExpressions) {
-      body.unshift({
-        type: "ImportDeclaration",
-        diagnosticsOnTop: true,
-        specifiers: [
-          {
-            type: "ImportDefaultSpecifier",
-            local: state.queryFnId
-          }
-        ],
-        source: {
-          type: "Literal",
-          value: `${state.providerImportSource}/query`
-        },
-        attributes: []
-      });
-    }
-    body.unshift({
-      type: "ImportDeclaration",
-      diagnosticsOnTop: true,
-      specifiers: [
-        {
-          type: "ImportDefaultSpecifier",
-          local: state.rootVmId
-        }
-      ],
-      source: {
-        type: "Literal",
-        value: `${state.providerImportSource}/vm`
-      },
-      attributes: []
-    }, createReplacementHolder(state, {
-      type: "preface"
-    }));
-    return {
-      ...node,
-      body
-    };
-  },
-  GTSDefineStatement(node, { state, visit }) {
-    enterVMFromRoot(state);
-    visit(node.body);
-    exitVM(state);
-    return EMPTY;
-  },
-  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 {
-          type: "Literal",
-          value: attr.name,
-          loc: attr.loc
-        };
-      } else {
-        return visit(attr);
-      }
-    });
-    const returnValue = {
-      type: "Identifier",
-      name: `__gts_attrRet_${state.idCounter++}`
-    };
-    state.typingPendingStatements.push({
-      type: "VariableDeclaration",
-      kind: "const",
-      declarations: [
-        {
-          type: "VariableDeclarator",
-          id: returnValue,
-          init: {
-            type: "CallExpression",
-            optional: false,
-            callee: {
-              type: "MemberExpression",
-              object: lhsId,
-              property: name,
-              computed: name.type === "Literal",
-              optional: false
-            },
-            arguments: positionals
-          }
-        }
-      ]
-    });
-    if (body.namedAttributes) {
-      enterVMFromAttr(state, returnValue);
-      visit(body.namedAttributes);
-      exitVM(state, `${body.namedAttributes.loc?.start.line}:${body.namedAttributes.loc?.start.column}`);
-    }
-    if (bindingName) {
-      const export_ = node.bindingAccessModifier !== "private";
-      const typingId = {
-        type: "Identifier",
-        name: `gts_binding_type_${state.externalizedBindings.length}`
-      };
-      genBindingTyping(state, {
-        attrName,
-        typingId
-      });
-      state.externalizedBindings.push({
-        bindingName: {
-          ...bindingName,
-          typeAnnotation: {
-            type: "TSTypeAnnotation",
-            typeAnnotation: {
-              type: "TSTypeReference",
-              typeName: typingId
-            }
-          }
-        },
-        export: export_,
-        typingId,
-        leadingComments: state.defineLeadingComments
-      });
-    }
-    exitAttr(state, returnValue);
-    return EMPTY;
-  },
-  GTSNamedAttributeBlock(node, { state, visit }) {
-    for (const attr of node.attributes) {
-      visit(attr);
-    }
-    if (node.directAction) {
-      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);
-      const fn = {
-        type: "ArrowFunctionExpression",
-        params: state.shortcutFunctionParameters,
-        body: {
-          type: "BlockStatement",
-          body: node.directAction.body.map((stmt) => visit(stmt))
-        },
-        expression: false
-      };
-      const returnValue = {
-        type: "Identifier",
-        name: `__gts_attrRet_${state.idCounter++}`
-      };
-      state.typingPendingStatements.push({
-        type: "VariableDeclaration",
-        kind: "const",
-        declarations: [
-          {
-            type: "VariableDeclarator",
-            id: returnValue,
-            init: {
-              type: "CallExpression",
-              optional: false,
-              callee: {
-                type: "MemberExpression",
-                object: lhsId,
-                property: state.ActionLit,
-                computed: true,
-                optional: false
-              },
-              arguments: [fn]
-            }
-          }
-        ]
-      });
-    }
-    return EMPTY;
-  },
-  ...commonGtsVisitor,
-  GTSShortcutArgumentExpression(node, { state, visit }) {
-    const lhs = { ...state.fnArgId };
-    return {
-      type: "MemberExpression",
-      object: lhs,
-      computed: false,
-      optional: false,
-      property: visit(node.property)
-    };
-  }
+const gtsToTypingsWalker = {
+	Program(node, { state, visit }) {
+		const body = [];
+		for (const stmt of node.body) if (stmt.type === "GTSDefineStatement") {
+			state.defineLeadingComments = stmt.leadingComments;
+			visit(stmt);
+			body.push(...state.typingPendingStatements);
+			state.typingPendingStatements = [];
+		} else body.push(visit(stmt));
+		for (const extBinding of state.externalizedBindings) {
+			const varDecl = {
+				type: "VariableDeclaration",
+				kind: "const",
+				declarations: [{
+					type: "VariableDeclarator",
+					id: extBinding.bindingName,
+					init: ANY_INIT,
+					typeAnnotation: {
+						type: "TSTypeAnnotation",
+						typeAnnotation: {
+							type: "TSTypeReference",
+							typeName: extBinding.typingId
+						}
+					}
+				}]
+			};
+			if (extBinding.export) body.unshift({
+				type: "ExportNamedDeclaration",
+				declaration: varDecl,
+				specifiers: [],
+				source: null,
+				attributes: [],
+				leadingComments: extBinding.leadingComments
+			});
+			else {
+				varDecl.leadingComments = extBinding.leadingComments;
+				body.unshift(varDecl);
+			}
+		}
+		const importDecls = [];
+		if (state.hasQueryExpressions) importDecls.push({
+			type: "ImportDeclaration",
+			specifiers: [{
+				type: "ImportDefaultSpecifier",
+				local: state.queryFnId
+			}],
+			source: {
+				type: "Literal",
+				value: `${state.providerImportSource}/query`
+			},
+			attributes: []
+		});
+		importDecls.push({
+			type: "ImportDeclaration",
+			specifiers: [{
+				type: "ImportDefaultSpecifier",
+				local: state.rootVmId
+			}],
+			source: {
+				type: "Literal",
+				value: `${state.providerImportSource}/vm`
+			},
+			attributes: []
+		});
+		for (const importDecl of importDecls) {
+			state.diagnosticsOnTopNodes.add(importDecl.source);
+			for (const specifier of importDecl.specifiers) state.diagnosticsOnTopNodes.add(specifier);
+		}
+		body.unshift(...importDecls, createReplacementHolder(state, { type: "preface" }));
+		return {
+			...node,
+			body
+		};
+	},
+	GTSDefineStatement(node, { state, visit }) {
+		enterVMFromRoot(state);
+		visit(node.body);
+		exitVM(state);
+		return EMPTY;
+	},
+	GTSNamedAttributeDefinition(node, { visit, state }) {
+		const { name, body, bindingName } = node;
+		const attrName = JSON.stringify(name.type === "Literal" ? String(name.value) : name.name);
+		const { lhsId } = enterAttr(state, attrName);
+		const positionals = body.positionalAttributes.attributes.map((attr) => {
+			if (attr.type === "Identifier" && /^[a-z_]/.test(attr.name)) {
+				const lit = {
+					type: "Literal",
+					value: attr.name,
+					loc: attr.loc,
+					range: attr.range
+				};
+				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",
+			declarations: [{
+				type: "VariableDeclarator",
+				id: returnValue,
+				init: {
+					type: "CallExpression",
+					optional: false,
+					callee,
+					arguments: positionals
+				}
+			}]
+		});
+		if (body.namedAttributes) {
+			enterVMFromAttr(state, returnValue);
+			visit(body.namedAttributes);
+			exitVM(state, body.namedAttributes.range);
+		}
+		if (bindingName) {
+			const export_ = node.bindingAccessModifier !== "private";
+			const typingId = {
+				type: "Identifier",
+				name: `__gts_binding_type_${state.externalizedBindings.length}`
+			};
+			genBindingTyping(state, {
+				attrName,
+				typingId
+			});
+			state.externalizedBindings.push({
+				bindingName: {
+					...bindingName,
+					typeAnnotation: {
+						type: "TSTypeAnnotation",
+						typeAnnotation: {
+							type: "TSTypeReference",
+							typeName: typingId
+						}
+					}
+				},
+				export: export_,
+				typingId,
+				leadingComments: state.defineLeadingComments
+			});
+		}
+		exitAttr(state, returnValue);
+		return EMPTY;
+	},
+	GTSNamedAttributeBlock(node, { state, visit }) {
+		for (const attr of node.attributes) visit(attr);
+		if (node.directAction) {
+			const attrName = JSON.stringify(state.ActionLit.value);
+			const { lhsId } = enterAttr(state, attrName);
+			const actionNotExistsReplacementStr = `${lhsId.name}[${attrName}]`;
+			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,
+				body: {
+					type: "BlockStatement",
+					body: node.directAction.body.map((stmt) => visit(stmt))
+				},
+				expression: false
+			};
+			const returnValue = {
+				type: "Identifier",
+				name: `__gts_attrRet_${state.idCounter++}`
+			};
+			state.typingPendingStatements.push({
+				type: "VariableDeclaration",
+				kind: "const",
+				declarations: [{
+					type: "VariableDeclarator",
+					id: returnValue,
+					init: {
+						type: "CallExpression",
+						optional: false,
+						callee: {
+							type: "MemberExpression",
+							object: lhsId,
+							property: state.ActionLit,
+							computed: true,
+							optional: false
+						},
+						arguments: [fn]
+					}
+				}]
+			});
+		}
+		return EMPTY;
+	},
+	...commonGtsVisitor
 };
-
-// packages/transpiler/src/transform/volar/mappings.ts
-import { decode } from "@jridgewell/sourcemap-codec";
-var DEFAULT_VOLAR_MAPPING_DATA = {
-  completion: true,
-  format: true,
-  navigation: true,
-  semantic: true,
-  structure: true,
-  verification: true
+//#endregion
+//#region src/transform/volar/mappings.ts
+const DEFAULT_VOLAR_MAPPING_DATA = {
+	completion: true,
+	format: true,
+	navigation: true,
+	semantic: true,
+	structure: true,
+	verification: true
 };
-function buildSrcToGenMap(source_map, line_offsets, generated_code) {
-  const map = new Map;
-  const decoded = decode(source_map.mappings);
-  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 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: {}
-      };
-      if (!map.has(key)) {
-        map.set(key, []);
-      }
-      map.get(key).push(gen_pos);
-    }
-  }
-  return map;
-}
-function getGeneratedPosition(src_line, src_column, srcToGenMap) {
-  const key = `${src_line}:${src_column}`;
-  const positions = srcToGenMap.get(key);
-  return positions || [];
-}
-function createLineOffsets(content) {
-  const lines = content.split(`
-`);
-  const offsets = [];
-  let currentOffset = 0;
-  for (const line of lines) {
-    offsets.push(currentOffset);
-    currentOffset += line.length + 1;
-  }
-  return offsets;
-}
-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 line = Number(lineStr);
-    const column = Number(columnStr);
-    const sourceStart = locToOffset(line, column, sourceLineOffsets);
-    const sourceLength = 1;
-    const generatedLength = codeSnippet.length;
-    mappings.push({
-      sourceOffsets: [sourceStart],
-      generatedOffsets: [generatedStart],
-      lengths: [sourceLength],
-      generatedLengths: [generatedLength],
-      data: {
-        verification: true
-      }
-    });
-  }
-  mappings.sort((a, b) => a.sourceOffsets[0] - b.sourceOffsets[0]);
-  return mappings;
-}
-
-// packages/transpiler/src/transform/volar/collect_tokens.ts
-import { walk as walk4 } from "zimmerframe";
-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: []
-  };
-  walk4(ast, state, {
-    _(node, { state: state2, 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;
-        }
-        state2.tokens.push(token);
-      }
-      next();
-    },
-    NewExpression(node, { state: state2, next }) {
-      const lParenLoc = node.lParenLoc;
-      if (lParenLoc) {
-        state2.tokens.push({
-          loc: lParenLoc
-        });
-      }
-      next();
-    },
-    CallExpression(node, { state: state2, next }) {
-      const lParenLoc = node.lParenLoc;
-      if (lParenLoc) {
-        state2.tokens.push({
-          loc: lParenLoc
-        });
-      }
-      next();
-    }
-  });
-  return state.tokens;
-}
-
-// packages/transpiler/src/transform/volar/printer.ts
-import tsPrinter from "esrap/languages/ts";
-var printer = tsPrinter({
-  getLeadingComments: (node) => node.leadingComments,
-  getTrailingComments: (node) => node.trailingComments
-});
-var 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);
-  }
-};
-var prevCallNewExpression = printer.CallExpression;
-var 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, node2) => {
-    if (text === "(") {
-      hasDeferredWrite = true;
-    } else {
-      context.write(text, node2);
-    }
-  };
-  const patchedVisit = (node2) => {
-    if (hasDeferredWrite) {
-      context.write("(");
-    }
-    return context.visit(node2);
-  };
-  const patchedAppend = (subcontext) => {
-    if (hasDeferredWrite) {
-      context.write("(", lParenFakeNode);
-      interceptionDone = true;
-    }
-    return context.append(subcontext);
-  };
-  const proxiedContext = 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;
-    }
-  });
-  return prevCallNewExpression(node, proxiedContext);
-};
-printer.CallExpression = newCallNewExpression;
-printer.NewExpression = newCallNewExpression;
-var 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, node2) {
-      node2 ??= {};
-      node2.loc ??= {
-        start: { line: 1, column: 0 },
-        end: { line: 1, column: 0 }
-      };
-      return prevContextWrite.call(this, text, node2);
-    };
-  }
-  prevWildcard(node, context, visit);
-  contextProto.write = prevContextWrite;
-};
-var patchedPrinter = printer;
-
-// packages/transpiler/src/transform/volar/index.ts
-function gtsToTypings(ast, option) {
-  const state = {
-    ...initialTranspileState(option),
-    leafTokens: option.leafTokens,
-    idCounter: 0,
-    typingPendingStatements: [],
-    rootVmId: { type: "Identifier", name: "__gts_root_vm" },
-    utilNsId: { type: "Identifier", name: "__gts_util" },
-    replacementTag: { type: "Identifier", name: "__gts_replacement_tag" },
-    MetaLit: { type: "Literal", value: "~meta" },
-    NamedDefinitionLit: { type: "Literal", value: "~namedDefinition" },
-    defineLeadingComments: [],
-    vmDefTypeIdStack: [],
-    metaTypeIdStack: [],
-    finalMetaTypeIdStack: [],
-    attrsOfCurrentVm: [],
-    extraMappings: option.extraMappings
-  };
-  const newAst = walk5(ast, state, gtsToTypingsWalker);
-  const { code, map } = print(newAst, patchedPrinter, {
-    indent: "  "
-  });
-  return {
-    code: applyReplacements(state, code),
-    sourceMap: map
-  };
+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);
+				}
+			}
+		},
+		experimentalGetLeftParenSourceRange: (node) => {
+			const callLike = node;
+			if (callLike.lParenRange) return {
+				start: callLike.lParenRange[0],
+				end: callLike.lParenRange[1]
+			};
+			return state.namedAttributeCalleeLParenRange.get(callLike.callee);
+		}
+	};
 }
+//#endregion
+//#region src/transform/volar/index.ts
 function transformForVolar(ast, option, sourceInfo) {
-  const tokens = collectLeafTokens(ast);
-  const extraMappings = new Map;
-  const { code, sourceMap } = gtsToTypings(ast, {
-    ...option,
-    leafTokens: tokens,
-    extraMappings
-  });
-  const volarMappings = convertToVolarMappings(code, sourceInfo.content, sourceMap, tokens, extraMappings);
-  return {
-    code,
-    mappings: volarMappings
-  };
+	const state = {
+		...initialTranspileState(option),
+		idCounter: 0,
+		typingPendingStatements: [],
+		rootVmId: {
+			type: "Identifier",
+			name: "__gts_root_vm"
+		},
+		utilNsId: {
+			type: "Identifier",
+			name: "__gts_util"
+		},
+		replacementTag: {
+			type: "Identifier",
+			name: "__gts_replacement_tag"
+		},
+		MetaLit: {
+			type: "Literal",
+			value: "~meta"
+		},
+		NamedDefinitionLit: {
+			type: "Literal",
+			value: "~namedDefinition"
+		},
+		defineLeadingComments: [],
+		vmDefTypeIdStack: [],
+		metaTypeIdStack: [],
+		finalMetaTypeIdStack: [],
+		attrsOfCurrentVm: [],
+		sourceNodes: /* @__PURE__ */ new WeakSet(),
+		namedAttributeCalleeLParenRange: /* @__PURE__ */ new WeakMap(),
+		literalFromIdentifier: /* @__PURE__ */ new WeakSet(),
+		lastArgNodes: /* @__PURE__ */ new WeakSet(),
+		diagnosticsOnTopNodes: /* @__PURE__ */ new WeakSet(),
+		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);
+	} });
+	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
+		});
+	}
+	return {
+		code,
+		mappings
+	};
 }
-
-// packages/transpiler/src/transform/index.ts
+//#endregion
+//#region src/transform/index.ts
 function transform(ast, option = {}, sourceInfo = {}) {
-  const ts = gtsToTs(ast, option);
-  const js = eraseTs(ts);
-  const { code, map } = print2(js, jsPrinter(), {
-    indent: "  ",
-    sourceMapContent: sourceInfo.content,
-    sourceMapSource: sourceInfo.filename
-  });
-  return {
-    code,
-    sourceMap: map
-  };
+	const { code, map } = print(eraseTs(gtsToTs(ast, option)), jsPrinter(), {
+		indent: "  ",
+		sourceMapContent: sourceInfo.content,
+		sourceMapSource: sourceInfo.filename
+	});
+	return {
+		code,
+		sourceMap: map
+	};
 }
-// packages/transpiler/src/config.ts
-import path from "path-browserify-esm";
-var DEFAULT_GTS_CONFIG = {
-  runtimeImportSource: "@gi-tcg/gts-runtime",
-  providerImportSource: "@gi-tcg/core/gts",
-  shortcutFunctionPreludes: [
-    "cryo",
-    "hydro",
-    "pyro",
-    "electro",
-    "anemo",
-    "geo",
-    "dendro",
-    "omni"
-  ],
-  queryBindings: ["my", "opp"]
+//#endregion
+//#region src/config.ts
+const DEFAULT_GTS_CONFIG = {
+	runtimeImportSource: "@gi-tcg/gts-runtime",
+	providerImportSource: "@gi-tcg/core/gts",
+	shortcutFunctionPreludes: [
+		"cryo",
+		"hydro",
+		"pyro",
+		"electro",
+		"anemo",
+		"geo",
+		"dendro",
+		"omni"
+	],
+	queryBindings: ["my", "opp"]
 };
 function* resolveGtsConfigImpl(filePath, inlineConfig = {}, options) {
-  const startDir = normalizeStartDir(filePath, options.cwd);
-  const stopDir = options.stopDir ? path.resolve(options.stopDir) : undefined;
-  const pkgConfig = yield* findNearestPackageConfig(options.readFileFn, startDir, stopDir);
-  return {
-    ...DEFAULT_GTS_CONFIG,
-    ...pkgConfig,
-    ...inlineConfig
-  };
+	const startDir = normalizeStartDir(filePath, options.cwd);
+	const stopDir = options.stopDir ? path.resolve(options.stopDir) : void 0;
+	const pkgConfig = yield* findNearestPackageConfig(options.readFileFn, startDir, stopDir);
+	return {
+		...DEFAULT_GTS_CONFIG,
+		...pkgConfig,
+		...inlineConfig
+	};
 }
 async function resolveGtsConfig(filePath, inlineConfig, options) {
-  const generator = resolveGtsConfigImpl(filePath, inlineConfig, options);
-  let result = generator.next();
-  while (!result.done) {
-    const toRead = result.value;
-    const content = await toRead;
-    result = generator.next(content);
-  }
-  return result.value;
+	const generator = resolveGtsConfigImpl(filePath, inlineConfig, options);
+	let result = generator.next();
+	while (!result.done) {
+		const content = await result.value;
+		result = generator.next(content);
+	}
+	return result.value;
 }
 function resolveGtsConfigSync(filePath, inlineConfig, options) {
-  const generator = resolveGtsConfigImpl(filePath, inlineConfig, options);
-  let result = generator.next();
-  while (!result.done) {
-    const toRead = result.value;
-    if (toRead instanceof Promise) {
-      throw new Error("resolveGtsConfigSync received a Promise. Did you mean to use resolveGtsConfig instead?");
-    }
-    const content = toRead;
-    result = generator.next(content);
-  }
-  return result.value;
+	const generator = resolveGtsConfigImpl(filePath, inlineConfig, options);
+	let result = generator.next();
+	while (!result.done) {
+		const toRead = result.value;
+		if (toRead instanceof Promise) throw new Error("resolveGtsConfigSync received a Promise. Did you mean to use resolveGtsConfig instead?");
+		const content = toRead;
+		result = generator.next(content);
+	}
+	return result.value;
 }
 function normalizeStartDir(sourceFile, cwd) {
-  const absolute = path.isAbsolute(sourceFile) ? sourceFile : path.resolve(cwd || ".", sourceFile);
-  return path.dirname(absolute);
+	const absolute = path.isAbsolute(sourceFile) ? sourceFile : path.resolve(cwd || ".", sourceFile);
+	return path.dirname(absolute);
 }
 function* findNearestPackageConfig(readFileFn, startDir, stopDir) {
-  let currentDir = startDir;
-  while (true) {
-    const pkgPath = path.resolve(currentDir, "package.json");
-    const config = yield* readPackageConfig(readFileFn, pkgPath);
-    if (config) {
-      return config;
-    }
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) {
-      break;
-    }
-    if (stopDir && currentDir === stopDir) {
-      break;
-    }
-    currentDir = parentDir;
-  }
-  return {};
+	let currentDir = startDir;
+	while (true) {
+		const config = yield* readPackageConfig(readFileFn, path.resolve(currentDir, "package.json"));
+		if (config) return config;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		if (stopDir && currentDir === stopDir) break;
+		currentDir = parentDir;
+	}
+	return {};
 }
 function* readPackageConfig(readFileFn, pkgPath) {
-  try {
-    const content = yield readFileFn(pkgPath, "utf8");
-    const parsed = JSON.parse(content);
-    return parsed.gamingTs;
-  } catch {
-    return;
-  }
+	try {
+		const content = yield readFileFn(pkgPath, "utf8");
+		return JSON.parse(content).gamingTs;
+	} catch {
+		return;
+	}
 }
-
-// packages/transpiler/src/index.ts
+//#endregion
+//#region src/index.ts
 function transpile(source, filename, option) {
-  const ast = parse(source);
-  return transform(ast, option, {
-    content: source,
-    filename
-  });
+	return transform(parse(source), option, {
+		content: source,
+		filename
+	});
 }
 function transpileForVolar(source, filename, option) {
-  const ast = parseLoose(source, {
-    recordCallLParens: true
-  });
-  return transformForVolar(ast, option, {
-    content: source,
-    filename
-  });
+	return transformForVolar(parseLoose(source, { recordCallLParens: true }), option, {
+		content: source,
+		filename
+	});
 }
-export {
-  transpileForVolar,
-  transpile,
-  resolveGtsConfigSync,
-  resolveGtsConfig,
-  GtsTranspilerError
-};
+//#endregion
+export { GtsTranspilerError, resolveGtsConfig, resolveGtsConfigSync, transpile, transpileForVolar };