@nudojs/parser 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { File, Node } from '@babel/types';
-import { TypeValue, MockHelper } from '@nudojs/core';
+import { Abs, MockHelper } from '@nudojs/core';
 export { stripTypes } from '@nudojs/core';
 
 /**
@@ -18,8 +18,10 @@ declare function parse(source: string, opts?: {
 type CaseDirective = {
     kind: "case";
     name: string;
-    args: TypeValue[];
-    expected?: TypeValue;
+    /** 无损参数 Abs（case 文法唯一真理源；约束表达式与 T.* 均产出） */
+    argsAbs: Abs[];
+    /** `=> expected` 断言 Abs */
+    expected?: Abs;
     commentLine?: number;
 };
 type MockDirective = {
@@ -37,16 +39,16 @@ type MockDirective = {
 };
 type SinonExpression = {
     type: "stub" | "spy" | "mock";
-    returnValue?: TypeValue;
-    resolvedValue?: TypeValue;
-    rejectedValue?: TypeValue;
+    returnValue?: Abs;
+    resolvedValue?: Abs;
+    rejectedValue?: Abs;
 };
 type PureDirective = {
     kind: "pure";
 };
 type SkipDirective = {
     kind: "skip";
-    returns?: TypeValue;
+    returns?: Abs;
 };
 type SampleDirective = {
     kind: "sample";
@@ -64,12 +66,12 @@ type MockModuleDirective = {
 };
 type AsDirective = {
     kind: "as";
-    typeExpr: TypeValue;
+    typeAbs: Abs;
 };
 type ReplaceDirective = {
     kind: "replace";
     targetSource: string;
-    typeExpr: TypeValue;
+    typeAbs: Abs;
 };
 type InlineDirective = AsDirective | ReplaceDirective;
 type FileDirective = EnvDirective | MockModuleDirective;
@@ -79,9 +81,15 @@ type FunctionWithDirectives = {
     name: string;
     directives: Directive[];
 };
-declare function parseTypeValueExpr(expr: string): TypeValue;
+/**
+ * case 实参主路径：始终产出 Abs；约束表达式优先。
+ * `T.*` 文法 **已弃用**，仅为旧 fixture 兼容保留——新代码用 `number()`/`lit()`。
+ */
+declare function parseCaseArgExpr(expr: string): Abs;
+/** @deprecated 旧名兼容；等价 parseCaseArgExpr */
+declare function parseTypeValueExpr(expr: string): Abs;
 declare function extractDirectives(ast: Node): FunctionWithDirectives[];
 declare function extractInlineDirectives(node: Node): InlineDirective[];
 declare function extractFileDirectives(ast: Node): FileDirective[];
 
-export { type AsDirective, type CaseDirective, type Directive, type EnvDirective, type FileDirective, type FunctionWithDirectives, type InlineDirective, type MockDirective, type MockModuleDirective, type PureDirective, type ReplaceDirective, type SampleDirective, type SinonExpression, type SkipDirective, extractDirectives, extractFileDirectives, extractInlineDirectives, parse, parseTypeValueExpr };
+export { type AsDirective, type CaseDirective, type Directive, type EnvDirective, type FileDirective, type FunctionWithDirectives, type InlineDirective, type MockDirective, type MockModuleDirective, type PureDirective, type ReplaceDirective, type SampleDirective, type SinonExpression, type SkipDirective, extractDirectives, extractFileDirectives, extractInlineDirectives, parse, parseCaseArgExpr, parseTypeValueExpr };

package/dist/index.js

@@ -8,98 +8,194 @@ function parse(source, opts) {
 import { stripTypes } from "@nudojs/core";
 
 // src/directives.ts
-import { T, createEnvironment, stub, spy, mock } from "@nudojs/core";
+import {
+  stub,
+  spy,
+  mock,
+  abs as makeAbs,
+  lit as termLit,
+  num,
+  str,
+  bool,
+  numLit,
+  strLit,
+  boolLit,
+  absFunction,
+  joinAbs,
+  execNudoModule,
+  isNudoConstraint,
+  constraintToEntryAbs,
+  SELF
+} from "@nudojs/core";
+function absExact(shape) {
+  return makeAbs(shape, void 0, void 0, "exact");
+}
+function absUnknown() {
+  return makeAbs({ k: "unknown" }, void 0, void 0, "partial");
+}
+function absNullLit() {
+  return makeAbs({ k: "unknown" }, termLit(null), void 0, "exact");
+}
+function absUndefLit() {
+  return makeAbs({ k: "unknown" }, termLit(void 0), void 0, "exact");
+}
+function absLit(v) {
+  if (typeof v === "number") return numLit(v);
+  if (typeof v === "string") return strLit(v);
+  if (typeof v === "boolean") return boolLit(v);
+  if (v === null) return absNullLit();
+  return absUndefLit();
+}
+function absUnion(members) {
+  if (members.length === 0) return absExact({ k: "never" });
+  return members.reduce((acc, m) => joinAbs(acc, m));
+}
 var CASE_NAME_REGEX = /@nudo:case\s+"([^"]+)"\s*\(/g;
 var MOCK_INLINE_REGEX = /@nudo:mock\s+(\w+)\s*=\s*(.+)/g;
 var MOCK_FROM_REGEX = /@nudo:mock\s+(\w+)\s+from\s+"([^"]+)"/g;
 var PURE_REGEX = /@nudo:pure\b/g;
 var SKIP_REGEX = /@nudo:skip(?:\s+(.+))?/g;
 var SAMPLE_REGEX = /@nudo:sample\s+(\d+)/g;
+var CONSTRAINT_EXPR_RE = /^(number|string|boolean|array|shape|lit|union|fn|partial|pick|omit|record|required|readonly|nonNullable|and)\s*\(/;
+function tryParseConstraint(expr) {
+  const s = expr.trim();
+  if (!CONSTRAINT_EXPR_RE.test(s)) return void 0;
+  try {
+    const src = `export const __nudo_case_arg = (${s});`;
+    const exports = execNudoModule(src);
+    const v = exports.__nudo_case_arg;
+    if (!isNudoConstraint(v)) return void 0;
+    return v;
+  } catch {
+    return void 0;
+  }
+}
+function flattenPreds(preds) {
+  const out = [];
+  const visit = (p) => {
+    if (p.op === "and") {
+      p.args.forEach(visit);
+      return;
+    }
+    out.push(p);
+  };
+  preds.forEach(visit);
+  return out;
+}
+function constraintSelfEqLit(c, selfIds) {
+  const leaves = flattenPreds(c.preds);
+  const eqs = leaves.filter((p2) => p2.op === "eq");
+  if (eqs.length !== 1) return void 0;
+  const p = eqs[0];
+  if (p.op !== "eq") return void 0;
+  const isSelf = (t) => t.op === "var" && typeof t.id === "string" && selfIds.includes(t.id);
+  const a = p.a;
+  const b = p.b;
+  if (isSelf(a) && b.op === "lit") return b.value;
+  if (isSelf(b) && a.op === "lit") return a.value;
+  return void 0;
+}
+function constraintToCaseArgAbs(c) {
+  if (c.members && c.members.length > 0) {
+    const parts = c.members.map((m) => constraintToCaseArgAbs(m));
+    if (parts.length === 1) return parts[0];
+    return { shape: { k: "sum", members: parts }, conf: "path" };
+  }
+  const selfIds = [SELF, "__arg", "__nudo_self__"];
+  const lv = constraintSelfEqLit(c, selfIds);
+  if (typeof lv === "number" && !Number.isNaN(lv)) return numLit(lv);
+  if (typeof lv === "string") return strLit(lv);
+  if (typeof lv === "boolean") return boolLit(lv);
+  return constraintToEntryAbs(c, "__arg");
+}
+function parseCaseArgExpr(expr) {
+  const constraint = tryParseConstraint(expr);
+  if (constraint) {
+    try {
+      return constraintToCaseArgAbs(constraint);
+    } catch {
+      return absUnknown();
+    }
+  }
+  return parseLegacyTypeExpr(expr);
+}
 function parseTypeValueExpr(expr) {
+  return parseCaseArgExpr(expr);
+}
+function parseLegacyTypeExpr(expr) {
   const s = expr.trim();
-  if (s === "T.number") return T.number;
-  if (s === "T.string") return T.string;
-  if (s === "T.boolean") return T.boolean;
-  if (s === "T.unknown") return T.unknown;
-  if (s === "T.never") return T.never;
-  if (s === "T.null") return T.null;
-  if (s === "T.undefined") return T.undefined;
-  if (s === "true") return T.literal(true);
-  if (s === "false") return T.literal(false);
-  if (s === "null") return T.literal(null);
-  if (s === "undefined") return T.literal(void 0);
+  if (s === "T.number") return num();
+  if (s === "T.string") return str();
+  if (s === "T.boolean") return bool();
+  if (s === "T.unknown") return absUnknown();
+  if (s === "T.never") return absExact({ k: "never" });
+  if (s === "T.null") return absNullLit();
+  if (s === "T.undefined") return absUndefLit();
+  if (s === "true") return absLit(true);
+  if (s === "false") return absLit(false);
+  if (s === "null") return absLit(null);
+  if (s === "undefined") return absLit(void 0);
   const literalMatch = s.match(/^T\.literal\((.+)\)$/);
   if (literalMatch) {
-    return T.literal(parsePrimitiveValue(literalMatch[1].trim()));
+    return absLit(parsePrimitiveValue(literalMatch[1].trim()));
   }
   if (s.startsWith("T.union(") && s.endsWith(")")) {
     const inner = s.slice("T.union(".length, -1);
     const args = splitTopLevelArgs(inner);
-    return T.union(...args.map(parseTypeValueExpr));
+    return absUnion(args.map(parseLegacyTypeExpr));
   }
   if (s.startsWith("T.array(") && s.endsWith(")")) {
     const inner = s.slice("T.array(".length, -1);
-    return T.array(parseTypeValueExpr(inner));
+    return absExact({ k: "arr", element: parseLegacyTypeExpr(inner) });
   }
   if (s.startsWith("T.tuple(") && s.endsWith(")")) {
     const inner = s.slice("T.tuple(".length, -1).trim();
     if (inner.startsWith("[") && inner.endsWith("]")) {
       const elements = splitTopLevelArgs(inner.slice(1, -1));
-      return T.tuple(elements.map(parseTypeValueExpr));
+      return absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
     }
-    return T.tuple([]);
+    return absExact({ k: "tuple", elements: [] });
   }
   if (s.startsWith("T.object(") && s.endsWith(")")) {
     const inner = s.slice("T.object(".length, -1).trim();
     if (inner.startsWith("{") && inner.endsWith("}")) {
-      const content = inner.slice(1, -1).trim();
-      if (!content) return T.object({});
-      const entries = splitTopLevelArgs(content);
-      const props = {};
-      for (const entry of entries) {
-        const colonIdx = entry.indexOf(":");
-        if (colonIdx === -1) continue;
-        const key = entry.slice(0, colonIdx).trim();
-        const val = entry.slice(colonIdx + 1).trim();
-        props[key] = parseTypeValueExpr(val);
-      }
-      return T.object(props);
+      return parseObjectLiteral(inner.slice(1, -1).trim());
     }
-    return T.object({});
+    return absExact({ k: "obj", slots: {} });
   }
   if (findTopLevelArrow(s) !== -1 || /^function\s*[\w$]*\s*\(/.test(s)) {
     const fnExpr = parseArrowFunctionExpr(s);
     if (fnExpr) {
-      const fnType = T.fn(fnExpr.params, fnExpr.body, createEnvironment());
-      fnType._paramPatterns = fnExpr.paramPatterns;
-      return fnType;
+      return absFunction(fnExpr.params, { body: fnExpr.body });
     }
   }
-  if (/^-?\d+(\.\d+)?$/.test(s)) return T.literal(Number(s));
+  if (/^-?\d+(\.\d+)?$/.test(s)) return absLit(Number(s));
   if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
-    return T.literal(s.slice(1, -1));
+    return absLit(s.slice(1, -1));
   }
   if (s.startsWith("{") && s.endsWith("}")) {
-    const content = s.slice(1, -1).trim();
-    if (!content) return T.object({});
-    const entries = splitTopLevelArgs(content);
-    const props = {};
-    for (const entry of entries) {
-      const colonIdx = findTopLevelColon(entry);
-      if (colonIdx === -1) continue;
-      const key = entry.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
-      const val = entry.slice(colonIdx + 1).trim();
-      props[key] = parseTypeValueExpr(val);
-    }
-    return T.object(props);
+    return parseObjectLiteral(s.slice(1, -1).trim());
   }
   if (s.startsWith("[") && s.endsWith("]")) {
     const content = s.slice(1, -1).trim();
-    if (!content) return T.tuple([]);
+    if (!content) return absExact({ k: "tuple", elements: [] });
     const elements = splitTopLevelArgs(content);
-    return T.tuple(elements.map(parseTypeValueExpr));
+    return absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
   }
-  return T.unknown;
+  return absUnknown();
+}
+function parseObjectLiteral(content) {
+  if (!content) return absExact({ k: "obj", slots: {} });
+  const entries = splitTopLevelArgs(content);
+  const slots = {};
+  for (const entry of entries) {
+    const colonIdx = findTopLevelColon(entry);
+    if (colonIdx === -1) continue;
+    const key = entry.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
+    const val = entry.slice(colonIdx + 1).trim();
+    slots[key] = { value: parseLegacyTypeExpr(val) };
+  }
+  return absExact({ k: "obj", slots });
 }
 function parsePrimitiveValue(s) {
   if (s === "true") return true;
@@ -189,62 +285,65 @@ function parseArrowFunctionExpr(expr) {
     return null;
   }
 }
+function parseAbsExpr(expr) {
+  return parseCaseArgExpr(expr);
+}
 function parseSinonExpr(expr) {
   const s = expr.trim();
   const stubReturnsMatch = s.match(/^sinon\.stub\(\)\.returns\((.+)\)$/);
   if (stubReturnsMatch) {
     return {
       type: "stub",
-      returnValue: parseTypeValueExpr(stubReturnsMatch[1].trim())
+      returnValue: parseAbsExpr(stubReturnsMatch[1].trim())
     };
   }
   const stubResolvesMatch = s.match(/^sinon\.stub\(\)\.resolves\((.+)\)$/);
   if (stubResolvesMatch) {
     return {
       type: "stub",
-      resolvedValue: parseTypeValueExpr(stubResolvesMatch[1].trim())
+      resolvedValue: parseAbsExpr(stubResolvesMatch[1].trim())
     };
   }
   const stubRejectsMatch = s.match(/^sinon\.stub\(\)\.rejects\((.+)\)$/);
   if (stubRejectsMatch) {
     return {
       type: "stub",
-      rejectedValue: parseTypeValueExpr(stubRejectsMatch[1].trim())
+      rejectedValue: parseAbsExpr(stubRejectsMatch[1].trim())
     };
   }
   const onFirstCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onFirstCall\(\)\.returns\((.+)\)$/);
   if (onFirstCallReturnsMatch) {
     return {
       type: "stub",
-      returnValue: parseTypeValueExpr(onFirstCallReturnsMatch[1].trim())
+      returnValue: parseAbsExpr(onFirstCallReturnsMatch[1].trim())
     };
   }
   const onSecondCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onSecondCall\(\)\.returns\((.+)\)$/);
   if (onSecondCallReturnsMatch) {
     return {
       type: "stub",
-      returnValue: parseTypeValueExpr(onSecondCallReturnsMatch[1].trim())
+      returnValue: parseAbsExpr(onSecondCallReturnsMatch[1].trim())
     };
   }
   const onThirdCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onThirdCall\(\)\.returns\((.+)\)$/);
   if (onThirdCallReturnsMatch) {
     return {
       type: "stub",
-      returnValue: parseTypeValueExpr(onThirdCallReturnsMatch[1].trim())
+      returnValue: parseAbsExpr(onThirdCallReturnsMatch[1].trim())
     };
   }
   const onCallReturnsMatch = s.match(/^sinon\.stub\(\)\.onCall\(\d+\)\.returns\((.+)\)$/);
   if (onCallReturnsMatch) {
     return {
       type: "stub",
-      returnValue: parseTypeValueExpr(onCallReturnsMatch[1].trim())
+      returnValue: parseAbsExpr(onCallReturnsMatch[1].trim())
     };
   }
   const withArgsReturnsMatch = s.match(/^sinon\.stub\(\)\.withArgs\(.+\)\.returns\((.+)\)$/);
   if (withArgsReturnsMatch) {
     return {
       type: "stub",
-      returnValue: parseTypeValueExpr(withArgsReturnsMatch[1].trim())
+      returnValue: parseAbsExpr(withArgsReturnsMatch[1].trim())
     };
   }
   const callsFakeMatch = s.match(/^sinon\.stub\(\)\.callsFake\((.+)\)$/);
@@ -253,7 +352,9 @@ function parseSinonExpr(expr) {
     if (arrowFn) {
       return {
         type: "stub",
-        returnValue: T.fn(arrowFn.params, arrowFn.body, createEnvironment())
+        returnValue: absFunction(arrowFn.params, {
+          body: arrowFn.body
+        })
       };
     }
     return { type: "stub" };
@@ -262,7 +363,7 @@ function parseSinonExpr(expr) {
   if (complexChainMatch) {
     return {
       type: "stub",
-      returnValue: parseTypeValueExpr(complexChainMatch[1].trim())
+      returnValue: parseAbsExpr(complexChainMatch[1].trim())
     };
   }
   if (s === "sinon.stub()") {
@@ -280,62 +381,64 @@ function parseNudoMockExpr(expr) {
   const s = expr.trim();
   const stubReturnsOnFirstMatch = s.match(/^stub\(\)\.returns\((.+)\)\.onFirstCall\(\)$/);
   if (stubReturnsOnFirstMatch) {
-    const helper = stub.returns(parseTypeValueExpr(stubReturnsOnFirstMatch[1].trim()));
+    const helper = stub.returns(parseAbsExpr(stubReturnsOnFirstMatch[1].trim()));
     helper.onFirstCallValue = helper.returnValue;
     return helper;
   }
   const stubReturnsOnSecondMatch = s.match(/^stub\(\)\.returns\((.+)\)\.onSecondCall\(\)$/);
   if (stubReturnsOnSecondMatch) {
-    return stub.returns(parseTypeValueExpr(stubReturnsOnSecondMatch[1].trim()));
+    return stub.returns(parseAbsExpr(stubReturnsOnSecondMatch[1].trim()));
   }
   const stubReturnsOnCallMatch = s.match(/^stub\(\)\.returns\((.+)\)\.onCall\(\d+\)$/);
   if (stubReturnsOnCallMatch) {
-    return stub.returns(parseTypeValueExpr(stubReturnsOnCallMatch[1].trim()));
+    return stub.returns(parseAbsExpr(stubReturnsOnCallMatch[1].trim()));
   }
   const stubCallsFakeMatch = s.match(/^stub\(\)\.callsFake\((.+)\)$/);
   if (stubCallsFakeMatch) {
-    const helper = { kind: "mock-helper" };
-    helper.callsFakeImpl = parseTypeValueExpr(stubCallsFakeMatch[1].trim());
-    return helper;
+    const arrowFn = parseArrowFunctionExpr(stubCallsFakeMatch[1].trim());
+    if (arrowFn) {
+      return stub.callsFake({ params: arrowFn.params, body: arrowFn.body, async: false });
+    }
+    return { kind: "mock-helper" };
   }
   const stubWithArgsMatch = s.match(/^stub\(\)\.withArgs\((.+)\)\.returns\((.+)\)$/);
   if (stubWithArgsMatch) {
-    const retVal = parseTypeValueExpr(stubWithArgsMatch[2].trim());
+    const retVal = parseAbsExpr(stubWithArgsMatch[2].trim());
     const argsStr = stubWithArgsMatch[1].trim();
-    const args = splitTopLevelArgs(argsStr).map(parseTypeValueExpr);
+    const args = splitTopLevelArgs(argsStr).map((a) => parseAbsExpr(a));
     const helper = { kind: "mock-helper" };
     helper.withArgsCases = [{ args, returnValue: retVal }];
     return helper;
   }
   const stubOnFirstReturnsMatch = s.match(/^stub\(\)\.onFirstCall\(\)\.returns\((.+)\)$/);
   if (stubOnFirstReturnsMatch) {
-    return stub.returns(parseTypeValueExpr(stubOnFirstReturnsMatch[1].trim()));
+    return stub.returns(parseAbsExpr(stubOnFirstReturnsMatch[1].trim()));
   }
   const stubOnFirstValueMatch = s.match(/^stub\(\)\.onFirstCall\(([^()]*)\)$/);
   if (stubOnFirstValueMatch && stubOnFirstValueMatch[1].trim() !== "") {
     const helper = { kind: "mock-helper" };
-    helper.onFirstCallValue = parseTypeValueExpr(stubOnFirstValueMatch[1].trim());
+    helper.onFirstCallValue = parseAbsExpr(stubOnFirstValueMatch[1].trim());
     return helper;
   }
   const spyReturnsMatch = s.match(/^spy\(\)\.returns\((.+)\)$/);
   if (spyReturnsMatch) {
-    return spy.returns(parseTypeValueExpr(spyReturnsMatch[1].trim()));
+    return spy.returns(parseAbsExpr(spyReturnsMatch[1].trim()));
   }
   const stubResolvesOnFirstMatch = s.match(/^stub\(\)\.resolves\((.+)\)\.onFirstCall\(\)$/);
   if (stubResolvesOnFirstMatch) {
-    return stub.resolves(parseTypeValueExpr(stubResolvesOnFirstMatch[1].trim()));
+    return stub.resolves(parseAbsExpr(stubResolvesOnFirstMatch[1].trim()));
   }
   const stubReturnsMatch = s.match(/^stub\(\)\.returns\((.+)\)$/);
   if (stubReturnsMatch) {
-    return stub.returns(parseTypeValueExpr(stubReturnsMatch[1].trim()));
+    return stub.returns(parseAbsExpr(stubReturnsMatch[1].trim()));
   }
   const stubResolvesMatch = s.match(/^stub\(\)\.resolves\((.+)\)$/);
   if (stubResolvesMatch) {
-    return stub.resolves(parseTypeValueExpr(stubResolvesMatch[1].trim()));
+    return stub.resolves(parseAbsExpr(stubResolvesMatch[1].trim()));
   }
   const stubRejectsMatch = s.match(/^stub\(\)\.rejects\((.+)\)$/);
   if (stubRejectsMatch) {
-    return stub.rejects(parseTypeValueExpr(stubRejectsMatch[1].trim()));
+    return stub.rejects(parseAbsExpr(stubRejectsMatch[1].trim()));
   }
   if (s === "stub()") {
     return stub();
@@ -401,14 +504,20 @@ function parseDirectivesFromComments(comments) {
       const argsStr = extractBalancedParens(text, parenStart);
       if (argsStr === null) continue;
       const cleaned = argsStr.split("\n").map((line) => line.replace(/^\s*\*\s?/, "")).join("\n");
-      const args = splitTopLevelArgs(cleaned).map(parseTypeValueExpr);
+      const argsAbs = splitTopLevelArgs(cleaned).map(parseCaseArgExpr);
       const afterParen = parenStart + argsStr.length + 2;
       const restLine = text.slice(afterParen).split("\n")[0].trim();
       const arrowMatch = restLine.match(/^=>\s*(.+)/);
-      const expected = arrowMatch ? parseTypeValueExpr(arrowMatch[1].trim()) : void 0;
+      const expected = arrowMatch ? parseCaseArgExpr(arrowMatch[1].trim()) : void 0;
       const linesBeforeMatch = text.slice(0, match.index).split("\n").length - 1;
       const commentLine = commentStartLine + linesBeforeMatch;
-      directives.push({ kind: "case", name, args, expected, commentLine });
+      directives.push({
+        kind: "case",
+        name,
+        argsAbs,
+        expected,
+        commentLine
+      });
     }
     PURE_REGEX.lastIndex = 0;
     if (PURE_REGEX.test(text)) {
@@ -420,7 +529,7 @@ function parseDirectivesFromComments(comments) {
       const returnsExpr = skipMatch[1]?.trim();
       directives.push({
         kind: "skip",
-        returns: returnsExpr ? parseTypeValueExpr(returnsExpr) : void 0
+        returns: returnsExpr ? parseAbsExpr(returnsExpr) : void 0
       });
     }
     SAMPLE_REGEX.lastIndex = 0;
@@ -470,7 +579,7 @@ function extractInlineDirectives(node) {
     const text = comment.value;
     const asMatch = text.match(AS_REGEX);
     if (asMatch) {
-      results.push({ kind: "as", typeExpr: parseTypeValueExpr(asMatch[1].trim()) });
+      results.push({ kind: "as", typeAbs: parseAbsExpr(asMatch[1].trim()) });
       continue;
     }
     const replaceMatch = text.match(REPLACE_REGEX);
@@ -483,7 +592,7 @@ function extractInlineDirectives(node) {
         results.push({
           kind: "replace",
           targetSource,
-          typeExpr: parseTypeValueExpr(typeExprStr)
+          typeAbs: parseAbsExpr(typeExprStr)
         });
       }
     }
@@ -563,6 +672,7 @@ export {
   extractFileDirectives,
   extractInlineDirectives,
   parse,
+  parseCaseArgExpr,
   parseTypeValueExpr,
   stripTypes
 };

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@nudojs/parser",
-  "version": "0.4.0",
+  "version": "0.4.2",
+  "engines": {
+    "node": ">=20"
+  },
   "description": "Babel-based parser and directive extraction for Nudo",
   "type": "module",
   "license": "MIT",
@@ -36,7 +39,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "0.4.0"
+    "@nudojs/core": "1.0.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"