@cortex-js/compute-engine 0.25.1 → 0.26.2

package/dist/math-json.min.js

@@ -1,4 +1,4 @@
-/** MathJSON 0.25.1 */
+/** MathJSON 0.26.2 */
     (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 f=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var D=(n,t)=>{for(var e in t)f(n,e,{get:t[e],enumerable:!0})},F=(n,t,e,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of v(t))!k.call(n,r)&&r!==e&&f(n,r,{get:()=>t[r],enumerable:!(i=T(t,r))||i.enumerable});return n};var R=n=>F(f({},"__esModule",{value:!0}),n);var z={};D(z,{applyRecursively:()=>A,getDictionary:()=>y,getStringValue:()=>m,head:()=>l,headName:()=>j,isDictionaryObject:()=>S,isFunctionObject:()=>u,isStringObject:()=>M,isSymbolObject:()=>d,mapArgs:()=>$,nops:()=>E,op:()=>s,symbol:()=>O,version:()=>X});function d(n){return n!==null&&typeof n=="object"&&"sym"in n}function M(n){return n!==null&&typeof n=="object"&&"str"in n}function u(n){return n!==null&&typeof n=="object"&&"fn"in n}function S(n){return n!==null&&typeof n=="object"&&"dict"in n}var c;function I(n){if(!c){let e=`^[${["Zyyy","Zinh","Arab","Armn","Beng","Bopo","Cyrl","Deva","Ethi","Geor","Grek","Gujr","Guru","Hang","Hani","Hebr","Hira","Kana","Knda","Khmr","Laoo","Latn","Mlym","Mymr","Orya","Sinh","Taml","Telu","Thaa","Thai","Tibt"].map(i=>`\\p{Script=${i}}`).join("")}]*$`;c=new RegExp(e,"u")}return c.test(n)}function a(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||N.test(n)?!0:I(n)?/^[\p{XIDS}_]\p{XIDC}*$/u.test(n):!1}var _="\\u{FE0F}",V="\\u{20E3}",L="\\u{200D}",P="\\p{RI}\\p{RI}",w="(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})",b=`(?:\\p{EMod}|${_}${V}?|${w})`,C="(?:(?=\\P{XIDC})\\p{Emoji})",h=`(?:${C}${b}*|\\p{Emoji}${b}+|${P})`,J=`(?:${h})(${L}${h})*`,G=new RegExp(`(?:${J})+`,"u"),N=new RegExp(`^(?:${J})+$`,"u");function q(n){return typeof n!="string"?"not-a-string":n===""?"empty-string":n.normalize()!==n?"expected-nfc":/[\u200E\u200F\u2066-\u2069\u202A-\u202E]/.test(n)?"unexpected-bidi-marker":N.test(n)?"valid":/\p{XIDC}/u.test(n)&&G.test(n)?"unexpected-mixed-emoji":I(n)?a(n)?"valid":a(n[0])?"invalid-char":"invalid-first-char":"unexpected-script"}function m(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"||n.length<2||n[0]!=="'"||n[n.length-1]!=="'"?null:n.substring(1,n.length-1)}function l(n){return Array.isArray(n)?typeof n[0]=="string"&&!a(n[0])?(console.error(`Invalid identifier "${n[0]}": ${q(n[0])}`),null):n[0]:n==null?null:u(n)?n.fn[0]:null}function j(n){let t=l(n);return typeof t=="string"?t:""}function H(n){return Array.isArray(n)?n.slice(1):n==null?null:u(n)?n.fn.slice(1):null}function s(n,t){return Array.isArray(n)?n[t]??null:n==null?null:u(n)?n.fn[t]??null:null}function K(n){return s(n,1)}function Z(n){return s(n,2)}function E(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 O(n){if(typeof n=="string")return/^[+-]?[0-9\.]/.test(n)||n.length>=2&&n[0]==="'"&&n[n.length-1]==="'"?null:n;if(n==null)return null;let t=d(n)?n.sym:n;return typeof t!="string"?null:t}function p(n){let t=l(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let e=m(K(n));return e?[e,Z(n)??"Nothing"]:null}return null}function y(n){if(n===null)return null;if(typeof n=="object"&&"dict"in n)return n.dict;let t=p(n);if(t)return{[t[0]]:t[1]};if(l(n)==="Dictionary"){let i={};for(let r=1;r<E(n);r++){let o=p(s(n,r));o&&(i[o[0]]=o[1])}return i}return null}function A(n,t){let e=l(n);if(e!==null)return[t(e),...(H(n)??[]).map(t)];let i=y(n);if(i!==null){let r=Object.keys(i),o={};for(let g of r)o[g]=t(i[g]);return{dict:o}}return t(n)}function $(n,t){let e=null;if(Array.isArray(n)&&(e=n),u(n)&&(e=n.fn),e===null)return[];let i=1,r=[];for(;i<e.length;)r.push(t(e[i])),i+=1;return r}var X="0.25.1";return R(z);})();
+var MathJson=(()=>{var f=Object.defineProperty;var M=Object.getOwnPropertyDescriptor;var S=Object.getOwnPropertyNames;var N=Object.prototype.hasOwnProperty;var A=(n,t)=>{for(var e in t)f(n,e,{get:t[e],enumerable:!0})},p=(n,t,e,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of S(t))!N.call(n,i)&&i!==e&&f(n,i,{get:()=>t[i],enumerable:!(r=M(t,i))||r.enumerable});return n};var J=n=>p(f({},"__esModule",{value:!0}),n);var O={};A(O,{getDictionary:()=>g,getStringValue:()=>c,isFunctionObject:()=>u,isStringObject:()=>y,isSymbolObject:()=>a,mapArgs:()=>h,operand:()=>E,operator:()=>o,symbol:()=>b,version:()=>I});function a(n){return n!==null&&typeof n=="object"&&"sym"in n}function y(n){return n!==null&&typeof n=="object"&&"str"in n}function u(n){return n!==null&&typeof n=="object"&&"fn"in n}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"||n.length<2||n.at(0)!=="'"||n.at(-1)!=="'"?null:n.substring(1,n.length-1)}function o(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function m(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function E(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function j(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 b(n){if(typeof n=="string")return/^[+-]?[0-9\.]/.test(n)||n.length>=2&&n[0]==="'"&&n[n.length-1]==="'"?null:n;if(n==null)return null;let t=a(n)?n.sym:n;return typeof t!="string"?null:t}function d(n){let t=o(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[e,r]=m(n),i=c(e);return i?[i,r??"Nothing"]:null}return null}function g(n){if(n===null)return null;let t=d(n);if(t)return{[t[0]]:t[1]};if(o(n)==="Dictionary"){let r={},i=m(n);for(let l=1;l<j(n);l++){let s=d(i[l]);s&&(r[s[0]]=s[1])}return r}return null}function h(n,t){let e=null;if(Array.isArray(n)&&(e=n),u(n)&&(e=n.fn),e===null)return[];let r=1,i=[];for(;r<e.length;)i.push(t(e[r])),r+=1;return i}var I="0.26.2";return J(O);})();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

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

@@ -1,6 +1,18 @@
-/* 0.25.1 */
-export declare const BLACK = "\u001B[30;1m${s}";
-export declare const GREY = "\u001B[30;1m${s}";
+/* 0.26.2 */
+export declare const DEFAULT_COLOR = "\u001B[39m";
+export declare const DEFAULT_BG = "\u001B[49m";
+export declare const WHITE_BG = "\u001B[47m";
+export declare const BLACK_BG = "\u001B[40m";
+export declare const GREY_BG = "\u001B[100m";
+export declare const GREEN_BG = "\u001B[42m";
+export declare const RED_BG = "\u001B[41m";
+export declare const YELLOW_BG = "\u001B[43m";
+export declare const BLUE_BG = "\u001B[44m";
+export declare const MAGENTA_BG = "\u001B[45m";
+export declare const CYAN_BG = "\u001B[46m";
+export declare const WHITE = "\u001B[37;1m";
+export declare const BLACK = "\u001B[30;1m";
+export declare const GREY = "\u001B[30;1m";
 export declare const GREEN = "\u001B[32;1m";
 export declare const RED = "\u001B[31;1m";
 export declare const YELLOW = "\u001B[33m";
@@ -12,4 +24,18 @@ export declare const INVERSE_GREEN = "\u001B[102;97m";
 export declare const INVERSE_YELLOW = "\u001B[103;97m";
 export declare const INVERSE_BLUE = "\u001B[104;97m";
 export declare const BOLD = "\u001B[1m";
-export declare const GREY_BG = "\u001B[40;1m";
+export declare const BOLD_OFF = "\u001B[22m";
+export declare const DIM = "\u001B[2m";
+export declare const DIM_OFF = "\u001B[22m";
+export declare const ITALIC = "\u001B[3m";
+export declare const ITALIC_OFF = "\u001B[23m";
+export declare const UNDERLINE = "\u001B[4m";
+export declare const UNDERLINE_OFF = "\u001B[24m";
+export declare const BLINK = "\u001B[5m";
+export declare const BLINK_OFF = "\u001B[25m";
+export declare const INVERSE = "\u001B[7m";
+export declare const INVERSE_OFF = "\u001B[27m";
+export declare const HIDDEN = "\u001B[8m";
+export declare const HIDDEN_OFF = "\u001B[28m";
+export declare function ansiFgColor(color: string | number, mode: 'none' | 'basic' | 'full'): number[];
+export declare function ansiBgColor(color: string, mode: 'none' | 'basic' | 'full'): number[];

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

@@ -0,0 +1,9 @@
+/* 0.26.2 */
+    s: string;
+    pos: number;
+    constructor(s: string, pos?: number);
+    atEnd(): boolean;
+    peek(): string;
+    consume(): string;
+    match(s: string): boolean;
+}

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

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

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

@@ -0,0 +1,9 @@
+/* 0.26.2 */
+    infer Head,
+    ...infer Rem
+] ? MergeTypes<Rem, Res & Head> : Res;
+export type OneOf<TypesArray extends any[], Res = never, AllProperties = MergeTypes<TypesArray>> = TypesArray extends [infer Head, ...infer Rem] ? OneOf<Rem, Res | OnlyFirst<Head, AllProperties>, AllProperties> : Res;
+type OnlyFirst<F, S> = F & {
+    [Key in keyof Omit<S, keyof F>]?: never;
+};
+export {};

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

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 /** @category Error Handling */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */

package/dist/types/common/styled-text.d.ts

@@ -0,0 +1,28 @@
+/* 0.26.2 */
+    fg?: string;
+    bg?: string;
+    weight?: 'bold' | 'normal' | 'thin';
+    italic?: boolean;
+    mono?: boolean;
+    content: string;
+};
+/** A paragraph block has a blank line before and after
+ * and is wrapped to the width of the terminal.
+ *
+ * A 'block' is rendered as is, with no wrapping, but possibly
+ * with an indent. Used for code blocks, tables.
+ *
+ * A `blockquote` is a block with a vertical bar on the left,
+ * and is wrapped to the available width.
+ *
+ * A `note`, `warning` or `error` is an admonition block with a
+ * colored background or border (blue, orange or red).
+ *
+ */
+export type StyledBlock = {
+    tag: 'paragraph' | 'block';
+    spans: StyledSpan[];
+} | {
+    tag: 'blockquote' | 'note' | 'warning' | 'error';
+    blocks: StyledBlock[];
+};

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

@@ -0,0 +1 @@
+/* 0.26.2 */

package/dist/types/common/syntax-highlighter.d.ts

@@ -0,0 +1,40 @@
+/* 0.26.2 */
+import { StyledBlock, StyledSpan } from './styled-text';
+export type CodeTag = 
+/** Plain text in default foreground/background color */
+'default'
+/** A literal such as a number, string or regex */
+ | 'literal'
+/** A comment */
+ | 'comment'
+/** A language keyword: if, while, export */
+ | 'keyword'
+/** An operator such as =, >=, +, etc... */
+ | 'operator'
+/** A punctuation such as `;`, `,`, `:` */
+ | 'punctuation'
+/** An identifier such as "foo" or "bar" */
+ | 'identifier'
+/** A type such as `boolean` or `number` */
+ | 'type';
+export type CodeSpan = {
+    tag: CodeTag;
+    content: string;
+};
+export type SyntaxGrammar = {
+    comment?: (buf: Buffer) => undefined | CodeSpan;
+    number?: (buf: Buffer) => undefined | CodeSpan;
+    string?: (buf: Buffer) => undefined | CodeSpan;
+    regex?: (buf: Buffer) => undefined | CodeSpan;
+    identifier?: (buf: Buffer) => undefined | CodeSpan;
+    keyword?: (buf: Buffer) => undefined | CodeSpan;
+};
+export declare function parseCode(text: string, grammar?: SyntaxGrammar, pos?: number): CodeSpan[];
+/** Return a style span of the input code */
+export declare function highlightCodeSpan(code: string, grammar?: SyntaxGrammar): StyledSpan[];
+/** Return a style block of the input code, including a
+ * gutter with line numbers and an optional highlighted line
+ */
+export declare function highlightCodeBlock(code: string, lineStart?: number | undefined, markIndicator?: string, grammar?: SyntaxGrammar): StyledBlock;
+export declare function mark(line: StyledSpan[], mark: string): StyledSpan[];
+/** JS sample  */

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

@@ -0,0 +1,19 @@
+/* 0.26.2 */
+declare abstract class Terminal {
+    width: number | undefined;
+    indent: number;
+    constructor(options?: {
+        indent?: number;
+        width?: number;
+    });
+    renderBlock(block: StyledBlock): string;
+    abstract renderSpan(span: StyledSpan): string;
+    renderSpans(s: StyledSpan[]): string;
+    display(s: StyledSpan[] | StyledBlock): void;
+}
+export declare const terminal: Terminal;
+/** Word-wrap a string that contains ANSI escape sequences.
+ *  ANSI escape sequences do not add to the string length.
+ */
+export declare const wrapAnsiString: (string: string, width: number | undefined) => string[];
+export {};

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

@@ -0,0 +1,4 @@
+/* 0.26.2 */
+export declare function parseType(s: undefined): undefined;
+export declare function parseType(s: string | Type): Type;
+export declare function parseType(s: string | Type | undefined): Type | undefined;

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

@@ -0,0 +1,8 @@
+/* 0.26.2 */
+export declare const NUMERIC_TYPES: PrimitiveType[];
+export declare const COLLECTION_TYPES: PrimitiveType[];
+export declare const SCALAR_TYPES: PrimitiveType[];
+export declare const VALUE_TYPES: PrimitiveType[];
+export declare const EXPRESSION_TYPES: PrimitiveType[];
+export declare const PRIMITIVE_TYPES: PrimitiveType[];
+export declare function isValidPrimitiveType(s: any): s is PrimitiveType;

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

@@ -0,0 +1,2 @@
+/* 0.26.2 */
+export declare function typeToString(type: Type, precedence?: number): string;

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

@@ -0,0 +1,6 @@
+/* 0.26.2 */
+/** Return true if lhs is a subtype of rhs */
+export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
+/** Return true if lhs is a subtype of rhs */
+export declare function isSubtype(lhs: Type | TypeString, rhs: Type | TypeString): boolean;
+export declare function isCompatible(lhs: PrimitiveType, rhs: PrimitiveType, compatibility: TypeCompatibility): boolean;

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

@@ -0,0 +1,249 @@
+/* 0.26.2 */
+ * A primitive type is a simple type that represents a concrete value.
+ *
+ * - `any`: the top type
+ *    - `expression`
+ *    - `error`: an invalid value, such as `["Error", "missing"]`
+ *    - `nothing`: the type of the `Nothing` symbol, the unit type
+ *    - `never`: the bottom type
+ *    - `unknown`: a value whose type is not known
+ *
+ * - `expression`:
+ *    - a symbolic expression, such as `["Add", "x", 1]`
+ *    - <value>
+ *    - `symbol`: a symbol, such as `x`.
+ *    - `function`: a function expression
+ *      such as `["Function", ["Add", "x", 1], "x"]`.
+ *
+ * - `value`
+ *    - `scalar`
+ *      - <number>
+ *      - `boolean`: a boolean value: `True` or `False`.
+ *      - `string`: a string of characters.
+ *    - `collection`
+ *       - `list`: a collection of expressions, possibly recursive,
+ *          with optional dimensions, e.g. `[number]`, `[boolean^32]`,
+ *          `[number^(2x3)]`. Used to represent a vector, a matrix or a
+ *          tensor when the type of its elements is a number
+ *       - `set`: a collection of unique expressions, e.g. `set<string>`.
+ *       - `tuple`: a fixed-size collection of named or unnamed elements, e.g.
+ *          `tuple<number, boolean>`, `tuple<x: number, y: boolean>`.
+ *       - `map`: a set key-value pairs, e.g. `map<x: number, y: boolean>`.
+ *
+ * - `number`: any numeric value:
+ *    - `finite_number`: <finite_complex> or <finite_imaginary> or
+ *       <finite_real> or <finite_rational> or <finite_integer>
+ *    - `non_finite_number`: `NaN`, `PositiveInfinity`, `NegativeInfinity` or
+ *      `ComplexInfinity`
+ *    - `complex` and `finite_complex`: a complex number, with non-zero real
+ *       and imaginary parts.
+ *    - `imaginary` and `finite_imaginary`: a complex number with a real part
+ *       of 0 (pure imaginary).
+ *    - `real` and `finite_real`: a complex number with an imaginary part of 0.
+ *    - `rational` and `finite_rational`: a pure rational number
+ *       (not an integer)
+ *    - `integer` and `finite_integer`: a whole number
+ *
+ *
+ */
+export type PrimitiveType = NumericType | 'collection' | 'list' | 'set' | 'map' | 'tuple' | 'value' | 'scalar' | 'function' | 'symbol' | 'boolean' | 'string' | 'expression' | 'unknown' | 'error' | 'nothing' | 'never' | 'any';
+export type NumericType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'finite_imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
+export type NamedElement = {
+    name?: string;
+    type: Type;
+};
+export type FunctionSignature = {
+    kind: 'signature';
+    args?: NamedElement[];
+    optArgs?: NamedElement[];
+    restArg?: NamedElement;
+    result: Type;
+};
+export type AlgebraicType = {
+    kind: 'union' | 'intersection';
+    types: Type[];
+};
+export type NegationType = {
+    kind: 'negation';
+    type: Type;
+};
+export type ValueType = {
+    kind: 'value';
+    value: any;
+};
+/** Map is not a collection. It is a set of key/value pairs.
+ * An element of a map whose type is a subtype of `nothing` is optional.
+ * For example, in `{x: number, y: boolean | nothing}` the element `y` is optional.
+ */
+export type MapType = {
+    kind: 'map';
+    elements: Record<string, Type>;
+};
+/** Collection, List, Set, Tuple and Map are collections.
+ *
+ * `CollectionType` is a generic collection of elements of a certain type.
+ */
+export type CollectionType = {
+    kind: 'collection';
+    elements: Type;
+};
+/**
+ * The elements of a list are ordered.
+ *
+ * All elements of a list have the same type (but it can be a broad type,
+ * up to `any`).
+ *
+ * The same element can be present in the list more than once.
+ *
+ * A list can be multi-dimensional. For example, a list of integers with
+ * dimensions 2x3x4 is a 3D tensor with 2 layers, 3 rows and 4 columns.
+ *
+ */
+export type ListType = {
+    kind: 'list';
+    elements: Type;
+    dimensions?: number[];
+};
+/** Each element of a set is unique (is not present in the set more than once).
+ * The elements of a set are not ordered.
+ */
+export type SetType = {
+    kind: 'set';
+    elements: Type;
+};
+export type TupleType = {
+    kind: 'tuple';
+    elements: NamedElement[];
+};
+/** Nominal typing */
+export type TypeReference = {
+    kind: 'reference';
+    ref: string;
+};
+export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType | ListType | SetType | MapType | TupleType | FunctionSignature | ValueType | TypeReference;
+/**
+ * The type of a boxed expression indicates the kind of expression it is and
+ * the value it represents.
+ *
+ * The type is represented either by a primitive type (e.g. number, complex, collection, etc.), or a compound type (e.g. tuple, function signature, etc.).
+ *
+ * Types are described using the following BNF grammar:
+
+```bnf
+<type> ::= <union_type>
+
+<union_type> ::= <intersection_type> (" | " <intersection_type>)*
+
+<intersection_type> ::= <primary_type> (" & " <primary_type>)*
+
+<primary_type> ::=  <primitive>
+                | <tuple_type>
+                | <function_type>
+                | <list_type>
+                | <wrapped_primary_type>
+
+<wrapped_primary_type> ::= "(" <primary_type> ")"
+
+
+<primitive> ::= "any" | "unknown" | <value-type> | <symbolic-type> | <numeric-type>
+
+<numeric-type> ::= "number" | "complex" | "imaginary" | "real" | "rational" | "integer"
+
+<value-type> ::= "value" | <numeric-type> | "collection" | "boolean" | "string"
+
+<symbolic-type> ::= "expression" | "function" | "symbol"
+
+<tuple_type> ::= "(" (<name> <type> "," <named_tuple_elements>*) ")"
+            | "(" (<type> "," <unnamed_tuple_elements>*) ")" |
+            | "tuple(" <tuple_elements> ")"
+
+<tuple_elements> ::= <unnamed_tuple_elements> | <named_tuple_elements>
+
+<unnamed_tuple_elements> ::= <type> ("," <type>)*
+
+<named_tuple_elements> ::= <name> <type> ("," <name> <type>)*
+
+<function_type> ::=  <arguments> " -> " <type>
+
+<arguments> ::= "()"
+            | <argument>
+            | "(" <argument-list> ")"
+            | <deferred_evaluation>
+
+<deferred_evaluation> ::= "???" <argument>
+                       | "???" "(" <argument-list> ")"
+
+<argument> ::= <type>
+            | <name> <type>
+
+<rest_argument> ::= "..." <type>
+            | <name> "..." <type>
+
+<optional_argument> ::= <argument> "?"
+
+<optional_arguments> ::= <optional_argument> ("," <optional_argument>)*
+
+<required_arguments> ::= <argument> ("," <argument>)*
+
+<argument-list> ::= <required_arguments> ("," <rest_argument>)?
+            | <required_arguments> <optional_arguments>?
+            | <optional_arguments>?
+            | <rest_argument>
+
+
+<list_type> ::= "[" <type> <dimensions>? "]"
+
+<dimensions> ::= "^" <fixed_size>
+            | "^(" <multi_dimensional_size> ")"
+
+<fixed_size> ::= <positive-integer_literal>
+
+<multi_dimensional_size> ::= <positive-integer_literal> "x" <positive-integer_literal> ("x" <positive-integer_literal>)*
+
+<map> ::= "{}"
+            |"{" <map_elements> "}"
+            | "map(" <map_elements> ")"
+
+<map_elements> ::= <name> <type> ("," <name> <type>)*
+
+<set> ::= "set<" <type> ">"
+
+<collection ::= "collection<" <type> ">"
+
+<name> ::= <identifier> ":"
+
+<identifier> ::= [a-zA-Z_][a-zA-Z0-9_]*
+
+<positive-integer_literal> ::= [1-9][0-9]*
+```
+
+
+Examples of types:
+   "number"    -- a simple type primitive
+
+
+   "(number, boolean)" -- a tuple type
+   "(x: number, y:boolean)" -- a named tuple/record type. Either all arguments are named, or none are
+
+   "[any]" -- an arbitrary collection type, with no length or element type restrictions
+   "[integer]" -- a collection type where all the elements are integers
+   "[(number, boolean)]" -- a collection of tuples
+   "[(value:number, seen:boolean)]" -- a collection of named tuples
+   "[boolean]^32" -- a collection type with a fixed size of 32 elements
+   "[integer]^(2x3)" -- an integer matrix of 2 columns and 3 rows
+   "[integer]^(2x3x4)" -- a tensor of dimensions 2x3x4
+
+   "number -> number" -- a function type with a single argument
+   "(x: number, number) -> number" -- a function type with a named argument
+   "(number, y:number?) -> number" -- a function type with an optional named argument (can have several optional arguments, at the end)
+   "(number, ...number) -> number" -- a function type with a rest argument (can have only one, and no optional arguments if there is a rest argument).
+   "() -> number" -- a function type with an empty argument list
+
+   "number | boolean" -- a union type
+   "(x: number) & (y: number)" -- an intersection type
+   "number | ((x: number) & (y: number))" -- a union type with an intersection type
+   "(number -> number) | number" -- a union type with a function type
+*/
+export type TypeString = string;
+export type TypeCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
+export type TypeResolver = (name: string) => Type | undefined;

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

@@ -0,0 +1,39 @@
+/* 0.26.2 */
+/** Convert two or more types into a more specific type that is a subtype of
+ *  all the input types. The resulting type is usually more constrained and
+ *  only encompasses values that belong to both input types.
+ *
+ * Examples:
+ * narrow('integer', 'rational') => 'integer'
+ * narrow('number', 'complex') => 'complex'
+ * narrow('number', 'collection') => 'nothing'
+ * narrow('number', 'value') => 'value'
+ * narrow('number', 'expression') => 'expression'
+ * narrow('number', 'string') => 'nothing'
+ *
+ *
+ */
+export declare function narrow(...types: Readonly<Type>[]): Type;
+/**
+ * Convert two or more types into a broader, more general type that can
+ * accommodate all the input types. The resulting type is usually a supertype
+ * that encompasses the possible values of the input types
+ *
+ * Examples:
+ * widen('integer', 'rational') => 'rational'
+ * widen('number', 'complex') => 'complex'
+ * widen('number', 'collection') => 'collection'
+ * widen('number', 'value') => 'value'
+ * widen('number', 'expression') => 'expression'
+ * widen('number', 'string') => 'any'
+ */
+export declare function widen(...types: Readonly<Type>[]): Type;
+export declare function isSignatureType(type: Readonly<Type> | TypeString): type is FunctionSignature;
+export declare function functionSignature(type: Readonly<Type>): Type | undefined;
+export declare function functionResult(type: Readonly<Type>): Type | undefined;
+export declare function collectionElementType(type: Readonly<Type>): Type | undefined;
+export declare function isValidType(t: any): t is Readonly<Type>;
+/**
+ * Add a `toString()` method to the type object
+ */
+export declare function makeType(type: Type): Readonly<Type>;

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

@@ -1 +1,2 @@
-/* 0.25.1 */
+/* 0.26.2 */
+export declare function hidePrivateProperties(obj: any): void;

package/dist/types/compute-engine/assume.d.ts

@@ -1,4 +1,4 @@
-/* 0.25.1 */
+/* 0.26.2 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -7,20 +7,20 @@
  * - `x > 3`
  * - `x + y = 5`
  *
- * Some assumptions are handled separately, specifically, those that can
- * be represented as a symbol definition (equality to an expression,
- * membership to Integers, RealNumbers, etc..., >0, <=0, etc...). The result
- * of these are stored directly in the current scope's symbols dictionary
- * (and an entry for the symbol is created if necessary).
- *
- * New assumptions can 'refine' previous assumptions, that is they are valid
- * if they don't contradict previous assumptions. To set new assumptions
- * that contradict previous ones, you must first `forget` about any symbols
- * in the new assumption.
+ * Assumptions that represent a symbol definition (equality to an expression,
+ * membership to a type, >0, <=0, etc...) are stored directly in the current
+ * scope's symbols dictionary, and an entry for the symbol is created if
+ * necessary.
  *
  * Predicates that involve multiple symbols are simplified (for example
- * `x + y = 5` becomes `x + y - 5 = 0`, then stored in the `assumptions` of the
- * current context).
+ * `x + y = 5` becomes `x + y - 5 = 0`), then stored in the `assumptions`
+ * record of the current context.
+ *
+ * New assumptions can 'refine' previous assumptions, if they don't contradict
+ * previous assumptions.
+ *
+ * To set new assumptions that contradict previous ones, you must first
+ * `forget` about any symbols in the new assumption.
  *
  */
 export declare function assume(proposition: BoxedExpression): AssumeResult;