@cortex-js/compute-engine 0.32.0 → 0.32.1

package/dist/math-json.esm.js

@@ -0,0 +1,130 @@
+/** Compute Engine 0.32.1 */
+
+// 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;
+}
+function isStringObject(expr) {
+  return expr !== null && typeof expr === "object" && "str" in expr;
+}
+function isDictionaryObject(expr) {
+  return expr !== null && typeof expr === "object" && "dict" in expr && typeof expr.dict === "object" && !Array.isArray(expr.dict) && expr.dict !== null;
+}
+function isFunctionObject(expr) {
+  return expr !== null && typeof expr === "object" && "fn" in expr && Array.isArray(expr.fn) && expr.fn.length > 0 && typeof expr.fn[0] === "string";
+}
+function stringValue(expr) {
+  if (expr === null || expr === void 0) return null;
+  if (typeof expr === "object" && "str" in expr) return expr.str;
+  if (typeof expr !== "string") return null;
+  if (expr.length >= 2 && expr.at(0) === "'" && expr.at(-1) === "'")
+    return expr.substring(1, expr.length - 1);
+  if (matchesNumber(expr) || matchesSymbol(expr)) return null;
+  return expr;
+}
+function operator(expr) {
+  if (Array.isArray(expr)) return expr[0];
+  if (expr === null || expr === void 0) return "";
+  if (isFunctionObject(expr)) return expr.fn[0];
+  return "";
+}
+function operands(expr) {
+  if (Array.isArray(expr)) return expr.slice(1);
+  if (expr !== void 0 && isFunctionObject(expr)) return expr.fn.slice(1);
+  return [];
+}
+function operand(expr, n) {
+  if (Array.isArray(expr)) return expr[n] ?? null;
+  if (expr === null || !isFunctionObject(expr)) return null;
+  return expr.fn[n] ?? null;
+}
+function nops(expr) {
+  if (expr === null || expr === void 0) return 0;
+  if (Array.isArray(expr)) return Math.max(0, expr.length - 1);
+  if (isFunctionObject(expr)) return Math.max(0, expr.fn.length - 1);
+  return 0;
+}
+function symbol(expr) {
+  if (typeof expr === "string" && matchesSymbol(expr)) {
+    if (expr.length >= 2 && expr.at(0) === "`" && expr.at(-1) === "`")
+      return expr.slice(1, -1);
+    return expr;
+  }
+  if (expr === null || expr === void 0) return null;
+  if (isSymbolObject(expr)) return expr.sym;
+  return null;
+}
+function keyValuePair(expr) {
+  const h = operator(expr);
+  if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
+    const [k, v] = operands(expr);
+    const key = stringValue(k);
+    if (!key) return null;
+    return [key, v ?? "Nothing"];
+  }
+  return null;
+}
+function dictionaryFromExpression(expr) {
+  if (expr === null) return null;
+  if (isDictionaryObject(expr)) return expr;
+  const kv = keyValuePair(expr);
+  if (kv) return { [kv[0]]: kv[1] };
+  if (operator(expr) === "Dictionary") {
+    const dict = {};
+    const ops = operands(expr);
+    for (let i = 1; i < nops(expr); i++) {
+      const kv2 = keyValuePair(ops[i]);
+      if (kv2) {
+        dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
+      }
+    }
+    return { dict };
+  }
+  return null;
+}
+function mapArgs(expr, fn) {
+  let args = null;
+  if (Array.isArray(expr)) args = expr;
+  if (isFunctionObject(expr)) args = expr.fn;
+  if (args === null) return [];
+  let i = 1;
+  const result = [];
+  while (i < args.length) {
+    result.push(fn(args[i]));
+    i += 1;
+  }
+  return result;
+}
+function matchesNumber(s) {
+  return /^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(s) || /^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(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.32.1";
+export {
+  dictionaryFromExpression,
+  isFunctionObject,
+  isStringObject,
+  isSymbolObject,
+  mapArgs,
+  operand,
+  operator,
+  stringValue,
+  symbol,
+  version
+};

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

@@ -0,0 +1,130 @@
+/** Compute Engine 0.32.1 */
+
+// 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;
+}
+function isStringObject(expr) {
+  return expr !== null && typeof expr === "object" && "str" in expr;
+}
+function isDictionaryObject(expr) {
+  return expr !== null && typeof expr === "object" && "dict" in expr && typeof expr.dict === "object" && !Array.isArray(expr.dict) && expr.dict !== null;
+}
+function isFunctionObject(expr) {
+  return expr !== null && typeof expr === "object" && "fn" in expr && Array.isArray(expr.fn) && expr.fn.length > 0 && typeof expr.fn[0] === "string";
+}
+function stringValue(expr) {
+  if (expr === null || expr === void 0) return null;
+  if (typeof expr === "object" && "str" in expr) return expr.str;
+  if (typeof expr !== "string") return null;
+  if (expr.length >= 2 && expr.at(0) === "'" && expr.at(-1) === "'")
+    return expr.substring(1, expr.length - 1);
+  if (matchesNumber(expr) || matchesSymbol(expr)) return null;
+  return expr;
+}
+function operator(expr) {
+  if (Array.isArray(expr)) return expr[0];
+  if (expr === null || expr === void 0) return "";
+  if (isFunctionObject(expr)) return expr.fn[0];
+  return "";
+}
+function operands(expr) {
+  if (Array.isArray(expr)) return expr.slice(1);
+  if (expr !== void 0 && isFunctionObject(expr)) return expr.fn.slice(1);
+  return [];
+}
+function operand(expr, n) {
+  if (Array.isArray(expr)) return expr[n] ?? null;
+  if (expr === null || !isFunctionObject(expr)) return null;
+  return expr.fn[n] ?? null;
+}
+function nops(expr) {
+  if (expr === null || expr === void 0) return 0;
+  if (Array.isArray(expr)) return Math.max(0, expr.length - 1);
+  if (isFunctionObject(expr)) return Math.max(0, expr.fn.length - 1);
+  return 0;
+}
+function symbol(expr) {
+  if (typeof expr === "string" && matchesSymbol(expr)) {
+    if (expr.length >= 2 && expr.at(0) === "`" && expr.at(-1) === "`")
+      return expr.slice(1, -1);
+    return expr;
+  }
+  if (expr === null || expr === void 0) return null;
+  if (isSymbolObject(expr)) return expr.sym;
+  return null;
+}
+function keyValuePair(expr) {
+  const h = operator(expr);
+  if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
+    const [k, v] = operands(expr);
+    const key = stringValue(k);
+    if (!key) return null;
+    return [key, v ?? "Nothing"];
+  }
+  return null;
+}
+function dictionaryFromExpression(expr) {
+  if (expr === null) return null;
+  if (isDictionaryObject(expr)) return expr;
+  const kv = keyValuePair(expr);
+  if (kv) return { [kv[0]]: kv[1] };
+  if (operator(expr) === "Dictionary") {
+    const dict = {};
+    const ops = operands(expr);
+    for (let i = 1; i < nops(expr); i++) {
+      const kv2 = keyValuePair(ops[i]);
+      if (kv2) {
+        dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
+      }
+    }
+    return { dict };
+  }
+  return null;
+}
+function mapArgs(expr, fn) {
+  let args = null;
+  if (Array.isArray(expr)) args = expr;
+  if (isFunctionObject(expr)) args = expr.fn;
+  if (args === null) return [];
+  let i = 1;
+  const result = [];
+  while (i < args.length) {
+    result.push(fn(args[i]));
+    i += 1;
+  }
+  return result;
+}
+function matchesNumber(s) {
+  return /^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(s) || /^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(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.32.1";
+export {
+  dictionaryFromExpression,
+  isFunctionObject,
+  isStringObject,
+  isSymbolObject,
+  mapArgs,
+  operand,
+  operator,
+  stringValue,
+  symbol,
+  version
+};

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

@@ -0,0 +1,4 @@
+/** MathJSON 0.32.1 */
+    (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 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.32.1";return S(T);})();
+Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/math-json.umd.js

@@ -0,0 +1,155 @@
+/** MathJSON 0.32.1 */
+    (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;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/math-json.ts
+  var math_json_exports = {};
+  __export(math_json_exports, {
+    dictionaryFromExpression: () => dictionaryFromExpression,
+    isFunctionObject: () => isFunctionObject,
+    isStringObject: () => isStringObject,
+    isSymbolObject: () => isSymbolObject,
+    mapArgs: () => mapArgs,
+    operand: () => operand,
+    operator: () => operator,
+    stringValue: () => stringValue,
+    symbol: () => symbol,
+    version: () => version
+  });
+
+  // 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;
+  }
+  function isStringObject(expr) {
+    return expr !== null && typeof expr === "object" && "str" in expr;
+  }
+  function isDictionaryObject(expr) {
+    return expr !== null && typeof expr === "object" && "dict" in expr && typeof expr.dict === "object" && !Array.isArray(expr.dict) && expr.dict !== null;
+  }
+  function isFunctionObject(expr) {
+    return expr !== null && typeof expr === "object" && "fn" in expr && Array.isArray(expr.fn) && expr.fn.length > 0 && typeof expr.fn[0] === "string";
+  }
+  function stringValue(expr) {
+    if (expr === null || expr === void 0) return null;
+    if (typeof expr === "object" && "str" in expr) return expr.str;
+    if (typeof expr !== "string") return null;
+    if (expr.length >= 2 && expr.at(0) === "'" && expr.at(-1) === "'")
+      return expr.substring(1, expr.length - 1);
+    if (matchesNumber(expr) || matchesSymbol(expr)) return null;
+    return expr;
+  }
+  function operator(expr) {
+    if (Array.isArray(expr)) return expr[0];
+    if (expr === null || expr === void 0) return "";
+    if (isFunctionObject(expr)) return expr.fn[0];
+    return "";
+  }
+  function operands(expr) {
+    if (Array.isArray(expr)) return expr.slice(1);
+    if (expr !== void 0 && isFunctionObject(expr)) return expr.fn.slice(1);
+    return [];
+  }
+  function operand(expr, n) {
+    if (Array.isArray(expr)) return expr[n] ?? null;
+    if (expr === null || !isFunctionObject(expr)) return null;
+    return expr.fn[n] ?? null;
+  }
+  function nops(expr) {
+    if (expr === null || expr === void 0) return 0;
+    if (Array.isArray(expr)) return Math.max(0, expr.length - 1);
+    if (isFunctionObject(expr)) return Math.max(0, expr.fn.length - 1);
+    return 0;
+  }
+  function symbol(expr) {
+    if (typeof expr === "string" && matchesSymbol(expr)) {
+      if (expr.length >= 2 && expr.at(0) === "`" && expr.at(-1) === "`")
+        return expr.slice(1, -1);
+      return expr;
+    }
+    if (expr === null || expr === void 0) return null;
+    if (isSymbolObject(expr)) return expr.sym;
+    return null;
+  }
+  function keyValuePair(expr) {
+    const h = operator(expr);
+    if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
+      const [k, v] = operands(expr);
+      const key = stringValue(k);
+      if (!key) return null;
+      return [key, v ?? "Nothing"];
+    }
+    return null;
+  }
+  function dictionaryFromExpression(expr) {
+    if (expr === null) return null;
+    if (isDictionaryObject(expr)) return expr;
+    const kv = keyValuePair(expr);
+    if (kv) return { [kv[0]]: kv[1] };
+    if (operator(expr) === "Dictionary") {
+      const dict = {};
+      const ops = operands(expr);
+      for (let i = 1; i < nops(expr); i++) {
+        const kv2 = keyValuePair(ops[i]);
+        if (kv2) {
+          dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
+        }
+      }
+      return { dict };
+    }
+    return null;
+  }
+  function mapArgs(expr, fn) {
+    let args = null;
+    if (Array.isArray(expr)) args = expr;
+    if (isFunctionObject(expr)) args = expr.fn;
+    if (args === null) return [];
+    let i = 1;
+    const result = [];
+    while (i < args.length) {
+      result.push(fn(args[i]));
+      i += 1;
+    }
+    return result;
+  }
+  function matchesNumber(s) {
+    return /^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(s) || /^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(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.32.1";
+  return __toCommonJS(math_json_exports);
+})();
+Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

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

@@ -0,0 +1,41 @@
+/* 0.32.1 */
+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";
+export declare const BLUE = "\u001B[34;1m";
+export declare const MAGENTA = "\u001B[35;1m";
+export declare const CYAN = "\u001B[36;1m";
+export declare const INVERSE_RED = "\u001B[101;97m";
+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 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/configuration-change.d.ts

@@ -0,0 +1,28 @@
+/* 0.32.1 */
+    private _listeners;
+    private _pending;
+    private _version;
+    /**
+     * Registers a listener for configuration changes.
+     * Returns a function to unsubscribe the listener.
+     * Prevents duplicate subscriptions: if the listener is already registered,
+     * returns the existing unsubscribe logic without adding a duplicate.
+     */
+    listen(listener: ConfigurationChangeListener): () => void;
+    private _unsubscribe;
+    /**
+     * Notifies all live listeners of a configuration change.
+     * Also prunes any dead references from the list.
+     * Prevents infinite loops from recursive notify() calls.
+     */
+    notify(): void;
+    /**
+     * Immediately notifies all live listeners of a configuration change.
+     * Also prunes any dead references from the list.
+     * Increments the version and clears the pending flag.
+     */
+    notifyNow(): void;
+}
+export interface ConfigurationChangeListener {
+    onConfigurationChange?: () => void;
+}

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

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

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

@@ -0,0 +1,15 @@
+/* 0.32.1 */
+/**
+ * Return a string or an array of graphemes.
+ *
+ * This includes:
+ * - emoji with skin and hair modifiers
+ * - emoji combination (for example "female pilot")
+ * - text emoji with an emoji presentation style modifier
+ *      - U+1F512 U+FE0E 🔒︎
+ *      - U+1F512 U+FE0F 🔒️
+ * - flags represented as two regional indicator codepoints
+ * - flags represented as a flag emoji + zwj + an emoji tag
+ * - other combinations (for example, rainbow flag)
+ */
+export declare function splitGraphemes(string: string): string | string[];

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

@@ -0,0 +1,20 @@
+/* 0.32.1 */
+    cause: unknown;
+    value: T;
+    constructor({ message, value, cause, }?: {
+        message?: string;
+        value?: T;
+        cause?: unknown;
+    });
+}
+/**
+ * Executes a generator asynchronously with timeout and abort signal support.
+ *
+ * @param gen - The generator to execute.
+ * @param timeLimitMs - The maximum time (in milliseconds) allowed for execution.
+ * @param signal - An AbortSignal to cancel execution prematurely.
+ * @returns The final value produced by the generator.
+ * @throws CancellationError if the operation is canceled or times out.
+ */
+export declare function runAsync<T>(gen: Generator<T>, timeLimitMs: number, signal?: AbortSignal): Promise<T>;
+export declare function run<T>(gen: Generator<T>, timeLimitMs: number): T;

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

@@ -0,0 +1,10 @@
+/* 0.32.1 */
+    infer Head,
+    ...infer Rem
+] ? MergeTypes<Rem, Res & Head> : Res;
+/** @internal  */
+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

@@ -0,0 +1,96 @@
+/* 0.32.1 */
+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');
+/** @category Error Handling */
+export type SignalMessage = SignalCode | [SignalCode, ...any[]];
+/** @category Error Handling */
+export type SignalOrigin = {
+    url?: string;
+    source?: string;
+    offset?: number;
+    line?: number;
+    column?: number;
+    around?: string;
+};
+/** @category Error Handling */
+export type Signal = {
+    severity?: 'warning' | 'error';
+    /** An error/warning code or, a code with one or more arguments specific to
+     * the signal code.
+     */
+    message: SignalMessage;
+    /** If applicable, the head of the function about which the
+     * signal was raised
+     */
+    head?: string;
+    /** Location where the signal was raised. */
+    origin?: SignalOrigin;
+};
+/** @category Error Handling */
+export type ErrorSignal = Signal & {
+    severity: 'error';
+};
+/** @category Error Handling */
+export type WarningSignal = Signal & {
+    severity: 'warning';
+};
+/** @category Error Handling */
+export type WarningSignalHandler = (warnings: WarningSignal[]) => void;
+/**
+ * The error codes can be used in an `ErrorCode` expression:
+ *
+ *        `["ErrorCode", "'syntax-error'", arg1]`
+ *
+ * It evaluates to a localized, human-readable string.
+ *
+ *
+ * * `unknown-symbol`: a symbol was encountered which does not have a
+ * definition.
+ *
+ * * `unknown-operator`: a presumed operator was encountered which does not
+ * have a definition.
+ *
+ * * `unknown-function`: a LaTeX command was encountered which does not
+ * have a definition.
+ *
+ * * `unexpected-command`: a LaTeX command was encountered when only a string
+ * was expected
+ *
+ * * `unexpected-superscript`: a superscript was encountered in an unexpected
+ * context, or no `powerFunction` was defined. By default, superscript can
+ * be applied to numbers, symbols or expressions, but not to operators (e.g.
+ * `2+^34`) or to punctuation.
+ *
+ * * `unexpected-subscript`: a subscript was encountered in an unexpected
+ * context or no 'subscriptFunction` was defined. By default, subscripts
+ * are not expected on numbers, operators or symbols. Some commands (e.g. `\sum`)
+ * do expected a subscript.
+ *
+ * * `unexpected-sequence`: some adjacent elements were encountered (for
+ * example `xy`), but the elements could not be combined. By default, adjacent
+ * symbols are combined with `Multiply`, but adjacent numbers or adjacent
+ * operators are not combined.
+ *
+ * * `expected-argument`: a LaTeX command that requires one or more argument
+ * was encountered without the required arguments.
+ *
+ * * `expected-operand`: an operator was encountered without its required
+ * operands.
+ *
+ * * `non-associative-operator`: an operator which is not associative was
+ * encountered in an associative context, for example: `a < b < c` (assuming
+ * `<` is defined as non-associative)
+ *
+ * * `postfix-operator-requires-one-operand`: a postfix operator which requires
+ * a single argument was encountered with no arguments or more than one argument
+ *
+ * * `prefix-operator-requires-one-operand`: a prefix operator which requires
+ * a single argument was encountered with no arguments or more than one argument
+ *
+ * * `base-out-of-range`:  The base is expected to be between 2 and 36.
+ *
+ * @category Error Handling
+ *
+ */
+export type ErrorCode = 'expected-argument' | 'unexpected-argument' | 'expected-operator' | 'expected-operand' | 'invalid-name' | 'invalid-dictionary-entry' | 'unknown-symbol' | 'unknown-operator' | 'unknown-function' | 'unknown-command' | 'unexpected-command' | 'unbalanced-symbols' | 'unexpected-superscript' | 'unexpected-subscript' | 'unexpected-sequence' | 'non-associative-operator' | 'function-has-too-many-arguments' | 'function-has-too-few-arguments' | 'operator-requires-one-operand' | 'infix-operator-requires-two-operands' | 'prefix-operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'associative-function-has-too-few-arguments' | 'commutative-function-has-too-few-arguments' | 'threadable-function-has-too-few-arguments' | 'hold-first-function-has-too-few-arguments' | 'hold-rest-function-has-too-few-arguments' | 'base-out-of-range' | 'syntax-error';