@nudojs/parser 0.5.1 → 1.1.0-beta.0

package/README.md

@@ -4,15 +4,15 @@ Babel-based parser and directive extraction for [Nudo](https://github.com/nudojs
 
 ## What is Nudo?
 
-Nudo is a type inference engine for JavaScript. Instead of a separate type system, it runs your code with symbolic type values via abstract interpretation — no TypeScript, no build step.
+Nudo is a type inference engine for JavaScript. The type system is Abs (`shape × term × pred × conf`); analysis runs Abs-native via abstract interpretation — no TypeScript, no build step.
 
 ## This package
 
 `@nudojs/parser` handles source code parsing and Nudo directive extraction:
 
 - **Parsing** — wraps Babel parser for JavaScript/TypeScript source files
-- **Directives** — extracts `@nudo:case`, `@nudo:mock`, `@nudo:pure`, `@nudo:skip`, `@nudo:sample`, `@nudo:env`, `@nudo:mock-module`, `@nudo:as`, and `@nudo:replace` from comments. `@nudo:refine` / `@nudo:import` are parsed in `@nudojs/core` (`algebra/refine.ts`).
-- **Type expressions** — parses inline type value expressions used in directives
+- **Directives** — extracts `@nudo:case`, `@nudo:mock`, `@nudo:pure`, `@nudo:skip`, `@nudo:sample`, `@nudo:env`, `@nudo:mock-module`, `@nudo:as`, and `@nudo:replace` from comments. `@nudo:contract` / `@nudo:import` are parsed in `@nudojs/core` (`algebra/refine.ts`).
+- **Case arg expressions** — parses constraint builders and concrete literals used in directives
 
 ## Install
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { File, Node } from '@babel/types';
+import { File, Node, AssignmentExpression, Expression, Identifier, MemberExpression, Program, ClassBody, VariableDeclarator, ExportSpecifier, ExportDefaultSpecifier, ExportNamespaceSpecifier, Statement } from '@babel/types';
 import { Abs, MockHelper } from '@nudojs/core';
 export { stripTypes } from '@nudojs/core';
 
@@ -15,10 +15,95 @@ declare function parse(source: string, opts?: {
     errorRecovery?: boolean;
 }): File;
 
+/** File → its Program; Program → itself. Replaces `(ast as File).program ?? ast`. */
+declare function asProgram(ast: Node | File | Program | null | undefined): Program | undefined;
+/** Top-level statements of a File/Program (empty when neither). */
+declare function programBody(ast: Node | File | Program | null | undefined): Statement[];
+declare function asIdentifier(node: Node | null | undefined): Identifier | undefined;
+declare function asExpression(node: Node | null | undefined): Expression | undefined;
+declare function asAssignmentExpression(node: Node | null | undefined): AssignmentExpression | undefined;
+/** Identifier.name, else StringLiteral.value (module string export names). */
+declare function nameOrStringValue(node: Node | null | undefined): string | undefined;
+/** Identifier.name only (undefined for string export names). */
+declare function identifierName(node: Node | null | undefined): string | undefined;
+/** VariableDeclaration.declarations; empty for other nodes. */
+declare function getDeclarations(node: Node | null | undefined): VariableDeclarator[];
+/** First declarator's init (fn-binding extraction). */
+declare function getDeclaratorInit(node: Node | null | undefined): Expression | undefined;
+/** First declarator of a VariableDeclaration, narrowed to Identifier id. */
+declare function getFirstDeclaratorId(node: Node | null | undefined): Identifier | undefined;
+/** VariableDeclarator id narrowed to Identifier. */
+declare function getDeclaratorId(node: Node | null | undefined): Identifier | undefined;
+/** Inner declaration of `export default` / `export …` (undefined for other nodes). */
+declare function getExportDeclaration(node: Node | null | undefined): Node | undefined;
+/**
+ * Unwrap an export form: named/default exports yield their inner declaration
+ * with `exported: true`; any other statement is returned as-is with `exported: false`.
+ */
+declare function unwrapExport(node: Node | null | undefined): {
+    declaration: Node;
+    exported: boolean;
+};
+/** ExportNamedDeclaration.specifiers (empty for other nodes). */
+declare function getExportSpecifiers(node: Node | null | undefined): (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[];
+/** ExportSpecifier local name — Identifier only (matches `local.name`). */
+declare function exportSpecifierLocalName(spec: Node | null | undefined): string | undefined;
+/** ExportSpecifier exported name (`exported.name ?? exported.value`). */
+declare function exportSpecifierExportedName(spec: Node | null | undefined): string | number | undefined;
+/** ExpressionStatement.expression. */
+declare function getExpressionStatementExpression(node: Node | null | undefined): Expression | undefined;
+/** Function/Class declaration or expression `id?.name`. */
+declare function fnOrClassIdName(node: Node | null | undefined): string | undefined;
+/** ClassDeclaration/ClassExpression `id?.name`. */
+declare function classIdName(node: Node | null | undefined): string | undefined;
+/** `id.loc` of a named function/class (undefined when anonymous or unlocated). */
+declare function fnOrClassIdLoc(node: Node | null | undefined): Node["loc"];
+/** Non-computed member property key text (Identifier.name or StringLiteral.value). */
+declare function memberPropertyKey(member: Node | null | undefined): string | null;
+/** Identifier name of a non-computed member's object (e.g. `module` in `module.exports`). */
+declare function memberObjectName(member: Node | null | undefined): string | undefined;
+/** Identifier name of a non-computed member's property (e.g. `exports`). */
+declare function memberPropertyName(member: Node | null | undefined): string | undefined;
+/** `module.exports` / `module["exports"]` is rejected here: computed keys return false. */
+declare function isModuleExportsMember(member: Node | null | undefined): boolean;
+declare function asMemberExpression(node: Node | null | undefined): MemberExpression | undefined;
+/** Class body members; empty when node is not a class. */
+declare function getClassMembers(node: Node | null | undefined): ClassBody["body"];
+/**
+ * `key.name ?? key.value` on a class/object member key.
+ * Handles Identifier / StringLiteral / NumericLiteral and ESTree-shaped keys.
+ */
+declare function classMemberKeyName(member: Node | null | undefined): string | number | undefined;
+/** Key node of a class member (for range selection). */
+declare function classMemberKey(member: Node | null | undefined): Node | undefined;
+type InstanceMethod = {
+    name: string;
+    node: Node;
+};
+/**
+ * Instance methods of a class-like node. Accepts Babel `ClassMethod` /
+ * `TSDeclareMethod` and ESTree `MethodDefinition` (whose function lives in `value`).
+ * Skips getters/setters/constructors and static members.
+ */
+declare function classInstanceMethods(node: Node | null | undefined): InstanceMethod[];
+/** Class/TSDeclare method function node (ESTree MethodDefinition → its `value`). */
+declare function methodFunctionNode(member: Node | null | undefined): Node | undefined;
+/**
+ * Parameter display label: `name`, `...rest`, or `_`.
+ * Non-identifier rest arguments keep the historical `...undefined` string form.
+ */
+declare function paramDisplayName(param: Node | null | undefined): string;
+/** RestElement argument name, else plain Identifier name. */
+declare function paramName(param: Node | null | undefined): string | undefined;
+/** CJS/ESM default interop: callable module or `{ default }` wrapper. */
+declare function unwrapDefaultExport<T>(mod: T | {
+    default: T;
+}): T;
+
 type CaseDirective = {
     kind: "case";
     name: string;
-    /** 无损参数 Abs（case 文法唯一真理源；约束表达式与 T.* 均产出） */
+    /** 无损参数 Abs（case 文法唯一真理源：约束构建器 / 具体字面量） */
     argsAbs: Abs[];
     /** `=> expected` 断言 Abs */
     expected?: Abs;
@@ -82,14 +167,12 @@ type FunctionWithDirectives = {
     directives: Directive[];
 };
 /**
- * case 实参主路径：始终产出 Abs；约束表达式优先。
- * `T.*` 文法 **已弃用**，仅为旧 fixture 兼容保留——新代码用 `number()`/`lit()`。
+ * case 实参 / 指令类型表达式唯一文法：约束构建器优先，其余为具体字面量、
+ * 结构字面量与箭头函数。`T.*` 文法已物理删除。
  */
 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, parseCaseArgExpr, parseTypeValueExpr };
+export { type AsDirective, type CaseDirective, type Directive, type EnvDirective, type FileDirective, type FunctionWithDirectives, type InlineDirective, type InstanceMethod, type MockDirective, type MockModuleDirective, type PureDirective, type ReplaceDirective, type SampleDirective, type SinonExpression, type SkipDirective, asAssignmentExpression, asExpression, asIdentifier, asMemberExpression, asProgram, classIdName, classInstanceMethods, classMemberKey, classMemberKeyName, exportSpecifierExportedName, exportSpecifierLocalName, extractDirectives, extractFileDirectives, extractInlineDirectives, fnOrClassIdLoc, fnOrClassIdName, getClassMembers, getDeclarations, getDeclaratorId, getDeclaratorInit, getExportDeclaration, getExportSpecifiers, getExpressionStatementExpression, getFirstDeclaratorId, identifierName, isModuleExportsMember, memberObjectName, memberPropertyKey, memberPropertyName, methodFunctionNode, nameOrStringValue, paramDisplayName, paramName, parse, parseCaseArgExpr, programBody, unwrapDefaultExport, unwrapExport };

package/dist/index.js

@@ -7,6 +7,173 @@ function parse(source, opts) {
 // src/index.ts
 import { stripTypes } from "@nudojs/core";
 
+// src/ast-guards.ts
+import { isExpression } from "@babel/types";
+function asProgram(ast) {
+  if (!ast) return void 0;
+  if (ast.type === "File") return ast.program;
+  if (ast.type === "Program") return ast;
+  return void 0;
+}
+function programBody(ast) {
+  return asProgram(ast)?.body ?? [];
+}
+function asIdentifier(node) {
+  return node?.type === "Identifier" ? node : void 0;
+}
+function asExpression(node) {
+  return node && isExpression(node) ? node : void 0;
+}
+function asAssignmentExpression(node) {
+  return node?.type === "AssignmentExpression" ? node : void 0;
+}
+function nameOrStringValue(node) {
+  if (!node) return void 0;
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "StringLiteral") return node.value;
+  return void 0;
+}
+function identifierName(node) {
+  return node?.type === "Identifier" ? node.name : void 0;
+}
+function getDeclarations(node) {
+  return node?.type === "VariableDeclaration" ? node.declarations : [];
+}
+function getDeclaratorInit(node) {
+  const decl = node?.type === "VariableDeclarator" ? node : void 0;
+  return decl?.init ?? void 0;
+}
+function getFirstDeclaratorId(node) {
+  const decl = getDeclarations(node)[0];
+  return decl?.id.type === "Identifier" ? decl.id : void 0;
+}
+function getDeclaratorId(node) {
+  const decl = node?.type === "VariableDeclarator" ? node : void 0;
+  return decl?.id.type === "Identifier" ? decl.id : void 0;
+}
+function getExportDeclaration(node) {
+  if (!node) return void 0;
+  if (node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration") {
+    return node.declaration ?? void 0;
+  }
+  return void 0;
+}
+function unwrapExport(node) {
+  if (node?.type === "ExportNamedDeclaration" && node.declaration) {
+    return { declaration: node.declaration, exported: true };
+  }
+  if (node?.type === "ExportDefaultDeclaration") {
+    return { declaration: node.declaration, exported: true };
+  }
+  return { declaration: node, exported: false };
+}
+function getExportSpecifiers(node) {
+  return node?.type === "ExportNamedDeclaration" ? node.specifiers : [];
+}
+function exportSpecifierLocalName(spec) {
+  return spec?.type === "ExportSpecifier" ? identifierName(spec.local) : void 0;
+}
+function exportSpecifierExportedName(spec) {
+  if (spec?.type !== "ExportSpecifier") return void 0;
+  const exported = spec.exported;
+  return exported.type === "Identifier" ? exported.name : exported.value;
+}
+function getExpressionStatementExpression(node) {
+  return node?.type === "ExpressionStatement" ? node.expression : void 0;
+}
+function fnOrClassIdName(node) {
+  if (!node) return void 0;
+  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression" || node.type === "TSDeclareFunction") {
+    return node.id?.name;
+  }
+  return void 0;
+}
+function classIdName(node) {
+  if (!node) return void 0;
+  if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+    return node.id?.name;
+  }
+  return void 0;
+}
+function fnOrClassIdLoc(node) {
+  if (!node) return void 0;
+  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ClassDeclaration" || node.type === "ClassExpression" || node.type === "TSDeclareFunction") {
+    return node.id?.loc ?? void 0;
+  }
+  return void 0;
+}
+function memberPropertyKey(member) {
+  if (member?.type !== "MemberExpression" || member.computed) return null;
+  return nameOrStringValue(member.property) ?? null;
+}
+function memberObjectName(member) {
+  if (member?.type !== "MemberExpression") return void 0;
+  return identifierName(member.object);
+}
+function memberPropertyName(member) {
+  if (member?.type !== "MemberExpression" || member.computed) return void 0;
+  return identifierName(member.property);
+}
+function isModuleExportsMember(member) {
+  return memberObjectName(member) === "module" && memberPropertyName(member) === "exports";
+}
+function asMemberExpression(node) {
+  return node?.type === "MemberExpression" ? node : void 0;
+}
+function getClassMembers(node) {
+  if (node?.type === "ClassDeclaration" || node?.type === "ClassExpression") {
+    return node.body.body;
+  }
+  return [];
+}
+function classMemberKeyName(member) {
+  const key = member?.key;
+  return key?.name ?? key?.value;
+}
+function classMemberKey(member) {
+  return member?.key ?? void 0;
+}
+function classInstanceMethods(node) {
+  const out = [];
+  for (const raw of getClassMembers(node)) {
+    const m = raw;
+    const isMethod = m.type === "MethodDefinition" || m.type === "ClassMethod" || m.type === "TSDeclareMethod";
+    if (!isMethod) continue;
+    if (m.kind && m.kind !== "method") continue;
+    if (m.static) continue;
+    const keyName = m.key?.type === "Identifier" ? m.key.name : void 0;
+    if (!keyName) continue;
+    const methodNode = m.type === "MethodDefinition" ? m.value ?? void 0 : raw;
+    if (!methodNode) continue;
+    out.push({ name: keyName, node: methodNode });
+  }
+  return out;
+}
+function methodFunctionNode(member) {
+  const m = member;
+  if (!m) return void 0;
+  return m.type === "MethodDefinition" ? m.value ?? void 0 : member;
+}
+function paramDisplayName(param) {
+  if (!param) return "_";
+  if (param.type === "Identifier") return param.name;
+  if (param.type === "RestElement") {
+    const arg = param.argument;
+    return `...${arg.name}`;
+  }
+  return "_";
+}
+function paramName(param) {
+  if (!param) return void 0;
+  if (param.type === "Identifier") return param.name;
+  if (param.type === "RestElement") return identifierName(param.argument);
+  return void 0;
+}
+function unwrapDefaultExport(mod) {
+  if (typeof mod === "function") return mod;
+  return mod.default;
+}
+
 // src/directives.ts
 import {
   stub,
@@ -14,9 +181,6 @@ import {
   mock,
   abs as makeAbs,
   lit as termLit,
-  num,
-  str,
-  bool,
   numLit,
   strLit,
   boolLit,
@@ -46,17 +210,13 @@ function absLit(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*\(/;
+var CONSTRAINT_EXPR_RE = /^(number|string|boolean|any|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;
@@ -85,15 +245,15 @@ function flattenPreds(preds) {
 function constraintSelfEqLit(c, selfIds) {
   const leaves = flattenPreds(c.preds);
   const eqs = leaves.filter((p2) => p2.op === "eq");
-  if (eqs.length !== 1) return void 0;
+  if (eqs.length !== 1) return { found: false };
   const p = eqs[0];
-  if (p.op !== "eq") return void 0;
+  if (p.op !== "eq") return { found: false };
   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;
+  if (isSelf(a) && b.op === "lit") return { found: true, value: b.value };
+  if (isSelf(b) && a.op === "lit") return { found: true, value: a.value };
+  return { found: false };
 }
 function constraintToCaseArgAbs(c) {
   if (c.members && c.members.length > 0) {
@@ -102,10 +262,32 @@ function constraintToCaseArgAbs(c) {
     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);
+  const litRes = constraintSelfEqLit(c, selfIds);
+  if (litRes.found) {
+    const lv = litRes.value;
+    if (typeof lv === "number" && !Number.isNaN(lv)) return numLit(lv);
+    if (typeof lv === "string") return strLit(lv);
+    if (typeof lv === "boolean") return boolLit(lv);
+    if (lv === null) return absNullLit();
+    return absUndefLit();
+  }
+  if (c.element) {
+    return absExact({ k: "arr", element: constraintToCaseArgAbs(c.element) });
+  }
+  if (c.fields) {
+    const slots = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      slots[key] = { value: constraintToCaseArgAbs(field.constraint) };
+    }
+    return absExact({ k: "obj", slots });
+  }
+  const bareScalar = !c.fields && !c.element && !c.members && !c.fn && c.int !== true && c.preds.length === 0;
+  if (bareScalar) {
+    if (c.prim === "number" || c.prim === "string" || c.prim === "boolean") {
+      return absExact({ k: "prim", type: c.prim });
+    }
+    if (!c.prim) return absUnknown();
+  }
   return constraintToEntryAbs(c, "__arg");
 }
 function parseCaseArgExpr(expr) {
@@ -117,52 +299,16 @@ function parseCaseArgExpr(expr) {
       return absUnknown();
     }
   }
-  return parseLegacyTypeExpr(expr);
-}
-function parseTypeValueExpr(expr) {
-  return parseCaseArgExpr(expr);
+  return parseLiteralOrStructure(expr);
 }
-function parseLegacyTypeExpr(expr) {
+function parseLiteralOrStructure(expr) {
   const s = expr.trim();
-  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 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 absUnion(args.map(parseLegacyTypeExpr));
-  }
-  if (s.startsWith("T.array(") && s.endsWith(")")) {
-    const inner = s.slice("T.array(".length, -1);
-    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 absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
-    }
-    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("}")) {
-      return parseObjectLiteral(inner.slice(1, -1).trim());
-    }
-    return absExact({ k: "obj", slots: {} });
-  }
+  if (s === "unknown" || s === "any") return absUnknown();
+  if (s === "never") return absExact({ k: "never" });
   if (findTopLevelArrow(s) !== -1 || /^function\s*[\w$]*\s*\(/.test(s)) {
     const fnExpr = parseArrowFunctionExpr(s);
     if (fnExpr) {
@@ -180,7 +326,7 @@ function parseLegacyTypeExpr(expr) {
     const content = s.slice(1, -1).trim();
     if (!content) return absExact({ k: "tuple", elements: [] });
     const elements = splitTopLevelArgs(content);
-    return absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
+    return absExact({ k: "tuple", elements: elements.map((e) => parseCaseArgExpr(e)) });
   }
   return absUnknown();
 }
@@ -193,21 +339,10 @@ function parseObjectLiteral(content) {
     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) };
+    slots[key] = { value: parseCaseArgExpr(val) };
   }
   return absExact({ k: "obj", slots });
 }
-function parsePrimitiveValue(s) {
-  if (s === "true") return true;
-  if (s === "false") return false;
-  if (s === "null") return null;
-  if (s === "undefined") return void 0;
-  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
-  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
 function splitTopLevelArgs(s) {
   const result = [];
   let depth = 0;
@@ -622,7 +757,7 @@ function findReplaceSeparator(raw) {
     }
     if (ch === " " && depth === 0) {
       const rest = raw.slice(i + 1).trimStart();
-      if (rest.startsWith("T.") || rest.startsWith("{") || rest.startsWith("[") || rest.startsWith('"') || rest.startsWith("'") || /^-?\d/.test(rest) || rest === "true" || rest === "false" || rest === "null" || rest === "undefined") {
+      if (CONSTRAINT_EXPR_RE.test(rest) || rest.startsWith("{") || rest.startsWith("[") || rest.startsWith('"') || rest.startsWith("'") || rest === "true" || rest === "false" || rest === "null" || rest === "undefined" || rest === "unknown" || rest === "any" || rest === "never" || /^-?\d+(\.\d+)?$/.test(rest) || rest.includes("=>") || /^function\s*[\w$]*\s*\(/.test(rest)) {
         return i;
       }
     }
@@ -668,11 +803,43 @@ function extractFileDirectives(ast) {
   return results;
 }
 export {
+  asAssignmentExpression,
+  asExpression,
+  asIdentifier,
+  asMemberExpression,
+  asProgram,
+  classIdName,
+  classInstanceMethods,
+  classMemberKey,
+  classMemberKeyName,
+  exportSpecifierExportedName,
+  exportSpecifierLocalName,
   extractDirectives,
   extractFileDirectives,
   extractInlineDirectives,
+  fnOrClassIdLoc,
+  fnOrClassIdName,
+  getClassMembers,
+  getDeclarations,
+  getDeclaratorId,
+  getDeclaratorInit,
+  getExportDeclaration,
+  getExportSpecifiers,
+  getExpressionStatementExpression,
+  getFirstDeclaratorId,
+  identifierName,
+  isModuleExportsMember,
+  memberObjectName,
+  memberPropertyKey,
+  memberPropertyName,
+  methodFunctionNode,
+  nameOrStringValue,
+  paramDisplayName,
+  paramName,
   parse,
   parseCaseArgExpr,
-  parseTypeValueExpr,
-  stripTypes
+  programBody,
+  stripTypes,
+  unwrapDefaultExport,
+  unwrapExport
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/parser",
-  "version": "0.5.1",
+  "version": "1.1.0-beta.0",
   "engines": {
     "node": ">=20"
   },
@@ -39,7 +39,8 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "2.0.1"
+    "@babel/types": "^8.0.6",
+    "@nudojs/core": "3.0.0-beta.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"