@cortex-js/compute-engine 0.30.1 → 0.31.0

package/dist/math-json.esm.js

@@ -1,6 +1,9 @@
-/** Compute Engine 0.30.1 */
+/** Compute Engine 0.31.0 */
 
 // src/math-json/utils.ts
+function isNumberObject(expr) {
+  return expr !== null && typeof expr === "object" && "num" in expr;
+}
 function isSymbolObject(expr) {
   return expr !== null && typeof expr === "object" && "sym" in expr;
 }
@@ -70,13 +73,15 @@ function dictionaryFromExpression(expr) {
   const kv = keyValuePair(expr);
   if (kv) return { [kv[0]]: kv[1] };
   if (operator(expr) === "Dictionary") {
-    const result = {};
+    const dict = {};
     const ops = operands(expr);
     for (let i = 1; i < nops(expr); i++) {
       const kv2 = keyValuePair(ops[i]);
-      if (kv2) result[kv2[0]] = kv2[1];
+      if (kv2) {
+        dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
+      }
     }
-    return result;
+    return { dict };
   }
   return null;
 }
@@ -99,9 +104,18 @@ function matchesNumber(s) {
 function matchesSymbol(s) {
   return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s) || s.length >= 2 && s[0] === "`" && s[s.length - 1] === "`";
 }
+function expressionToDictionaryValue(expr) {
+  if (expr === null || expr === void 0) return null;
+  if (isStringObject(expr)) return expr.str;
+  if (isNumberObject(expr)) return parseFloat(expr.num);
+  if (isSymbolObject(expr)) return expr.sym;
+  if (typeof expr === "string" || typeof expr === "number") return expr;
+  if (Array.isArray(expr)) return { fn: expr };
+  return expr;
+}
 
 // src/math-json.ts
-var version = "0.30.1";
+var version = "0.31.0";
 export {
   dictionaryFromExpression,
   isFunctionObject,

package/dist/math-json.min.esm.js

@@ -1,6 +1,9 @@
-/** Compute Engine 0.30.1 */
+/** Compute Engine 0.31.0 */
 
 // src/math-json/utils.ts
+function isNumberObject(expr) {
+  return expr !== null && typeof expr === "object" && "num" in expr;
+}
 function isSymbolObject(expr) {
   return expr !== null && typeof expr === "object" && "sym" in expr;
 }
@@ -70,13 +73,15 @@ function dictionaryFromExpression(expr) {
   const kv = keyValuePair(expr);
   if (kv) return { [kv[0]]: kv[1] };
   if (operator(expr) === "Dictionary") {
-    const result = {};
+    const dict = {};
     const ops = operands(expr);
     for (let i = 1; i < nops(expr); i++) {
       const kv2 = keyValuePair(ops[i]);
-      if (kv2) result[kv2[0]] = kv2[1];
+      if (kv2) {
+        dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
+      }
     }
-    return result;
+    return { dict };
   }
   return null;
 }
@@ -99,9 +104,18 @@ function matchesNumber(s) {
 function matchesSymbol(s) {
   return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s) || s.length >= 2 && s[0] === "`" && s[s.length - 1] === "`";
 }
+function expressionToDictionaryValue(expr) {
+  if (expr === null || expr === void 0) return null;
+  if (isStringObject(expr)) return expr.str;
+  if (isNumberObject(expr)) return parseFloat(expr.num);
+  if (isSymbolObject(expr)) return expr.sym;
+  if (typeof expr === "string" || typeof expr === "number") return expr;
+  if (Array.isArray(expr)) return { fn: expr };
+  return expr;
+}
 
 // src/math-json.ts
-var version = "0.30.1";
+var version = "0.31.0";
 export {
   dictionaryFromExpression,
   isFunctionObject,

package/dist/math-json.min.umd.js

@@ -1,4 +1,4 @@
-/** MathJSON 0.30.1 */
+/** MathJSON 0.31.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MathJson = {}));})(this, (function (exports) { 'use strict';
-var MathJson=(()=>{var s=Object.defineProperty;var j=Object.getOwnPropertyDescriptor;var O=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var S=(n,t)=>{for(var i in t)s(n,i,{get:t[i],enumerable:!0})},J=(n,t,i,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of O(t))!M.call(n,e)&&e!==i&&s(n,e,{get:()=>t[e],enumerable:!(r=j(t,e))||r.enumerable});return n};var A=n=>J(s({},"__esModule",{value:!0}),n);var F={};S(F,{dictionaryFromExpression:()=>E,isFunctionObject:()=>u,isStringObject:()=>y,isSymbolObject:()=>f,mapArgs:()=>h,operand:()=>d,operator:()=>o,stringValue:()=>c,symbol:()=>m,version:()=>k});function f(n){return n!==null&&typeof n=="object"&&"sym"in n}function y(n){return n!==null&&typeof n=="object"&&"str"in n}function N(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function u(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):p(n)||g(n)?null:n}function o(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function b(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function d(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function D(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function m(n){return typeof n=="string"&&g(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:f(n)?n.sym:null}function a(n){let t=o(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,r]=b(n),e=c(i);return e?[e,r??"Nothing"]:null}return null}function E(n){if(n===null)return null;if(N(n))return n;let t=a(n);if(t)return{[t[0]]:t[1]};if(o(n)==="Dictionary"){let i={},r=b(n);for(let e=1;e<D(n);e++){let l=a(r[e]);l&&(i[l[0]]=l[1])}return i}return null}function h(n,t){let i=null;if(Array.isArray(n)&&(i=n),u(n)&&(i=n.fn),i===null)return[];let r=1,e=[];for(;r<i.length;)e.push(t(i[r])),r+=1;return e}function p(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function g(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}var k="0.30.1";return A(F);})();
+var MathJson=(()=>{var f=Object.defineProperty;var j=Object.getOwnPropertyDescriptor;var O=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var A=(n,t)=>{for(var i in t)f(n,i,{get:t[i],enumerable:!0})},J=(n,t,i,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of O(t))!M.call(n,e)&&e!==i&&f(n,e,{get:()=>t[e],enumerable:!(r=j(t,e))||r.enumerable});return n};var S=n=>J(f({},"__esModule",{value:!0}),n);var T={};A(T,{dictionaryFromExpression:()=>E,isFunctionObject:()=>u,isStringObject:()=>a,isSymbolObject:()=>o,mapArgs:()=>h,operand:()=>d,operator:()=>s,stringValue:()=>c,symbol:()=>m,version:()=>V});function N(n){return n!==null&&typeof n=="object"&&"num"in n}function o(n){return n!==null&&typeof n=="object"&&"sym"in n}function a(n){return n!==null&&typeof n=="object"&&"str"in n}function p(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function u(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):k(n)||g(n)?null:n}function s(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function b(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function d(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function D(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function m(n){return typeof n=="string"&&g(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:o(n)?n.sym:null}function y(n){let t=s(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,r]=b(n),e=c(i);return e?[e,r??"Nothing"]:null}return null}function E(n){if(n===null)return null;if(p(n))return n;let t=y(n);if(t)return{[t[0]]:t[1]};if(s(n)==="Dictionary"){let i={},r=b(n);for(let e=1;e<D(n);e++){let l=y(r[e]);l&&(i[l[0]]=F(l[1])??"Nothing")}return{dict:i}}return null}function h(n,t){let i=null;if(Array.isArray(n)&&(i=n),u(n)&&(i=n.fn),i===null)return[];let r=1,e=[];for(;r<i.length;)e.push(t(i[r])),r+=1;return e}function k(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function g(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}function F(n){return n==null?null:a(n)?n.str:N(n)?parseFloat(n.num):o(n)?n.sym:typeof n=="string"||typeof n=="number"?n:Array.isArray(n)?{fn:n}:n}var V="0.31.0";return S(T);})();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/math-json.umd.js

@@ -1,4 +1,4 @@
-/** MathJSON 0.30.1 */
+/** MathJSON 0.31.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.MathJson = {}));})(this, (function (exports) { 'use strict';
 var MathJson = (() => {
   var __defProp = Object.defineProperty;
@@ -35,6 +35,9 @@ var MathJson = (() => {
   });
 
   // src/math-json/utils.ts
+  function isNumberObject(expr) {
+    return expr !== null && typeof expr === "object" && "num" in expr;
+  }
   function isSymbolObject(expr) {
     return expr !== null && typeof expr === "object" && "sym" in expr;
   }
@@ -104,13 +107,15 @@ var MathJson = (() => {
     const kv = keyValuePair(expr);
     if (kv) return { [kv[0]]: kv[1] };
     if (operator(expr) === "Dictionary") {
-      const result = {};
+      const dict = {};
       const ops = operands(expr);
       for (let i = 1; i < nops(expr); i++) {
         const kv2 = keyValuePair(ops[i]);
-        if (kv2) result[kv2[0]] = kv2[1];
+        if (kv2) {
+          dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
+        }
       }
-      return result;
+      return { dict };
     }
     return null;
   }
@@ -133,9 +138,18 @@ var MathJson = (() => {
   function matchesSymbol(s) {
     return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s) || s.length >= 2 && s[0] === "`" && s[s.length - 1] === "`";
   }
+  function expressionToDictionaryValue(expr) {
+    if (expr === null || expr === void 0) return null;
+    if (isStringObject(expr)) return expr.str;
+    if (isNumberObject(expr)) return parseFloat(expr.num);
+    if (isSymbolObject(expr)) return expr.sym;
+    if (typeof expr === "string" || typeof expr === "number") return expr;
+    if (Array.isArray(expr)) return { fn: expr };
+    return expr;
+  }
 
   // src/math-json.ts
-  var version = "0.30.1";
+  var version = "0.31.0";
   return __toCommonJS(math_json_exports);
 })();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/types/common/ansi-codes.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare const DEFAULT_COLOR = "\u001B[39m";
 export declare const DEFAULT_BG = "\u001B[49m";
 export declare const WHITE_BG = "\u001B[47m";

package/dist/types/common/configuration-change.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
     private _listeners;
     private _pending;
     private _version;

package/dist/types/common/fuzzy-string-match.d.ts

@@ -1,2 +1,2 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare function fuzzyStringMatch(invalidWord: string, validWords: string[]): string | null;

package/dist/types/common/grapheme-splitter.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * Return a string or an array of graphemes.
  *

package/dist/types/common/interruptible.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
     cause: unknown;
     value: T;
     constructor({ message, value, cause, }?: {

package/dist/types/common/one-of.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
     infer Head,
     ...infer Rem
 ] ? MergeTypes<Rem, Res & Head> : Res;

package/dist/types/common/signals.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */
 export type SignalCode = RuntimeSignalCode | ('invalid-name' | 'expected-predicate' | 'expected-symbol' | 'operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'prefix-operator-requires-one-operand' | 'unbalanced-symbols' | 'expected-argument' | 'unexpected-command' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry' | 'syntax-error');

package/dist/types/common/type/ast-nodes.d.ts

@@ -0,0 +1,146 @@
+/* 0.31.0 */
+    kind: string;
+    position: number;
+    line: number;
+    column: number;
+}
+export interface NamedElementNode extends ASTNode {
+    kind: 'named_element';
+    name?: string;
+    type: TypeNode;
+}
+export interface ArgumentNode extends ASTNode {
+    kind: 'argument';
+    element: NamedElementNode;
+    modifier?: 'optional' | 'variadic_zero' | 'variadic_one';
+}
+export interface FunctionSignatureNode extends ASTNode {
+    kind: 'function_signature';
+    arguments: ArgumentNode[];
+    returnType: TypeNode;
+}
+export interface UnionTypeNode extends ASTNode {
+    kind: 'union';
+    types: TypeNode[];
+}
+export interface IntersectionTypeNode extends ASTNode {
+    kind: 'intersection';
+    types: TypeNode[];
+}
+export interface NegationTypeNode extends ASTNode {
+    kind: 'negation';
+    type: TypeNode;
+}
+export interface GroupTypeNode extends ASTNode {
+    kind: 'group';
+    type: TypeNode;
+}
+export interface ListTypeNode extends ASTNode {
+    kind: 'list';
+    elementType: TypeNode;
+    dimensions?: DimensionNode[];
+}
+export interface VectorTypeNode extends ASTNode {
+    kind: 'vector';
+    elementType: TypeNode;
+    size?: number;
+}
+export interface MatrixTypeNode extends ASTNode {
+    kind: 'matrix';
+    elementType: TypeNode;
+    dimensions?: DimensionNode[];
+}
+export interface TensorTypeNode extends ASTNode {
+    kind: 'tensor';
+    elementType: TypeNode;
+}
+export interface TupleTypeNode extends ASTNode {
+    kind: 'tuple';
+    elements: NamedElementNode[];
+}
+export interface RecordTypeNode extends ASTNode {
+    kind: 'record';
+    entries: RecordEntryNode[];
+}
+export interface RecordEntryNode extends ASTNode {
+    kind: 'record_entry';
+    key: string;
+    valueType: TypeNode;
+}
+export interface DictionaryTypeNode extends ASTNode {
+    kind: 'dictionary';
+    valueType: TypeNode;
+}
+export interface SetTypeNode extends ASTNode {
+    kind: 'set';
+    elementType: TypeNode;
+}
+export interface CollectionTypeNode extends ASTNode {
+    kind: 'collection';
+    elementType: TypeNode;
+    indexed?: boolean;
+}
+export interface ExpressionTypeNode extends ASTNode {
+    kind: 'expression';
+    operator: string;
+}
+export interface SymbolTypeNode extends ASTNode {
+    kind: 'symbol';
+    name: string;
+}
+export interface NumericTypeNode extends ASTNode {
+    kind: 'numeric';
+    baseType: string;
+    lowerBound?: ValueNode;
+    upperBound?: ValueNode;
+}
+export interface PrimitiveTypeNode extends ASTNode {
+    kind: 'primitive';
+    name: string;
+}
+export interface TypeReferenceNode extends ASTNode {
+    kind: 'type_reference';
+    name: string;
+    isForward?: boolean;
+}
+export interface ValueNode extends ASTNode {
+    kind: 'value';
+    value: any;
+    valueType: 'string' | 'number' | 'boolean' | 'infinity' | 'nan';
+}
+export interface DimensionNode extends ASTNode {
+    kind: 'dimension';
+    size: number | null;
+}
+export interface IdentifierNode extends ASTNode {
+    kind: 'identifier';
+    name: string;
+}
+export interface VerbatimStringNode extends ASTNode {
+    kind: 'verbatim_string';
+    value: string;
+}
+export type TypeNode = FunctionSignatureNode | UnionTypeNode | IntersectionTypeNode | NegationTypeNode | GroupTypeNode | ListTypeNode | VectorTypeNode | MatrixTypeNode | TensorTypeNode | TupleTypeNode | RecordTypeNode | DictionaryTypeNode | SetTypeNode | CollectionTypeNode | ExpressionTypeNode | SymbolTypeNode | NumericTypeNode | PrimitiveTypeNode | TypeReferenceNode | ValueNode;
+export interface ASTVisitor<T> {
+    visitFunctionSignature(node: FunctionSignatureNode): T;
+    visitUnionType(node: UnionTypeNode): T;
+    visitIntersectionType(node: IntersectionTypeNode): T;
+    visitNegationType(node: NegationTypeNode): T;
+    visitGroupType(node: GroupTypeNode): T;
+    visitListType(node: ListTypeNode): T;
+    visitVectorType(node: VectorTypeNode): T;
+    visitMatrixType(node: MatrixTypeNode): T;
+    visitTensorType(node: TensorTypeNode): T;
+    visitTupleType(node: TupleTypeNode): T;
+    visitRecordType(node: RecordTypeNode): T;
+    visitDictionaryType(node: DictionaryTypeNode): T;
+    visitSetType(node: SetTypeNode): T;
+    visitCollectionType(node: CollectionTypeNode): T;
+    visitExpressionType(node: ExpressionTypeNode): T;
+    visitSymbolType(node: SymbolTypeNode): T;
+    visitNumericType(node: NumericTypeNode): T;
+    visitPrimitiveType(node: PrimitiveTypeNode): T;
+    visitTypeReference(node: TypeReferenceNode): T;
+    visitValue(node: ValueNode): T;
+}
+export declare function visitNode<T>(node: TypeNode, visitor: ASTVisitor<T>): T;

package/dist/types/common/type/boxed-type.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /** @category Type */
 export declare class BoxedType {
     static unknown: BoxedType;

package/dist/types/common/type/lexer.d.ts

@@ -0,0 +1,51 @@
+/* 0.31.0 */
+export interface Token {
+    type: TokenType;
+    value: string;
+    position: number;
+    line: number;
+    column: number;
+}
+export interface LexerError {
+    message: string;
+    position: number;
+    line: number;
+    column: number;
+}
+export declare class Lexer {
+    input: string;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    constructor(input: string);
+    saveState(): {
+        pos: number;
+        line: number;
+        column: number;
+        tokens: Token[];
+    };
+    restoreState(state: {
+        pos: number;
+        line: number;
+        column: number;
+        tokens: Token[];
+    }): void;
+    error(message: string): never;
+    private peek;
+    private advance;
+    private match;
+    private isEOF;
+    private skipWhitespace;
+    private readIdentifier;
+    private readVerbatimString;
+    private readStringLiteral;
+    private readNumber;
+    private createToken;
+    private nextToken;
+    tokenize(): Token[];
+    peekToken(): Token;
+    consumeToken(): Token;
+    matchToken(type: TokenType): boolean;
+    expectToken(type: TokenType): Token;
+}

package/dist/types/common/type/parse.d.ts

@@ -1,4 +1,211 @@
-/* 0.30.1 */
+/* 0.31.0 */
+/**
+ * BNF grammar for the type parser:
+ *
+<type> ::= <union_type>
+         | <function_signature>
+
+<union_type> ::= <intersection_type> ( " | " <intersection_type> )*
+
+<intersection_type> ::= <primary_type_with_negation> ( " & " <primary_type_with_negation> )*
+
+<primary_type_with_negation> ::= ( "!" )? <primary_type>
+
+<primary_type> ::= <group>
+                 | <list_type>
+                 | <tuple_type>
+                 | <record_type>
+                 | <dictionary_type>
+                 | <set_type>
+                 | <collection_type>
+                 | <expression_type>
+                 | <symbol_type>
+                 | <numeric_type>
+                 | <primitive_type>
+                 | <value>
+                 | <type_reference>
+
+<group> ::= "(" <type> ")"
+
+(* --- Function Signatures --- *)
+
+<function_signature> ::= <arguments> " -> " <type>
+
+<arguments> ::= "()"
+              | "(" <argument_list>? ")"
+
+(* Note: The parser enforces a semantic rule: required arguments must come before optional and variadic arguments. *)
+<argument_list> ::= <argument_specifier> ( "," <argument_specifier> )*
+
+<argument_specifier> ::= <named_element> ( "?" | "*" | "+" )?
+
+<named_element> ::= ( <name> ":" )? <type>
+
+<name> ::= <identifier> | <verbatim_string>
+
+
+(* --- Collection-like Types --- *)
+
+<list_type> ::= "list" ( "<" <type> ( "^" <dimensions> )? ">" )?
+              | "vector" ( "<" ( <type> ("^" <dimension_specifier>)? | <dimensions> ) ">" )?
+              | "matrix" ( "<" ( <type> ("^" <dimensions>)? | <dimensions> ) ">" )?
+              | "tensor" ( "<" <type> ">" )?
+
+<dimensions> ::= <dimension_specifier> ( "x" <dimension_specifier> )*
+               | "(" <dimension_specifier> ( "x" <dimension_specifier> )* ")"
+
+<dimension_specifier> ::= <positive_integer_literal> | "?"
+
+<tuple_type> ::= "tuple<" ( <named_element> ( "," <named_element> )* )? ">"
+
+<record_type> ::= "record"
+                | "record<" <record_element> ( "," <record_element> )* ">"
+
+<record_element> ::= <key> ":" <type>
+
+<key> ::= <identifier> | <verbatim_string>
+
+<dictionary_type> ::= "dictionary"
+                    | "dictionary<" <type> ">"
+
+<set_type> ::= "set"
+             | "set<" <type> ">"
+
+<collection_type> ::= ( "collection" | "indexed_collection" ) ( "<" <type> ">" )?
+
+
+(* --- Other Constructed Types --- *)
+
+<expression_type> ::= "expression<" <identifier> ">"
+
+<symbol_type> ::= "symbol<" <identifier> ">"
+
+<numeric_type> ::= <numeric_primitive> "<" <bound> ".." <bound> ">"
+
+<bound> ::= <number_literal> | "-oo" | "oo" | ""
+
+
+(* --- Atomic and Primitive Types --- *)
+
+<type_reference> ::= ( "type" )? <identifier>
+
+<value> ::= <string_literal>
+          | <number_literal>
+          | "true" | "false"
+          | "nan" | "infinity" | "+infinity" | "oo" | "∞" | "+oo" | "+∞"
+          | "-infinity" | "-oo" | "-∞"
+
+<primitive_type> ::= <numeric_primitive>
+                   | "any" | "unknown" | "nothing" | "never" | "error"
+                   | "expression" | "symbol" | "function" | "value"
+                   | "scalar" | "boolean" | "string"
+                   | "collection" | "indexed_collection" | "list" | "tuple"
+                   | "set" | "record" | "dictionary"
+
+<numeric_primitive> ::= "number" | "finite_number" | "complex" | "finite_complex"
+                      | "imaginary" | "real" | "finite_real" | "rational"
+                      | "finite_rational" | "integer" | "finite_integer"
+                      | "non_finite_number"
+
+
+(* --- Terminals (Lexical Tokens) --- *)
+
+<identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
+
+<verbatim_string> ::= "`" ( [^`] | "\`" | "\\" )* "`"
+
+<positive_integer_literal> ::= [1-9][0-9]*
+
+<number_literal> ::= (* As parsed by the valueParser, including integers, decimals, and scientific notation *)
+
+<string_literal> ::= '"' ( [^"] | '\"' )* '"'
+ *
+ */
+declare class TypeParser {
+    buffer: string;
+    pos: number;
+    _valueParser: (parser: TypeParser) => any;
+    _typeResolver: TypeResolver;
+    constructor(buffer: string, options?: {
+        valueParser?: (parser: TypeParser) => any;
+        typeResolver?: TypeResolver;
+    });
+    error(...messages: (string | undefined)[]): never;
+    peek(): string;
+    consume(): string;
+    /** Check if the upcoming tokens match s, return false if not, consume otherwise */
+    match(s: string): boolean;
+    /** If the next token don't match `>`, error */
+    expectClosingBracket(): void;
+    /** If a white space is allowed, call before `consume()` or `match()` */
+    skipWhitespace(): void;
+    isEOF(): boolean;
+    parseValue(): Type | null;
+    parseTypeReference(): TypeReference | null;
+    parsePrimitiveType(): Type | null;
+    /**
+     * Arguments are `name: type` or `type` separated by commas.
+     * Arguments can be optional, i.e. `name: type?` or `type?`.
+     * Variadic arguments are `name: type+`, `type+`, `name: type*` or `type*`.
+     */
+    parseArguments(): [
+        required: NamedElement[],
+        optional: NamedElement[],
+        variadic: NamedElement | undefined,
+        variadicMin: 0 | 1 | undefined
+    ];
+    parseFunctionSignature(): Type | null;
+    parsePositiveIntegerLiteral(): number | null;
+    parseOptionalDimension(): number | null;
+    parseDimensions(): number[] | undefined;
+    parseList(): Type | null;
+    /**
+     * Parse the name of a named element, i.e. an identifier followed by a colon.
+     * Does special error handling for optional qualifiers.
+     * */
+    parseName(): string | null;
+    parseVerbatimString(): string | null;
+    /**
+     * A general purpose identifier, used for expresion<>, symbol<>, type references, record keys, etc.
+     *
+     * Not used for arguments (they have special error handling with `parseName()`).
+     */
+    parseIdentifier(): string | null;
+    /** Parse:
+     * - "<identifier>: <type>"
+     * - "<type>"
+     *
+     * Does not parse variadic arguments, i.e. `type+` or `name: type+`.
+     */
+    parseNamedElement(): NamedElement | null;
+    parseTupleElements(): NamedElement[];
+    parseTuple(): Type | null;
+    /** Parse a non-optional group, i.e. "(" <type> ")" */
+    parseGroup(): Type | null;
+    parseSet(): Type | null;
+    parseRecordKeyValue(): [string, Type][];
+    parseRecord(): Type | null;
+    parseDictionary(): Type | null;
+    parseCollection(): Type | null;
+    parseExpression(): Type | null;
+    parseSymbol(): Type | null;
+    /** Parse a constructed numeric type with a range */
+    parseNumericType(): Type | null;
+    parseStringType(): Type | null;
+    parsePrimary(): Type;
+    parseUnexpectedToken(): string | undefined;
+    parseMaybePrimary(): Type | null;
+    parseNegationType(): Type | null;
+    parseIntersectionType(): Type | null;
+    parseUnionType(): Type | null;
+    parseType(): Readonly<Type> | null;
+    /** Parse a type, but return null if there's a problem instead
+     * of throwing.
+     */
+    parseTypeMaybe(): Readonly<Type> | null;
+    parse(): Readonly<Type>;
+}
 export declare function parseType(s: undefined, typeResolver?: TypeResolver): undefined;
 export declare function parseType(s: TypeString | Type, typeResolver?: TypeResolver): Type;
 export declare function parseType(s: TypeString | Type | undefined, typeResolver?: TypeResolver): Type | undefined;
+export { TypeParser };