@gi-tcg/gts-transpiler 0.2.0 → 0.3.0

package/dist/index.js

@@ -77,7 +77,7 @@ function loosePlugin() {
           return super.parseIdent(liberal);
         }
       };
-      _proxiedThis = new Proxy(this, {
+      #proxiedThis = new Proxy(this, {
         get: (target, prop) => {
           if (prop === "parseIdent") {
             return this._patchedParseIdent;
@@ -96,7 +96,7 @@ function loosePlugin() {
         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 super.parseSubscript.call(this.#proxiedThis, base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
       }
     };
   };
@@ -137,13 +137,17 @@ function gtsPlugin(options = {}) {
       }
       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(this.start, "Expected attribute name");
+          this.raise(start, "Expected attribute name");
         }
         node.name = name;
         node.body = this.gts_parseAttributeBody();
@@ -556,6 +560,59 @@ class GtsTranspilerError extends Error {
   }
 }
 
+// packages/transpiler/src/parse/record_call_lparen_plugin.ts
+import { tokTypes as tokTypes3 } from "acorn";
+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;
+      }
+    };
+  };
+}
+
 // packages/transpiler/src/parse/index.ts
 var TsParser = Parser.extend(tsPlugin());
 function parse(input, options) {
@@ -580,10 +637,9 @@ function parse(input, options) {
 }
 function parseLoose(input, options) {
   try {
-    const GtsParser = TsParser.extend(loosePlugin(), gtsPlugin({
-      ...options,
-      allowEmptyShortcutMember: true,
-      allowEmptyPositionalAttribute: true
+    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, {
@@ -802,7 +858,7 @@ var commonGtsVisitor = {
           kind: "init",
           method: false,
           shorthand: false,
-          value: state.ActionId,
+          value: state.ActionLit,
           loc: node.loc
         },
         {
@@ -908,14 +964,10 @@ var gtsVisitor = {
     const body = [];
     for (const stmt of node.body) {
       const visited = visit(stmt);
-      if (visited.type !== "EmptyStatement") {
-        body.push(visited);
-      }
-      if (state.pendingStatements.length > 0) {
-        body.push(...state.pendingStatements);
-        state.pendingStatements = [];
-      }
+      body.push(visited);
     }
+    body.unshift(...state.bindingStatements);
+    state.bindingStatements = [];
     if (state.hasQueryExpressions) {
       body.unshift({
         type: "ImportDeclaration",
@@ -944,16 +996,6 @@ var gtsVisitor = {
           type: "ImportSpecifier",
           imported: { type: "Identifier", name: "createBinding" },
           local: state.createBindingFnId
-        },
-        {
-          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 },
@@ -990,8 +1032,7 @@ var gtsVisitor = {
     };
     const newBindings = state.externalizedBindings;
     state.externalizedBindings = [];
-    const statements = [];
-    statements.push({
+    state.bindingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
       declarations: [
@@ -1003,7 +1044,7 @@ var gtsVisitor = {
       ],
       loc: node.loc
     });
-    statements.push({
+    state.bindingStatements.push({
       type: "VariableDeclaration",
       kind: "const",
       declarations: [
@@ -1040,31 +1081,26 @@ var gtsVisitor = {
         ]
       };
       if (binding.export) {
-        statements.push({
+        state.bindingStatements.push({
           type: "ExportNamedDeclaration",
           declaration: decl,
           specifiers: [],
           attributes: []
         });
       } else {
-        statements.push(decl);
+        state.bindingStatements.push(decl);
       }
     }
-    statements.push({
+    return {
       type: "ExpressionStatement",
       expression: {
         type: "CallExpression",
         optional: false,
-        callee: {
-          ...state.createDefineFnId,
-          loc: node.loc
-        },
+        callee: state.createDefineFnId,
         arguments: [state.rootVmId, nodeVarId]
       },
       loc: node.loc
-    });
-    state.pendingStatements.push(...statements);
-    return { type: "EmptyStatement" };
+    };
   },
   GTSNamedAttributeDefinition(node, { visit, state }) {
     const namedBody = visit(node.body);
@@ -1196,9 +1232,9 @@ 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 PreludeLit = {
+    type: "Literal",
+    value: "~prelude"
   };
   const shortcutFunctionParameters = [
     fnArgId,
@@ -1219,7 +1255,7 @@ var initialTranspileState = (option = {}) => {
       right: {
         type: "MemberExpression",
         object: fnArgId,
-        property: preludeSymbolId,
+        property: PreludeLit,
         computed: true,
         optional: false
       }
@@ -1242,8 +1278,8 @@ var initialTranspileState = (option = {}) => {
   return {
     createDefineFnId: { type: "Identifier", name: "__gts_createDefine" },
     createBindingFnId: { type: "Identifier", name: "__gts_createBinding" },
-    ActionId: { type: "Identifier", name: "__gts_Action" },
-    preludeSymbolId,
+    ActionLit: { type: "Literal", value: "~action" },
+    PreludeLit,
     fnArgId,
     shortcutFunctionParameters,
     rootVmId: { type: "Identifier", name: "__gts_rootVm" },
@@ -1266,7 +1302,7 @@ var initialTranspileState = (option = {}) => {
     externalizedBindings: [],
     hasQueryExpressions: false,
     defineIdCounter: 0,
-    pendingStatements: []
+    bindingStatements: []
   };
 };
 var gtsToTs = (ast, option = {}) => {
@@ -1277,7 +1313,6 @@ var gtsToTs = (ast, option = {}) => {
 // packages/transpiler/src/transform/volar/index.ts
 import { walk as walk5 } from "zimmerframe";
 import { print } from "esrap";
-import tsPrinter from "esrap/languages/ts";
 
 // packages/transpiler/src/transform/volar/replacements.ts
 var createReplacementHolder = (state, value) => {
@@ -1303,31 +1338,94 @@ var createReplacementHolder = (state, value) => {
 };
 function applyReplacements(state, code) {
   const replacementRegex = new RegExp("\\b" + state.replacementTag.name + "`(.*?)`", "gm");
-  const {
-    symbolsId: { NamedDefinition, Meta }
-  } = state;
+  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 === "enterVMFromRoot") {
-      return `type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition.name}]; type ${payload.metaType} = ${payload.defType}[${Meta.name}];`;
+    if (payload.type === "preface") {
+      return oneLine`
+        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`
+        type ${payload.defType} = (typeof ${payload.vm})[${NamedDefinition}];
+        type ${payload.metaType} = ${payload.defType}[${Meta}];
+      `;
     } 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}];`;
+      return oneLine`
+        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.additionalMappings.set(payload.errorLoc, needleString);
+        state.extraMappings.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 Collected = ${collectedAttrsExpr}; export type Expected = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}]; }; ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});`;
+      return oneLine`
+        type ${payload.finalMetaType} = ${payload.metaType};
+        let ${lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${Meta}>;
+        type ${lhs} = typeof ${lhs};
+        namespace ${requiredAttrsNs} {
+          export type Collected = ${collectedAttrsExpr};
+          export type Expected = { [K in keyof ${payload.defType}]: ${lhs}[K] extends { required(this: ${lhs}): true } ? K : never }[keyof ${payload.defType}];
+        };
+        ((_: ${requiredAttrsNs}.Expected extends ${requiredAttrsNs}.Collected ? string : ${requiredAttrsNs}.Expected) => 0)(${needleString});
+      `;
     } else if (payload.type === "enterAttr") {
-      return `const ${payload.lhs}: { [${Meta.name}]: ${payload.metaType} } & Omit<${payload.defType}, ${Meta.name}> = 0 as any;`;
+      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`
+        type ${uniqueKeyLhs} = {
+          ${Meta}: ${payload.metaType}; 
+          uniqueKey: ${payload.defType} extends { [${payload.attrName}]: { uniqueKey: infer UniqueKey } } ? UniqueKey : () => 0;
+        
+        let ${uniqueKeyLhs}!: ${uniqueKeyLhs};
+        let ${uniqueKey} = ${uniqueKeyLhs}.uniqueKey();
+        type ${uniqueKey} = typeof ${uniqueKey};
+        let ${uniqueKeyForThis}!: \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}${payload.lhs}\`;
+        interface ${uniqueKeyHelperIntf} {
+          [${uniqueKeyForThis}]: 1;
+        }
+        type ${omittedKeys} = ${Meta} | (
+          ${uniqueKey} extends 0
+          ? never                                                 /* no unique requirement */
+            : string extends keyof ${uniqueKeyHelperIntf}
+              ? keyof ${payload.defType}                          /* too loose, disable all */
+              : ${state.utilNsId.name}.UnionToIntersection<
+                keyof ${uniqueKeyHelperIntf} & \`\${${uniqueKey}}\${${state.utilNsId.name}.UniqueKeyProbSegment}\${string}\`
+              > extends never
+                ? ${payload.attrName}                             /* have duplicate, disable this */
+                : never
+        );
+        let ${payload.lhs}!: { ${Meta}: ${payload.metaType} } & Omit<${payload.defType}, ${omittedKeys}>;
+      `;
     } 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};`;
+      return oneLine`
+        type ${typingIdLhs} = {
+          ${Meta}: ${payload.finalMetaType};
+          as: ${payload.defType} extends { [${payload.attrName}]: { 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}`;
+      return oneLine`
+        type ${payload.returnType} = typeof ${payload.returnType};
+        type ${payload.newMetaType} = ${payload.returnType} extends { rewriteMeta: infer NewMeta extends {} } ? NewMeta : ${payload.oldMetaType}
+      `;
     } else {
       return "";
     }
@@ -1344,59 +1442,7 @@ var ANY_INIT = {
   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.typingPendingStatements.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++}`
@@ -1473,7 +1519,8 @@ var enterAttr = (state, attrName) => {
     type: "enterAttr",
     defType: defTypeId.name,
     metaType: metaTypeId.name,
-    lhs: lhsId.name
+    lhs: lhsId.name,
+    attrName
   }));
   return { lhsId };
 };
@@ -1539,8 +1586,7 @@ var gtsToTypingsWalker = {
               }
             }
           }
-        ],
-        leadingComments: extBinding.leadingComments
+        ]
       };
       if (extBinding.export) {
         body.unshift({
@@ -1548,31 +1594,18 @@ var gtsToTypingsWalker = {
           declaration: varDecl,
           specifiers: [],
           source: null,
-          attributes: []
+          attributes: [],
+          leadingComments: extBinding.leadingComments
         });
       } else {
+        varDecl.leadingComments = extBinding.leadingComments;
         body.unshift(varDecl);
       }
     }
-    if (state.prefaceInserted) {
-      body.unshift({
-        type: "ImportDeclaration",
-        specifiers: [
-          {
-            type: "ImportDefaultSpecifier",
-            local: state.rootVmId
-          }
-        ],
-        source: {
-          type: "Literal",
-          value: `${state.providerImportSource}/vm`
-        },
-        attributes: []
-      });
-    }
     if (state.hasQueryExpressions) {
       body.unshift({
         type: "ImportDeclaration",
+        diagnosticsOnTop: true,
         specifiers: [
           {
             type: "ImportDefaultSpecifier",
@@ -1586,6 +1619,23 @@ var gtsToTypingsWalker = {
         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
@@ -1600,15 +1650,18 @@ var gtsToTypingsWalker = {
   GTSNamedAttributeDefinition(node, { visit, state }) {
     const { name, body, bindingName } = node;
     const attrName = JSON.stringify(name.type === "Literal" ? String(name.value) : name.name);
+    const attributeNameToken = state.leafTokens.find((t) => t.loc === name.loc);
+    if (attributeNameToken) {
+      attributeNameToken.sourceLengthOffset = 1;
+    }
     const { lhsId } = enterAttr(state, attrName);
+    state.extraMappings.set(`${name.loc?.start.line}:${name.loc?.start.column}`, `${lhsId.name}${name.type === "Literal" ? `[` : `.`}`);
     const positionals = body.positionalAttributes.attributes.map((attr) => {
       if (attr.type === "Identifier" && /^[a-z_]/.test(attr.name)) {
         const token = state.leafTokens.find((t) => t.loc === attr.loc);
         if (token) {
-          token.locationAdjustment = {
-            startOffset: 1,
-            generatedLength: attr.name.length + 2
-          };
+          token.generatedStartOffset = 1;
+          token.generatedLength = attr.name.length + 2;
         }
         return {
           type: "Literal",
@@ -1684,7 +1737,11 @@ var gtsToTypingsWalker = {
       visit(attr);
     }
     if (node.directAction) {
-      const { lhsId } = enterAttr(state, state.ActionId.name);
+      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,
@@ -1711,7 +1768,7 @@ var gtsToTypingsWalker = {
               callee: {
                 type: "MemberExpression",
                 object: lhsId,
-                property: state.ActionId,
+                property: state.ActionLit,
                 computed: true,
                 optional: false
               },
@@ -1810,8 +1867,7 @@ function buildSrcToGenMap(source_map, line_offsets, generated_code) {
 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];
+  return positions || [];
 }
 function createLineOffsets(content) {
   const lines = content.split(`
@@ -1828,39 +1884,41 @@ 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) {
+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;
-    const genLineCol = getGeneratedPosition(token.loc.start.line, token.loc.start.column, srcToGenMap);
+    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.locationAdjustment) {
+    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: [token.locationAdjustment.generatedLength],
+        generatedLengths: [generatedLength],
         data: {
           verification: true
         }
       });
-      genStart += token.locationAdjustment.startOffset;
+      genStart += token.generatedStartOffset;
     }
-    if (token.isDummy) {
-      while (sourceStart > 0 && /\s/.test(source[sourceStart - 1])) {
-        sourceStart--;
-        sourceLength++;
-      }
-    }
-    const generatedLength = token.generatedLength ?? sourceLength;
     mappings.push({
       sourceOffsets: [sourceStart],
       generatedOffsets: [genStart],
@@ -1869,7 +1927,20 @@ function convertToVolarMappings(generated, source, sourceMap, tokens, additional
       data: DEFAULT_VOLAR_MAPPING_DATA
     });
   }
-  for (const [loc, codeSnippet] of additionalMappings) {
+  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;
@@ -1912,26 +1983,138 @@ function isLeafNode(node) {
   return true;
 }
 function collectLeafTokens(ast) {
-  const tokens = [];
-  walk4(ast, tokens, {
-    _(node, { state, next }) {
+  const state = {
+    tokens: []
+  };
+  walk4(ast, state, {
+    _(node, { state: state2, next }) {
       if (isLeafNode(node) && node.loc) {
         const token = {
           loc: node.loc
         };
-        if (node.isDummy) {
+        if ("isDummy" in node && node.isDummy) {
           token.isDummy = true;
           token.sourceLength = 0;
           token.generatedLength = 1;
         }
-        state.push(token);
+        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 tokens;
+  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 = {
@@ -1939,34 +2122,20 @@ function gtsToTypings(ast, option) {
     leafTokens: option.leafTokens,
     idCounter: 0,
     typingPendingStatements: [],
-    prefaceInserted: false,
-    rootVmId: { type: "Identifier", name: "__root_vm" },
+    rootVmId: { type: "Identifier", name: "__gts_root_vm" },
+    utilNsId: { type: "Identifier", name: "__gts_util" },
     replacementTag: { type: "Identifier", name: "__gts_replacement_tag" },
-    symbolsId: {
-      Meta: { type: "Identifier", name: "__gts_symbols_meta" },
-      NamedDefinition: { type: "Identifier", name: "__gts_symbols_namedDef" }
-    },
+    MetaLit: { type: "Literal", value: "~meta" },
+    NamedDefinitionLit: { type: "Literal", value: "~namedDefinition" },
     defineLeadingComments: [],
     vmDefTypeIdStack: [],
     metaTypeIdStack: [],
     finalMetaTypeIdStack: [],
     attrsOfCurrentVm: [],
-    additionalMappings: option.additionalMappings
+    extraMappings: option.extraMappings
   };
   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, {
+  const { code, map } = print(newAst, patchedPrinter, {
     indent: "  "
   });
   return {
@@ -1976,13 +2145,13 @@ function gtsToTypings(ast, option) {
 }
 function transformForVolar(ast, option, sourceInfo) {
   const tokens = collectLeafTokens(ast);
-  const additionalMappings = new Map;
+  const extraMappings = new Map;
   const { code, sourceMap } = gtsToTypings(ast, {
     ...option,
     leafTokens: tokens,
-    additionalMappings
+    extraMappings
   });
-  const volarMappings = convertToVolarMappings(code, sourceInfo.content, sourceMap, tokens, additionalMappings);
+  const volarMappings = convertToVolarMappings(code, sourceInfo.content, sourceMap, tokens, extraMappings);
   return {
     code,
     mappings: volarMappings
@@ -2004,7 +2173,77 @@ function transform(ast, option = {}, sourceInfo = {}) {
   };
 }
 // packages/transpiler/src/config.ts
-import path from "node:path";
+var path = globalThis.require ? globalThis.require("node:path") : {
+  isAbsolute(filePath) {
+    return filePath.startsWith("/");
+  },
+  dirname(filePath) {
+    if (!filePath) {
+      return ".";
+    }
+    const normalized = normalizeSlashes(filePath);
+    if (normalized === "/") {
+      return "/";
+    }
+    const trimmed = normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    const idx = trimmed.lastIndexOf("/");
+    if (idx < 0) {
+      return ".";
+    }
+    if (idx === 0) {
+      return "/";
+    }
+    return trimmed.slice(0, idx);
+  },
+  resolve(...segments) {
+    if (segments.length === 0) {
+      return ".";
+    }
+    let resolved = "";
+    for (let i = segments.length - 1;i >= 0; i--) {
+      const segment = segments[i];
+      if (!segment) {
+        continue;
+      }
+      if (resolved) {
+        resolved = `${segment}/${resolved}`;
+      } else {
+        resolved = segment;
+      }
+      if (path.isAbsolute(segment)) {
+        break;
+      }
+    }
+    return normalizeResolvedPath(resolved || ".");
+  }
+};
+function normalizeSlashes(filePath) {
+  return filePath.replace(/\\+/g, "/");
+}
+function normalizeResolvedPath(filePath) {
+  const normalized = normalizeSlashes(filePath);
+  const isAbsolute = normalized.startsWith("/");
+  const parts = normalized.split("/");
+  const stack = [];
+  for (const part of parts) {
+    if (!part || part === ".") {
+      continue;
+    }
+    if (part === "..") {
+      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+        stack.pop();
+      } else if (!isAbsolute) {
+        stack.push("..");
+      }
+      continue;
+    }
+    stack.push(part);
+  }
+  if (isAbsolute) {
+    return `/${stack.join("/")}` || "/";
+  }
+  return stack.join("/") || ".";
+}
 var DEFAULT_GTS_CONFIG = {
   runtimeImportSource: "@gi-tcg/gts-runtime",
   providerImportSource: "@gi-tcg/core/gts",
@@ -2060,7 +2299,7 @@ function normalizeStartDir(sourceFile, cwd) {
 function* findNearestPackageConfig(readFileFn, startDir, stopDir) {
   let currentDir = startDir;
   while (true) {
-    const pkgPath = path.join(currentDir, "package.json");
+    const pkgPath = path.resolve(currentDir, "package.json");
     const config = yield* readPackageConfig(readFileFn, pkgPath);
     if (config) {
       return config;
@@ -2095,7 +2334,9 @@ function transpile(source, filename, option) {
   });
 }
 function transpileForVolar(source, filename, option) {
-  const ast = parseLoose(source);
+  const ast = parseLoose(source, {
+    recordCallLParens: true
+  });
   return transformForVolar(ast, option, {
     content: source,
     filename
@@ -2106,5 +2347,6 @@ export {
   transpile,
   resolveGtsConfigSync,
   resolveGtsConfig,
+  path,
   GtsTranspilerError
 };