@gi-tcg/gts-transpiler 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,2085 @@
+// src/parse/index.ts
+import { Parser } from "acorn";
+import { tsPlugin } from "@sveltejs/acorn-typescript";
+
+// src/parse/gts_plugin.ts
+import { tokTypes as tokTypes2 } from "acorn";
+
+// 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"
+];
+
+// 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);
+      }
+    };
+  };
+}
+
+// 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();
+        let name;
+        if (this.type.label === "string") {
+          name = this.parseExprAtom();
+        } else if (this.type.label === "name") {
+          name = this.parseIdent();
+        } else {
+          this.raise(this.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.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");
+      }
+    };
+  };
+}
+
+// src/parse/comment.js
+import { walk } from "zimmerframe";
+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());
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+    }
+  };
+}
+
+// src/error.ts
+class GtsTranspilerError extends Error {
+  position;
+  constructor(message, position) {
+    super(message);
+    this.position = position;
+    this.name = "GtsTranspilerError";
+  }
+}
+
+// src/parse/index.ts
+var 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);
+    }
+  }
+}
+function parseLoose(input, options) {
+  try {
+    const GtsParser = TsParser.extend(loosePlugin(), gtsPlugin({
+      ...options,
+      allowEmptyShortcutMember: true,
+      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);
+    }
+  }
+}
+
+// src/transform/erase_ts.ts
+import { walk as walk2 } from "zimmerframe";
+var empty = {
+  type: "EmptyStatement"
+};
+function removeThisParameter(node, context) {
+  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);
+};
+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;
+  }
+};
+var eraseTs = (ast) => {
+  return walk2(ast, null, eraseTsVisitor);
+};
+
+// src/transform/index.ts
+import { print as print2 } from "esrap";
+import jsPrinter from "esrap/languages/ts";
+
+// src/transform/gts.ts
+import { walk as walk3 } from "zimmerframe";
+
+// src/transform/constants.ts
+var DEFAULT_SHORTCUT_FUNCTION_PRELUDES = [
+  "cryo",
+  "hydro",
+  "pyro",
+  "electro",
+  "anemo",
+  "geo",
+  "dendro",
+  "omni"
+];
+var DEFAULT_QUERY_BINDINGS = ["my", "opp"];
+
+// src/transform/gts.ts
+var commonGtsVisitor = {
+  GTSDirectFunction(node, { visit, state }) {
+    return {
+      type: "ArrowFunctionExpression",
+      params: [],
+      body: {
+        type: "ObjectExpression",
+        properties: [
+          {
+            type: "Property",
+            key: { type: "Identifier", name: "name" },
+            computed: false,
+            kind: "init",
+            method: false,
+            shorthand: false,
+            value: state.ActionId,
+            loc: node.loc
+          },
+          {
+            type: "Property",
+            key: { type: "Identifier", name: "positionals" },
+            computed: false,
+            kind: "init",
+            method: false,
+            shorthand: false,
+            value: {
+              type: "ArrayExpression",
+              elements: [
+                {
+                  type: "ArrowFunctionExpression",
+                  params: state.shortcutFunctionParameters,
+                  body: {
+                    type: "BlockStatement",
+                    body: node.body.map((stmt) => visit(stmt))
+                  },
+                  expression: false
+                }
+              ]
+            }
+          },
+          {
+            type: "Property",
+            key: { type: "Identifier", name: "named" },
+            computed: false,
+            kind: "init",
+            method: false,
+            shorthand: false,
+            value: {
+              type: "Literal",
+              value: null
+            }
+          }
+        ]
+      },
+      expression: true,
+      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
+              }
+            }
+          ]
+        }
+      ]
+    };
+  }
+};
+var gtsVisitor = {
+  Program(node, { state, next }) {
+    node = next() ?? node;
+    const body = [...node.body];
+    if (state.externalizedBindings.length > 0) {
+      body.unshift({
+        type: "ImportDeclaration",
+        specifiers: [
+          {
+            type: "ImportDefaultSpecifier",
+            local: state.binderFnId
+          }
+        ],
+        source: {
+          type: "Literal",
+          value: `${state.providerImportSource}/binder`
+        },
+        attributes: []
+      }, ...state.externalizedBindings.flatMap((binding) => {
+        const internalDecl = {
+          type: "VariableDeclaration",
+          kind: "const",
+          declarations: [
+            {
+              type: "VariableDeclarator",
+              id: binding.internalId,
+              init: binding.value
+            }
+          ]
+        };
+        const externalDecl = {
+          type: "VariableDeclaration",
+          kind: "const",
+          declarations: [
+            {
+              type: "VariableDeclarator",
+              id: binding.bindingName,
+              init: {
+                type: "CallExpression",
+                optional: false,
+                callee: state.binderFnId,
+                arguments: [
+                  binding.internalId,
+                  {
+                    type: "ObjectExpression",
+                    properties: [
+                      {
+                        type: "Property",
+                        key: { type: "Identifier", name: "path" },
+                        computed: false,
+                        kind: "init",
+                        method: false,
+                        shorthand: false,
+                        value: {
+                          type: "ArrayExpression",
+                          elements: binding.path.map((segment) => ({
+                            type: "Literal",
+                            value: segment
+                          }))
+                        }
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          ]
+        };
+        return binding.export ? [
+          internalDecl,
+          {
+            type: "ExportNamedDeclaration",
+            declaration: externalDecl,
+            specifiers: [],
+            attributes: []
+          }
+        ] : [internalDecl, externalDecl];
+      }));
+    }
+    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: "Action" },
+          local: state.ActionId
+        },
+        {
+          type: "ImportSpecifier",
+          imported: { type: "Identifier", name: "Prelude" },
+          local: state.preludeSymbolId
+        }
+      ],
+      source: { type: "Literal", value: state.runtimeImportSource },
+      attributes: []
+    });
+    return {
+      ...node,
+      body
+    };
+  },
+  GTSDefineStatement(node, { state, visit }) {
+    const body = visit(node.body);
+    const wrapper = {
+      type: "ObjectExpression",
+      properties: [
+        {
+          type: "Property",
+          key: { type: "Identifier", name: "attributes" },
+          computed: false,
+          kind: "init",
+          method: false,
+          shorthand: false,
+          value: {
+            type: "ArrayExpression",
+            elements: [body]
+          }
+        }
+      ]
+    };
+    return {
+      type: "ExpressionStatement",
+      expression: {
+        type: "CallExpression",
+        optional: false,
+        callee: {
+          ...state.createDefineFnId,
+          loc: node.loc
+        },
+        arguments: [state.rootVmId, wrapper]
+      },
+      loc: node.loc
+    };
+  },
+  GTSNamedAttributeDefinition(node, { visit, state }) {
+    state.attributeNames.push(node.name);
+    const namedBody = visit(node.body);
+    state.attributeNames.pop();
+    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 };
+    const arrow = {
+      type: "ArrowFunctionExpression",
+      params: [],
+      expression: true,
+      body,
+      loc: node.loc
+    };
+    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";
+      const internalId = {
+        type: "Identifier",
+        name: `__gts_internal_binding_${state.externalizedBindings.length}`
+      };
+      state.externalizedBindings.push({
+        bindingName: node.bindingName,
+        export: export_,
+        internalId,
+        value: arrow,
+        path: [...state.attributeNames, node.name].map((n) => {
+          if (n.type === "Literal") {
+            return String(n.value);
+          } else {
+            return n.name;
+          }
+        })
+      });
+      return internalId;
+    } else {
+      return arrow;
+    }
+  },
+  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: positionals,
+          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
+};
+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 preludeSymbolId = {
+    type: "Identifier",
+    name: "__gts_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: preludeSymbolId,
+        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" },
+    ActionId: { type: "Identifier", name: "__gts_Action" },
+    preludeSymbolId,
+    fnArgId,
+    shortcutFunctionParameters,
+    rootVmId: { type: "Identifier", name: "__gts_rootVm" },
+    binderFnId: { type: "Identifier", name: "__gts_Binder" },
+    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 }
+      }))
+    },
+    attributeNames: [],
+    externalizedBindings: [],
+    hasQueryExpressions: false
+  };
+};
+var gtsToTs = (ast, option = {}) => {
+  const state = initialTranspileState(option);
+  return walk3(ast, state, gtsVisitor);
+};
+
+// src/transform/volar/index.ts
+import { walk as walk5 } from "zimmerframe";
+import { print } from "esrap";
+import tsPrinter from "esrap/languages/ts";
+
+// 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
+          }
+        ]
+      }
+    }
+  };
+};
+function applyReplacements(state, code) {
+  const replacementRegex = new RegExp("\\b" + state.replacementTag.name + "`(.*?)`", "gm");
+  const {
+    symbolsId: { NamedDefinition, Meta }
+  } = state;
+  return code.replace(replacementRegex, (_, rawPayload) => {
+    const payload = JSON.parse(rawPayload);
+    if (payload.type === "enterVMFromRoot") {
+      return `type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition.name}]; type ${payload.metaType} = ${payload.defType}[${Meta.name}];`;
+    } else if (payload.type === "enterVMFromAttr") {
+      return `type ${payload.defType} = ${payload.returnType} extends { namedDefinition: infer Def } ? Def : { [${Meta.name}]: unknown }; type ${payload.metaType} = ${payload.defType}[${Meta.name}];`;
+    } else if (payload.type === "exitVM") {
+      const lhs = `${payload.finalMetaType}_lhs`;
+      const requiredAttrsNs = `${payload.finalMetaType}_rans`;
+      const collectedAttrsExpr = `${payload.collectedAttrs.join(" | ")}`;
+      const needleString = `null! as ${requiredAttrsNs}.RequiredAttributes`;
+      if (payload.errorLoc) {
+        state.additionalMappings.set(payload.errorLoc, needleString);
+      }
+      return `type ${payload.finalMetaType} = ${payload.metaType}; const ${lhs}: { [${Meta.name}]: ${payload.metaType} } & Omit<${payload.defType}, ${Meta.name}> = 0 as any; type ${lhs} = typeof ${lhs}; namespace ${requiredAttrsNs} { export type CollectedAttributes = ${collectedAttrsExpr}; export type RequiredAttributes = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}]; }; ((_: ${requiredAttrsNs}.CollectedAttributes) => 0)(${needleString});`;
+    } else if (payload.type === "enterAttr") {
+      return `const ${payload.lhs}: { [${Meta.name}]: ${payload.metaType} } & Omit<${payload.defType}, ${Meta.name}> = 0 as any;`;
+    } else if (payload.type === "createBindingTyping") {
+      const typingIdLhs = `${payload.typingId}_lhs`;
+      return `type ${typingIdLhs} = { [${Meta.name}]: ${payload.finalMetaType}; as: ${payload.defType}[${payload.attrName}] extends { as: infer As } ? As : unknown }; let ${typingIdLhs}!: ${typingIdLhs}; let ${payload.typingId} = ${typingIdLhs}.as(); type ${payload.typingId} = typeof ${payload.typingId};`;
+    } else if (payload.type === "exitAttr") {
+      return `type ${payload.returnType} = typeof ${payload.returnType}; type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}`;
+    } else {
+      return "";
+    }
+  });
+}
+
+// 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
+};
+var emitPreface = (state) => {
+  if (state.prefaceInserted) {
+    return;
+  }
+  const symbolsLhs = {
+    type: "TSQualifiedName",
+    left: { type: "Identifier", name: state.rootVmId.name },
+    right: { type: "Identifier", name: "_symbols" }
+  };
+  for (const symbolName of [
+    "Meta",
+    "Action",
+    "NamedDefinition",
+    "Prelude"
+  ]) {
+    const init = {
+      type: "TSTypeQuery",
+      exprName: {
+        type: "TSQualifiedName",
+        left: symbolsLhs,
+        right: { type: "Identifier", name: symbolName }
+      }
+    };
+    const symbolId = symbolName === "Action" ? state.ActionId : symbolName === "Prelude" ? state.preludeSymbolId : state.symbolsId[symbolName];
+    state.pendingStatements.push({
+      type: "TSTypeAliasDeclaration",
+      id: symbolId,
+      typeAnnotation: init
+    }, {
+      type: "VariableDeclaration",
+      kind: "const",
+      declarations: [
+        {
+          type: "VariableDeclarator",
+          id: {
+            ...symbolId,
+            typeAnnotation: {
+              type: "TSTypeAnnotation",
+              typeAnnotation: {
+                type: "TSTypeReference",
+                typeName: symbolId
+              }
+            }
+          },
+          init: ANY_INIT
+        }
+      ]
+    });
+  }
+  state.prefaceInserted = true;
+};
+var enterVMFromRoot = (state) => {
+  emitPreface(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.pendingStatements.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.pendingStatements.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.pendingStatements.push(createReplacementHolder(state, {
+    type: "exitVM",
+    metaType: currentMetaId.name,
+    defType: currentDefTypeId.name,
+    finalMetaType: finalMetaId.name,
+    collectedAttrs: collectedAttrNames,
+    errorLoc
+  }));
+};
+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.pendingStatements.push(createReplacementHolder(state, {
+    type: "enterAttr",
+    defType: defTypeId.name,
+    metaType: metaTypeId.name,
+    lhs: lhsId.name
+  }));
+  return { lhsId };
+};
+var genBindingTyping = (state, info) => {
+  const finalMetaId = state.finalMetaTypeIdStack.at(-1);
+  const defTypeId = state.vmDefTypeIdStack.at(-1);
+  if (!finalMetaId || !defTypeId) {
+    return;
+  }
+  state.pendingStatements.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.pendingStatements.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.pendingStatements);
+        state.pendingStatements = [];
+      } else {
+        body.push(visit(stmt));
+      }
+    }
+    if (state.externalizedBindings.length > 0) {
+      body.unshift({
+        type: "ImportDeclaration",
+        specifiers: [
+          {
+            type: "ImportDefaultSpecifier",
+            local: state.binderFnId
+          }
+        ],
+        source: {
+          type: "Literal",
+          value: `${state.providerImportSource}/binder`
+        },
+        attributes: []
+      }, ...state.externalizedBindings.flatMap((binding) => {
+        const internalDecl = {
+          type: "VariableDeclaration",
+          kind: "const",
+          declarations: [
+            {
+              type: "VariableDeclarator",
+              id: binding.internalId,
+              init: binding.value
+            }
+          ]
+        };
+        const externalDecl = {
+          type: "VariableDeclaration",
+          kind: "const",
+          declarations: [
+            {
+              type: "VariableDeclarator",
+              id: binding.bindingName,
+              init: {
+                type: "CallExpression",
+                optional: false,
+                callee: state.binderFnId,
+                arguments: [
+                  binding.internalId,
+                  {
+                    type: "ObjectExpression",
+                    properties: [
+                      {
+                        type: "Property",
+                        key: { type: "Identifier", name: "path" },
+                        computed: false,
+                        kind: "init",
+                        method: false,
+                        shorthand: false,
+                        value: {
+                          type: "ArrayExpression",
+                          elements: binding.path.map((segment) => ({
+                            type: "Literal",
+                            value: segment
+                          }))
+                        }
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          ]
+        };
+        return binding.export ? [
+          internalDecl,
+          {
+            type: "ExportNamedDeclaration",
+            declaration: externalDecl,
+            specifiers: [],
+            attributes: [],
+            leadingComments: binding.leadingComments
+          }
+        ] : [
+          internalDecl,
+          {
+            ...externalDecl,
+            leadingComments: binding.leadingComments
+          }
+        ];
+      }));
+    }
+    if (state.prefaceInserted) {
+      body.unshift({
+        type: "ImportDeclaration",
+        specifiers: [
+          {
+            type: "ImportDefaultSpecifier",
+            local: state.rootVmId
+          }
+        ],
+        source: {
+          type: "Literal",
+          value: `${state.providerImportSource}/rootVM`
+        },
+        attributes: []
+      });
+    }
+    if (state.hasQueryExpressions) {
+      body.unshift({
+        type: "ImportDeclaration",
+        specifiers: [
+          {
+            type: "ImportDefaultSpecifier",
+            local: state.queryFnId
+          }
+        ],
+        source: {
+          type: "Literal",
+          value: `${state.providerImportSource}/query`
+        },
+        attributes: []
+      });
+    }
+    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 token = state.leafTokens.find((t) => t.loc === attr.loc);
+        if (token) {
+          token.locationAdjustment = {
+            startOffset: 1,
+            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.pendingStatements.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 internalId = {
+        type: "Identifier",
+        name: `__gts_internal_binding_${state.externalizedBindings.length}`
+      };
+      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_,
+        internalId,
+        value: { type: "Literal", value: null },
+        path: [...state.attributeNames, node.name].map((n) => {
+          if (n.type === "Literal") {
+            return String(n.value);
+          } else {
+            return n.name;
+          }
+        }),
+        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 { lhsId } = enterAttr(state, state.ActionId.name);
+      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.pendingStatements.push({
+        type: "VariableDeclaration",
+        kind: "const",
+        declarations: [
+          {
+            type: "VariableDeclarator",
+            id: returnValue,
+            init: {
+              type: "CallExpression",
+              optional: false,
+              callee: {
+                type: "MemberExpression",
+                object: lhsId,
+                property: state.ActionId,
+                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)
+    };
+  }
+};
+
+// 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
+};
+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);
+  if (!positions || positions.length === 0) {}
+  return positions?.[0];
+}
+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, additionalMappings) {
+  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);
+    const sourceEnd = locToOffset(token.loc.end.line, token.loc.end.column, sourceLineOffsets);
+    let sourceLength = token.sourceLength ?? sourceEnd - sourceStart;
+    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.locationAdjustment) {
+      mappings.push({
+        sourceOffsets: [sourceStart],
+        generatedOffsets: [genStart],
+        lengths: [0],
+        generatedLengths: [token.locationAdjustment.generatedLength],
+        data: {
+          verification: true
+        }
+      });
+      genStart += token.locationAdjustment.startOffset;
+    }
+    if (token.isDummy) {
+      while (sourceStart > 0 && /\s/.test(source[sourceStart - 1])) {
+        sourceStart--;
+        sourceLength++;
+      }
+    }
+    const generatedLength = token.generatedLength ?? sourceLength;
+    mappings.push({
+      sourceOffsets: [sourceStart],
+      generatedOffsets: [genStart],
+      lengths: [sourceLength],
+      generatedLengths: [generatedLength],
+      data: DEFAULT_VOLAR_MAPPING_DATA
+    });
+  }
+  for (const [loc, codeSnippet] of additionalMappings) {
+    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;
+}
+
+// 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 tokens = [];
+  walk4(ast, tokens, {
+    _(node, { state, next }) {
+      if (isLeafNode(node) && node.loc) {
+        const token = {
+          loc: node.loc
+        };
+        if (node.isDummy) {
+          token.isDummy = true;
+          token.sourceLength = 0;
+          token.generatedLength = 1;
+        }
+        state.push(token);
+      }
+      next();
+    }
+  });
+  return tokens;
+}
+
+// src/transform/volar/index.ts
+function gtsToTypings(ast, option) {
+  const state = {
+    ...initialTranspileState(option),
+    leafTokens: option.leafTokens,
+    idCounter: 0,
+    pendingStatements: [],
+    prefaceInserted: false,
+    rootVmId: { type: "Identifier", name: "__root_vm" },
+    replacementTag: { type: "Identifier", name: "__gts_replacement_tag" },
+    symbolsId: {
+      Meta: { type: "Identifier", name: "__gts_symbols_meta" },
+      NamedDefinition: { type: "Identifier", name: "__gts_symbols_namedDef" }
+    },
+    vmDefTypeIdStack: [],
+    metaTypeIdStack: [],
+    finalMetaTypeIdStack: [],
+    attrsOfCurrentVm: [],
+    additionalMappings: option.additionalMappings
+  };
+  const newAst = walk5(ast, state, gtsToTypingsWalker);
+  const printer = tsPrinter({
+    getLeadingComments: (node) => node.leadingComments,
+    getTrailingComments: (node) => node.trailingComments
+  });
+  const prevIdentifier = printer.Identifier;
+  printer.Identifier = function(node, context) {
+    if (node.isDummy) {
+      context.write("", node);
+    } else {
+      prevIdentifier(node, context);
+    }
+  };
+  const { code, map } = print(newAst, printer, {
+    indent: "  "
+  });
+  return {
+    code: applyReplacements(state, code),
+    sourceMap: map
+  };
+}
+function transformForVolar(ast, option, sourceInfo) {
+  const tokens = collectLeafTokens(ast);
+  const additionalMappings = new Map;
+  const { code, sourceMap } = gtsToTypings(ast, {
+    ...option,
+    leafTokens: tokens,
+    additionalMappings
+  });
+  const volarMappings = convertToVolarMappings(code, sourceInfo.content, sourceMap, tokens, additionalMappings);
+  return {
+    code,
+    mappings: volarMappings
+  };
+}
+
+// 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
+  };
+}
+
+// src/index.ts
+function transpile(source, filename, option) {
+  const ast = parse(source);
+  return transform(ast, option, {
+    content: source,
+    filename
+  });
+}
+function transpileForVolar(source, filename, option) {
+  const ast = parseLoose(source);
+  return transformForVolar(ast, option, {
+    content: source,
+    filename
+  });
+}
+export {
+  transpileForVolar,
+  transpile,
+  GtsTranspilerError
+};