@mojir/lits 2.1.31 → 2.1.33

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.1.31";
+var version = "2.1.33";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -187,21 +187,21 @@ var specialExpressionTypes = {
     'cond': 4,
     '0_def': 5,
     'defined?': 6,
-    '0_defn': 7,
-    'block': 8,
-    'doseq': 9,
-    '0_fn': 10,
-    'for': 11,
-    'function': 12,
-    'if': 13,
-    'let': 14,
-    'loop': 15,
-    'object': 16,
-    'recur': 17,
-    'switch': 18,
-    'throw': 19,
-    'try': 20,
-    'unless': 21,
+    // '0_defn': 7,
+    'block': 7,
+    'doseq': 8,
+    '0_lambda': 9,
+    'for': 10,
+    // 'function': 10,
+    'if': 11,
+    'let': 12,
+    'loop': 13,
+    'object': 14,
+    'recur': 15,
+    'switch': 16,
+    'throw': 17,
+    'try': 18,
+    'unless': 19,
 };
 
 var NodeTypes = {
@@ -9239,7 +9239,7 @@ var collatzSequence = {
     'noNth': true,
 };
 
-function isPrime$1(num) {
+function isPrime(num) {
     if (num <= 1) {
         return false;
     }
@@ -9261,18 +9261,18 @@ var primeSequence = {
         var primes = [];
         var num = 2;
         while (primes.length < length) {
-            if (isPrime$1(num)) {
+            if (isPrime(num)) {
                 primes.push(num);
             }
             num += 1;
         }
         return primes;
     },
-    'nth:prime?': function (n) { return isPrime$1(n); },
+    'nth:prime?': function (n) { return isPrime(n); },
     'nth:prime-take-while': function (takeWhile) {
         var primes = [];
         for (var i = 2;; i += 1) {
-            if (!isPrime$1(i)) {
+            if (!isPrime(i)) {
                 continue;
             }
             if (!takeWhile(i, primes.length)) {
@@ -9288,7 +9288,7 @@ function isComposite(num) {
     if (num <= 1) {
         return false;
     }
-    return !isPrime$1(num);
+    return !isPrime(num);
 }
 var compositeSequence = {
     'nth:composite-seq': function (length) {
@@ -11785,140 +11785,13 @@ var doSpecialExpression = {
     },
 };
 
-var nonNumberReservedSymbolRecord = {
-    true: true,
-    false: false,
-    null: null,
-    else: null,
-    case: null,
-    each: null,
-    in: null,
-    when: null,
-    while: null,
-    catch: null,
-    function: null,
-    export: null,
-    as: null,
-    _: null,
-};
-var phi = (1 + Math.sqrt(5)) / 2;
-var numberReservedSymbolRecord = {
-    'E': Math.E,
-    '-E': -Math.E,
-    'ε': Math.E,
-    '-ε': -Math.E,
-    'PI': Math.PI,
-    '-PI': -Math.PI,
-    'π': Math.PI,
-    '-π': -Math.PI,
-    'PHI': phi,
-    '-PHI': -phi,
-    'φ': phi,
-    '-φ': -phi,
-    'POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
-    '∞': Number.POSITIVE_INFINITY,
-    'NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
-    '-∞': Number.NEGATIVE_INFINITY,
-    'MAX_SAFE_INTEGER': Number.MAX_SAFE_INTEGER,
-    'MIN_SAFE_INTEGER': Number.MIN_SAFE_INTEGER,
-    'MAX_VALUE': Number.MAX_VALUE,
-    'MIN_VALUE': Number.MIN_VALUE,
-    'NaN': Number.NaN,
-};
-var reservedSymbolRecord = __assign(__assign({}, nonNumberReservedSymbolRecord), numberReservedSymbolRecord);
-function isReservedSymbol(symbol) {
-    return symbol in reservedSymbolRecord;
-}
-function isNumberReservedSymbol(symbol) {
-    return symbol in numberReservedSymbolRecord;
-}
-
-function assertNameNotDefined(name, contextStack, builtin, sourceCodeInfo) {
-    if (typeof name !== 'string')
-        return;
-    // TODO only subset of special expressions are necessary to check (CommonSpecialExpressionType)
-    if (specialExpressionTypes[name])
-        throw new LitsError("Cannot define variable ".concat(name, ", it's a special expression."), sourceCodeInfo);
-    if (builtin.normalExpressions[name])
-        throw new LitsError("Cannot define variable ".concat(name, ", it's a builtin function."), sourceCodeInfo);
-    if (isReservedSymbol(name))
-        throw new LitsError("Cannot define variable ".concat(name, ", it's a reserved name."), sourceCodeInfo);
-    if (contextStack.globalContext[name])
-        throw new LitsError("Name already defined \"".concat(name, "\"."), sourceCodeInfo);
-}
-
-var functionSpecialExpression = {
-    arity: {},
-    evaluate: function (node, contextStack, _a) {
-        var _b, _c;
-        var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
-        var _d = __read(node[1], 4), functionSymbol = _d[1], fn = _d[2], docString = _d[3];
-        assertUserDefinedSymbolNode(functionSymbol, node[2]);
-        assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
-        var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
-        var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
-        var max = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; }) ? undefined : evaluatedFunction[0].length;
-        var arity = { min: min > 0 ? min : undefined, max: max };
-        var litsFunction = (_b = {},
-            _b[FUNCTION_SYMBOL] = true,
-            _b.sourceCodeInfo = node[2],
-            _b.functionType = 'UserDefined',
-            _b.name = functionSymbol[1],
-            _b.evaluatedfunction = evaluatedFunction,
-            _b.arity = arity,
-            _b.docString = docString,
-            _b);
-        contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
-        return litsFunction;
-    },
-    getUndefinedSymbols: function (node, contextStack, _a) {
-        var _b, _c;
-        var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
-        var functionName = node[1][1][1];
-        contextStack.addValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
-        var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
-        return getFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
-    },
-};
-var defnSpecialExpression = {
-    arity: {},
-    evaluate: function (node, contextStack, _a) {
-        var _b, _c;
-        var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
-        var _d = __read(node[1], 4), functionSymbol = _d[1], fn = _d[2], docString = _d[3];
-        assertUserDefinedSymbolNode(functionSymbol, node[2]);
-        assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
-        var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
-        var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
-        var arity = { min: min };
-        var litsFunction = (_b = {},
-            _b[FUNCTION_SYMBOL] = true,
-            _b.sourceCodeInfo = node[2],
-            _b.functionType = 'UserDefined',
-            _b.name = functionSymbol[1],
-            _b.evaluatedfunction = evaluatedFunction,
-            _b.arity = arity,
-            _b.docString = docString,
-            _b);
-        contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
-        return litsFunction;
-    },
-    getUndefinedSymbols: function (node, contextStack, _a) {
-        var _b, _c;
-        var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
-        var functionName = node[1][1][1];
-        var fn = node[1][2];
-        contextStack.exportValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
-        var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
-        return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
-    },
-};
-var fnSpecialExpression = {
+var lambdaSpecialExpression = {
     arity: {},
     evaluate: function (node, contextStack, _a) {
         var _b;
         var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
         var fn = node[1][1];
+        var docString = node[1][2];
         var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
         var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
         var max = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; }) ? undefined : evaluatedFunction[0].length;
@@ -11930,8 +11803,9 @@ var fnSpecialExpression = {
             _b.name = undefined,
             _b.evaluatedfunction = evaluatedFunction,
             _b.arity = arity,
-            _b.docString = '',
+            _b.docString = docString,
             _b);
+        evaluatedFunction[2].self = { value: litsFunction };
         return litsFunction;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
@@ -11962,17 +11836,16 @@ function evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evalua
     ];
     return evaluatedFunction;
 }
-function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, functionNameContext) {
+function getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode) {
     var result = new Set();
-    var contextStackWithFunctionName = functionNameContext ? contextStack.create(functionNameContext) : contextStack;
-    var newContext = {};
+    var newContext = { self: { value: null } };
     fn[0].forEach(function (arg) {
         Object.assign(newContext, getAllBindingTargetNames(arg));
         walkDefaults(arg, function (defaultNode) {
             addToSet(result, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
         });
     });
-    var newContextStack = contextStackWithFunctionName.create(newContext);
+    var newContextStack = contextStack.create(newContext);
     var overloadResult = getUndefinedSymbols(fn[1], newContextStack, builtin, evaluateNode);
     addToSet(result, overloadResult);
     return result;
@@ -12059,22 +11932,9 @@ var loopSpecialExpression = {
         var newContextStack = contextStack.create(bindingContext);
         var body = node[1][2];
         var _loop_1 = function () {
-            var e_1, _b;
             var result = null;
             try {
-                try {
-                    for (var body_1 = (e_1 = void 0, __values(body)), body_1_1 = body_1.next(); !body_1_1.done; body_1_1 = body_1.next()) {
-                        var form = body_1_1.value;
-                        result = evaluateNode(form, newContextStack);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (body_1_1 && !body_1_1.done && (_b = body_1.return)) _b.call(body_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
+                result = evaluateNode(body, newContextStack);
             }
             catch (error) {
                 if (error instanceof RecurSignal) {
@@ -12083,20 +11943,20 @@ var loopSpecialExpression = {
                         throw new LitsError("recur expected ".concat(bindingNodes.length, " parameters, got ").concat(valueToString(params_1.length)), node[2]);
                     }
                     bindingNodes.forEach(function (bindingNode, index) {
-                        var e_2, _a;
+                        var e_1, _a;
                         var valueRecord = evalueateBindingNodeValues(bindingNode[1][0], asAny(params_1[index]), function (Node) { return evaluateNode(Node, contextStack); });
                         try {
-                            for (var _b = (e_2 = void 0, __values(Object.entries(valueRecord))), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            for (var _b = (e_1 = void 0, __values(Object.entries(valueRecord))), _c = _b.next(); !_c.done; _c = _b.next()) {
                                 var _d = __read(_c.value, 2), name_1 = _d[0], value = _d[1];
                                 bindingContext[name_1].value = value;
                             }
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
                         finally {
                             try {
                                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                             }
-                            finally { if (e_2) throw e_2.error; }
+                            finally { if (e_1) throw e_1.error; }
                         }
                     });
                     return "continue";
@@ -12124,7 +11984,7 @@ var loopSpecialExpression = {
         }, {});
         var bindingValueNodes = bindingNodes.map(function (bindingNode) { return bindingNode[1][1]; });
         var bindingsResult = getUndefinedSymbols(bindingValueNodes, contextStack, builtin, evaluateNode);
-        var paramsResult = getUndefinedSymbols(node[1][2], contextStack.create(newContext), builtin, evaluateNode);
+        var paramsResult = getUndefinedSymbols([node[1][2]], contextStack.create(newContext), builtin, evaluateNode);
         return joinSets(bindingsResult, paramsResult);
     },
 };
@@ -12519,12 +12379,12 @@ var specialExpressions = [
     condSpecialExpression,
     defSpecialExpression,
     definedSpecialExpression,
-    defnSpecialExpression,
+    // defnSpecialExpression,
     doSpecialExpression,
     doseqSpecialExpression,
-    fnSpecialExpression,
+    lambdaSpecialExpression,
     forSpecialExpression,
-    functionSpecialExpression,
+    // functionSpecialExpression,
     ifSpecialExpression,
     letSpecialExpression,
     loopSpecialExpression,
@@ -12546,6 +12406,53 @@ new Set(specialExpressionKeys);
 // TODO, remove
 // console.log('builtin', [...specialExpressionKeys, ...normalExpressionKeys].length)
 
+var nonNumberReservedSymbolRecord = {
+    true: true,
+    false: false,
+    null: null,
+    else: null,
+    case: null,
+    each: null,
+    in: null,
+    when: null,
+    while: null,
+    catch: null,
+    function: null,
+    export: null,
+    as: null,
+    then: null,
+    end: null,
+    _: null,
+};
+var phi = (1 + Math.sqrt(5)) / 2;
+var numberReservedSymbolRecord = {
+    'E': Math.E,
+    '-E': -Math.E,
+    'ε': Math.E,
+    '-ε': -Math.E,
+    'PI': Math.PI,
+    '-PI': -Math.PI,
+    'π': Math.PI,
+    '-π': -Math.PI,
+    'PHI': phi,
+    '-PHI': -phi,
+    'φ': phi,
+    '-φ': -phi,
+    'POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
+    '∞': Number.POSITIVE_INFINITY,
+    'NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
+    '-∞': Number.NEGATIVE_INFINITY,
+    'MAX_SAFE_INTEGER': Number.MAX_SAFE_INTEGER,
+    'MIN_SAFE_INTEGER': Number.MIN_SAFE_INTEGER,
+    'MAX_VALUE': Number.MAX_VALUE,
+    'MIN_VALUE': Number.MIN_VALUE,
+    'NaN': Number.NaN,
+};
+var reservedSymbolRecord = __assign(__assign({}, nonNumberReservedSymbolRecord), numberReservedSymbolRecord);
+function isNumberReservedSymbol(symbol) {
+    return symbol in numberReservedSymbolRecord;
+}
+
 var functionExecutors = {
     NativeJsFunction: function (fn, params, sourceCodeInfo) {
         var _a;
@@ -12994,6 +12901,9 @@ var ContextStackImpl = /** @class */ (function () {
                 if (normalExpressionKeys.includes(name_1)) {
                     throw new LitsError("Cannot shadow builtin function \"".concat(name_1, "\""), sourceCodeInfo);
                 }
+                if (name_1 === 'self') {
+                    throw new LitsError("Cannot shadow builtin value \"".concat(name_1, "\""), sourceCodeInfo);
+                }
                 this.globalContext[name_1] = { value: value };
             }
         }
@@ -13023,6 +12933,9 @@ var ContextStackImpl = /** @class */ (function () {
                 if (normalExpressionKeys.includes(name_2)) {
                     throw new LitsError("Cannot shadow builtin function \"".concat(name_2, "\""), sourceCodeInfo);
                 }
+                if (name_2 === 'self') {
+                    throw new LitsError("Cannot shadow builtin value \"".concat(name_2, "\""), sourceCodeInfo);
+                }
                 currentContext[name_2] = { value: toAny(value) };
             }
         }
@@ -14018,9 +13931,6 @@ var Parser = /** @class */ (function () {
                     break;
             }
         }
-        else if (isReservedSymbolToken(firstToken, 'function')) {
-            return this.parseFunction(firstToken);
-        }
         else if (isReservedSymbolToken(firstToken, 'export')) {
             if (!moduleScope) {
                 throw new LitsError('export is only allowed in module scope', firstToken[2]);
@@ -14313,9 +14223,8 @@ var Parser = /** @class */ (function () {
                     var _c = __read(params, 1), param = _c[0];
                     return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
                 }
-                case specialExpressionTypes['0_fn']:
+                case specialExpressionTypes['0_lambda']:
                 case specialExpressionTypes['0_def']:
-                case specialExpressionTypes['0_defn']:
                     throw new LitsError("".concat(type, " is not allowed"), symbol[2]);
                 /* v8 ignore next 2 */
                 default:
@@ -14342,11 +14251,27 @@ var Parser = /** @class */ (function () {
                 return null;
             }
             this.advance();
-            var body = this.parseExpression();
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
+            var nodes = void 0;
+            var docString = '';
+            if (isLBraceToken(this.peek())) {
+                var parsedBlock = this.parseBlock(true);
+                docString = parsedBlock[1];
+                nodes = parsedBlock[0][1][1];
+            }
+            else {
+                nodes = [this.parseExpression()];
+            }
+            return withSourceCodeInfo([
+                NodeTypes.SpecialExpression,
+                [
+                    specialExpressionTypes['0_lambda'],
+                    [
                         functionArguments,
-                        [body],
-                    ]]], firstToken[2]);
+                        nodes,
+                    ],
+                    docString,
+                ],
+            ], firstToken[2]);
         }
         catch (_a) {
             return null;
@@ -14395,7 +14320,16 @@ var Parser = /** @class */ (function () {
         var firstToken = this.asToken(this.peek());
         this.advance();
         var startPos = this.parseState.position;
-        var exprNode = this.parseExpression();
+        var nodes;
+        var docString = '';
+        if (isLBraceToken(this.peek())) {
+            var parsedBlock = this.parseBlock(true);
+            docString = parsedBlock[1];
+            nodes = parsedBlock[0][1][1];
+        }
+        else {
+            nodes = [this.parseExpression()];
+        }
         var endPos = this.parseState.position - 1;
         var arity = 0;
         var dollar1 = 'NOT_SET'; // referring to argument bindings. $ = NAKED, $1, $2, $3, etc = WITH_1
@@ -14426,10 +14360,10 @@ var Parser = /** @class */ (function () {
                 functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, "$".concat(i)], undefined]], firstToken[2]));
             }
         }
-        var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_fn'], [
+        var node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_lambda'], [
                     functionArguments,
-                    [exprNode],
-                ]]], firstToken[2]);
+                    nodes,
+                ], docString]], firstToken[2]);
         return node;
     };
     Parser.prototype.parseOptionalDefaulValue = function () {
@@ -14620,21 +14554,10 @@ var Parser = /** @class */ (function () {
         }
         assertRParenToken(token);
         this.advance();
-        assertLBraceToken(this.peek());
+        assertOperatorToken(this.peek(), '->');
         this.advance();
-        var params = [];
-        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
-            params.push(this.parseExpression());
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else if (!isRBraceToken(this.peek())) {
-                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-            }
-        }
-        assertRBraceToken(this.peek());
-        this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, params]], firstToken[2]);
+        var expression = this.parseExpression();
+        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, expression]], firstToken[2]);
     };
     Parser.prototype.parseTry = function (token) {
         this.advance();
@@ -14665,7 +14588,7 @@ var Parser = /** @class */ (function () {
                 throw new LitsError('Duplicate binding', loopBinding[0][2]);
             }
             forLoopBindings.push(loopBinding);
-            if (isOperatorToken(this_1.peek(), ';')) {
+            if (isOperatorToken(this_1.peek(), ',')) {
                 this_1.advance();
             }
         };
@@ -14675,6 +14598,8 @@ var Parser = /** @class */ (function () {
         }
         assertRParenToken(this.peek());
         this.advance();
+        assertOperatorToken(this.peek(), '->');
+        this.advance();
         var expression = this.parseExpression();
         return isDoseq
             ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.doseq, forLoopBindings, expression]], firstToken[2])
@@ -14684,20 +14609,7 @@ var Parser = /** @class */ (function () {
         var bindingNode = this.parseBinding();
         var modifiers = [];
         var token = this.asToken(this.peek());
-        if (!isRParenToken(token) && !isOperatorToken(this.peek(), ';') && !isOperatorToken(token, ',')) {
-            throw new LitsError('Expected ")", ";" or ","', token[2]);
-        }
-        if (isOperatorToken(token, ',')) {
-            this.advance();
-            token = this.asToken(this.peek());
-        }
-        if (!isSymbolToken(token, 'let')
-            && !isReservedSymbolToken(token, 'when')
-            && !isReservedSymbolToken(token, 'while')
-            && !isRParenToken(token)
-            && !isOperatorToken(token, ';')) {
-            throw new LitsError('Expected symbol ";", ")", let, when or while', token[2]);
-        }
+        this.assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
         var letBindings = [];
         if (token[1] === 'let') {
             modifiers.push('&let');
@@ -14710,12 +14622,7 @@ var Parser = /** @class */ (function () {
                 }
                 letBindings.push(letNode[1][1]);
                 token = this_2.asToken(this_2.peek());
-                if (!isRParenToken(token) && !isOperatorToken(token, ';') && !isOperatorToken(token, ',')) {
-                    throw new LitsError('Expected ")", ";" or ","', token[2]);
-                }
-                if (isOperatorToken(token, ',')) {
-                    this_2.advance();
-                }
+                this_2.assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
                 token = this_2.asToken(this_2.peek());
             };
             var this_2 = this;
@@ -14729,33 +14636,57 @@ var Parser = /** @class */ (function () {
             || isReservedSymbolToken(token, 'while')) {
             this.advance();
             if (token[1] === 'when') {
-                if (modifiers.includes('&when')) {
-                    throw new LitsError('Multiple when modifiers in for loop', token[2]);
-                }
                 modifiers.push('&when');
                 whenNode = this.parseExpression();
             }
             else {
-                if (modifiers.includes('&while')) {
-                    throw new LitsError('Multiple while modifiers in for loop', token[2]);
-                }
                 modifiers.push('&while');
                 whileNode = this.parseExpression();
             }
             token = this.asToken(this.peek());
-            if (!isRParenToken(token) && !isOperatorToken(token, ';') && !isOperatorToken(token, ',')) {
-                throw new LitsError('Expected do or comma', token[2]);
-            }
-            if (isOperatorToken(token, ',')) {
-                this.advance();
-            }
+            var symbols = modifiers.includes('&when') && modifiers.includes('&while')
+                ? []
+                : modifiers.includes('&when')
+                    ? ['while']
+                    : ['when'];
+            this.assertInternalLoopBindingDelimiter(token, symbols);
             token = this.asToken(this.peek());
         }
-        if (!isRParenToken(token) && !isOperatorToken(token, ';')) {
-            throw new LitsError('Expected "{" or ";"', token[2]);
-        }
+        this.assertInternalLoopBindingDelimiter(token, []);
         return [bindingNode, letBindings, whenNode, whileNode];
     };
+    Parser.prototype.assertInternalLoopBindingDelimiter = function (token, symbols) {
+        if (!this.isInternalLoopBindingDelimiter(token, symbols)) {
+            var symbolsString = "".concat(__spreadArray(__spreadArray([], __read(symbols), false), [','], false).map(function (symbol) { return "\"".concat(symbol, "\""); }).join(', '), " or \")\"");
+            throw new LitsError("Expected symbol ".concat(symbolsString), token[2]);
+        }
+    };
+    Parser.prototype.isInternalLoopBindingDelimiter = function (token, symbols) {
+        var e_1, _a;
+        // end of loop binding
+        if (isOperatorToken(token, ',') || isRParenToken(token)) {
+            return true;
+        }
+        try {
+            for (var symbols_1 = __values(symbols), symbols_1_1 = symbols_1.next(); !symbols_1_1.done; symbols_1_1 = symbols_1.next()) {
+                var symbol = symbols_1_1.value;
+                if (symbol === 'let' && isSymbolToken(token, 'let')) {
+                    return true;
+                }
+                if (['when', 'while'].includes(symbol) && isReservedSymbolToken(token, symbol)) {
+                    return true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (symbols_1_1 && !symbols_1_1.done && (_a = symbols_1.return)) _a.call(symbols_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    };
     Parser.prototype.parseBinding = function () {
         var firstToken = asSymbolToken(this.peek());
         var name = asUserDefinedSymbolNode(this.parseSymbol());
@@ -14774,10 +14705,8 @@ var Parser = /** @class */ (function () {
     Parser.prototype.parseIfOrUnless = function (token) {
         var isUnless = token[1] === 'unless';
         this.advance();
-        assertLParenToken(this.peek());
-        this.advance();
         var condition = this.parseExpression();
-        assertRParenToken(this.peek());
+        assertReservedSymbolToken(this.peek(), 'then');
         this.advance();
         var thenExpression = this.parseExpression();
         var elseExpression;
@@ -14790,100 +14719,74 @@ var Parser = /** @class */ (function () {
             : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [condition, thenExpression, elseExpression]]], token[2]);
     };
     Parser.prototype.parseCond = function (token) {
-        this.advance();
-        assertLBraceToken(this.peek());
         this.advance();
         var params = [];
-        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
+        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
             assertReservedSymbolToken(this.peek(), 'case');
             this.advance();
             var caseExpression = this.parseExpression();
-            assertOperatorToken(this.peek(), ':');
+            assertReservedSymbolToken(this.peek(), 'then');
             this.advance();
             var expressions = [];
             while (!this.isAtEnd()
                 && !isReservedSymbolToken(this.peek(), 'case')
-                && !isRBraceToken(this.peek())) {
+                && !isReservedSymbolToken(this.peek(), 'end')) {
                 expressions.push(this.parseExpression());
                 if (isOperatorToken(this.peek(), ';')) {
                     this.advance();
                 }
-                else if (!isReservedSymbolToken(this.peek(), 'case') && !isRBraceToken(this.peek())) {
-                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
+                else if (!isReservedSymbolToken(this.peek(), 'case') && !isReservedSymbolToken(this.peek(), 'end')) {
+                    throw new LitsError('Expected case or end', this.peekSourceCodeInfo());
                 }
             }
             var thenExpression = expressions.length === 1
                 ? expressions[0]
                 : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]);
             params.push([caseExpression, thenExpression]);
-            if (isRBraceToken(this.peek())) {
+            if (isReservedSymbolToken(this.peek(), 'end')) {
                 break;
             }
             assertReservedSymbolToken(this.peek(), 'case');
         }
-        assertRBraceToken(this.peek());
+        assertReservedSymbolToken(this.peek());
         this.advance();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.cond, params]], token[2]);
     };
     Parser.prototype.parseSwitch = function (token) {
-        this.advance();
-        assertLParenToken(this.peek());
         this.advance();
         var valueExpression = this.parseExpression();
-        assertRParenToken(this.peek());
-        this.advance();
-        assertLBraceToken(this.peek());
-        this.advance();
         var params = [];
-        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
+        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
             assertReservedSymbolToken(this.peek(), 'case');
             this.advance();
             var caseExpression = this.parseExpression();
-            assertOperatorToken(this.peek(), ':');
+            assertReservedSymbolToken(this.peek(), 'then');
             this.advance();
             var expressions = [];
             while (!this.isAtEnd()
                 && !isReservedSymbolToken(this.peek(), 'case')
-                && !isRBraceToken(this.peek())) {
+                && !isReservedSymbolToken(this.peek(), 'end')) {
                 expressions.push(this.parseExpression());
                 if (isOperatorToken(this.peek(), ';')) {
                     this.advance();
                 }
-                else if (!isReservedSymbolToken(this.peek(), 'case') && !isRBraceToken(this.peek())) {
-                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
+                else if (!isReservedSymbolToken(this.peek(), 'case') && !isReservedSymbolToken(this.peek(), 'end')) {
+                    throw new LitsError('Expected case or end', this.peekSourceCodeInfo());
                 }
             }
             var thenExpression = expressions.length === 1
                 ? expressions[0]
                 : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]);
             params.push([caseExpression, thenExpression]);
-            if (isRBraceToken(this.peek())) {
+            if (isReservedSymbolToken(this.peek(), 'end')) {
                 break;
             }
             assertReservedSymbolToken(this.peek(), 'case');
         }
-        assertRBraceToken(this.peek());
+        assertReservedSymbolToken(this.peek(), 'end');
         this.advance();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.switch, valueExpression, params]], token[2]);
     };
-    Parser.prototype.parseFunction = function (token) {
-        this.advance();
-        var symbol = this.parseSymbol();
-        var functionArguments = this.parseFunctionArguments();
-        var _a = __read(this.parseBlock(true), 2), block = _a[0], docString = _a[1];
-        return withSourceCodeInfo([
-            NodeTypes.SpecialExpression,
-            [
-                specialExpressionTypes.function,
-                symbol,
-                [
-                    functionArguments,
-                    block[1][1],
-                ],
-                docString,
-            ],
-        ], token[2]);
-    };
     Parser.prototype.isAtEnd = function () {
         return this.parseState.position >= this.tokenStream.tokens.length;
     };
@@ -14896,7 +14799,7 @@ var Parser = /** @class */ (function () {
             return [';', ',', ':'].includes(token[1]);
         }
         if (isReservedSymbolToken(token)) {
-            return ['else', 'when', 'while', 'case', 'catch'].includes(token[1]);
+            return ['else', 'when', 'while', 'case', 'catch', 'let', 'then'].includes(token[1]);
         }
         return false;
     };
@@ -14907,13 +14810,8 @@ var Parser = /** @class */ (function () {
             var letNode = this.parseLet(asSymbolToken(token));
             return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], exportToken[2]);
         }
-        else if (isReservedSymbolToken(token, 'function')) {
-            var functionNode = this.parseFunction(token);
-            functionNode[1][0] = specialExpressionTypes['0_defn'];
-            return functionNode;
-        }
         else {
-            throw new LitsError('Expected let or function', this.peekSourceCodeInfo());
+            throw new LitsError('Expected let', this.peekSourceCodeInfo());
         }
     };
     Parser.prototype.stringToSymbolNode = function (value, sourceCodeInfo) {
@@ -15103,7 +15001,7 @@ var AutoCompleter = /** @class */ (function () {
     };
     AutoCompleter.prototype.generateSuggestions = function (params) {
         var _this = this;
-        var blacklist = new Set(['0_def', '0_defn', '0_fn']);
+        var blacklist = new Set(['0_def', '0_defn', '0_lambda']);
         var startsWithCaseSensitive = this.generateWithPredicate(params, function (suggestion) {
             return !blacklist.has(suggestion) && suggestion.startsWith(_this.searchString);
         });
@@ -15732,7 +15630,7 @@ var arrayReference = {
             '[[3, 2, 1, 0], [6, 5, 4], [9, 8, 7]] mapcat reverse',
             'mapcat([[3, 2, 1, 0], [6, 5, 4], [9, 8, 7]], reverse)',
             '[[3, 2, 1, 0,], [6, 5, 4,], [9, 8, 7]] mapcat reverse',
-            "\nfunction foo(n) {\n  [n - 1, n, n + 1]\n};\n[1, 2, 3] mapcat foo",
+            "\nlet foo = (n) -> {\n  [n - 1, n, n + 1]\n};\n[1, 2, 3] mapcat foo",
             "\nmapcat(\n  [[1, 2], [2, 2], [2, 3]],\n  -> $ remove even?\n)",
         ],
     },
@@ -20463,7 +20361,7 @@ var metaReference = {
         description: 'Returns documentation string of the $fun.',
         examples: [
             'doc(+)',
-            "\nfunction add(x, y) {\n  \"\"\"\n  Adds two numbers.\n  Args:\n    x: First number.\n    y: Second number.\n  Returns:\n    Sum of x and y.\n  \"\"\"\n  x + y;\n};\n\ndoc(add)",
+            "\nlet add = (x, y) -> {\n  \"\"\"\n  Adds two numbers.\n  Args:\n    x: First number.\n    y: Second number.\n  Returns:\n    Sum of x and y.\n  \"\"\"\n  x + y;\n};\n\ndoc(add)",
         ],
     },
     arity: {
@@ -20484,8 +20382,8 @@ var metaReference = {
         examples: [
             'arity(+)',
             'arity(defined?)',
-            "\nfunction add(x, y = 0) {\n  x + y;\n};\n\narity(add)",
-            "\nfunction foo(k, ...x) {\n  k + x;\n};\n  arity(foo)",
+            "\nlet add = (x, y = 0) -> {\n  x + y;\n};\n\narity(add)",
+            "\nlet foo = (k, ...x) -> {\n  k + x;\n};\n  arity(foo)",
         ],
     },
 };
@@ -26365,8 +26263,8 @@ var sequenceReference = {
         examples: [
             '[3, 1, 2] sort (a, b) -> b - a',
             'sort([3, 1, 2])',
-            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond { case a < b: -1 case a > b: 1 case true: -1 }\n)",
-            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond { case a > b: -1 case a < b: 1 case true: -1 }\n)",
+            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond case a < b then -1 case a > b then 1 case true then -1 end\n)",
+            "\nsort(\n  [3, 1, 2],\n  (a, b) -> cond case a > b then -1 case a < b then 1 case true then -1 end\n)",
         ],
     },
     'sort-by': {
@@ -26843,26 +26741,6 @@ var specialExpressionsReference = {
         description: "\n  Binds local variables s to `value`. `value` can be any expression. The scope of the variables is the body of the let expression.",
         examples: ["\nlet a = 1 + 2 + 3 + 4;\nlet b = -> $ * ( $ + 1 );\nwrite!(\"a\", a, \"b\", b)"],
     },
-    'function': {
-        title: 'function',
-        category: 'Special expression',
-        customVariants: ['function name(...arg) { body }'],
-        details: [
-            ['name', 'symbol', 'The name of the function.'],
-            ['arg', '[...]arg-name [= value]', 'Arguments of the function.'],
-            ['...', 'rest-symbol', 'Optional. The rest argument of the function.'],
-            ['arg-name', 'symbol', 'The name of the argument.'],
-            ['value', 'any', 'Optional. The default value of the argument.'],
-            ['let-binding', 'symbol', 'Optional. The let bindings of the function.'],
-            ['body', 'one or more expressions', 'The body of the function.'],
-        ],
-        description: 'Creates a named function. When called, evaluation of the last expression in the body is returned.',
-        examples: [
-            "\nfunction hyp (a, b) {\n  sqrt(a * a + b * b)\n};\n\nhyp(3, 4)",
-            "\nfunction sumOfSquares(...s) {\n  apply(\n    +,\n    map(s, -> $ ^ 2)\n  )\n};\n\nsumOfSquares(1, 2, 3, 4, 5)",
-            "\nfunction withOptional(a, b = 42) {\n  a + b\n};\n\nwrite!(withOptional(1), withOptional(1, 2))",
-        ],
-    },
     'try': {
         title: 'try',
         category: 'Special expression',
@@ -26902,7 +26780,7 @@ var specialExpressionsReference = {
     'if': {
         title: 'if',
         category: 'Special expression',
-        customVariants: ['if (test) true-expr else false-expr', 'if (test) true-expr'],
+        customVariants: ['if test then true-expr else false-expr', 'if test then true-expr'],
         details: [
             ['test', 'expression', 'The condition to test.'],
             ['true-expr', 'expression', 'The expression to evaluate if the test is truthy.'],
@@ -26910,16 +26788,16 @@ var specialExpressionsReference = {
         ],
         description: 'Either `true-expr` or `false-expr` branch is taken. `true-expr` is selected when $test is truthy. If $test is falsy `false-expr` is executed, if no `false-expr` exists, `null` is returned.',
         examples: [
-            "\nif (true) {\n  write!(\"TRUE\")\n} else {\n  write!(\"FALSE\")\n}",
-            'if (false) write!("TRUE") else write!("FALSE")',
-            'if (true) write!("TRUE")',
-            'if (false) write!("TRUE")',
+            "\nif true then {\n  write!(\"TRUE\")\n} else {\n  write!(\"FALSE\")\n}",
+            'if false then write!("TRUE") else write!("FALSE")',
+            'if true then write!("TRUE")',
+            'if false then write!("TRUE")',
         ],
     },
     'unless': {
         title: 'unless',
         category: 'Special expression',
-        customVariants: ['unless (test) true-expr else false-expr end', 'unless test true-expr end'],
+        customVariants: ['unless test then true-expr else false-expr end', 'unless test true-expr end'],
         details: [
             ['test', 'expression', 'The condition to test.'],
             ['true-expr', 'expression', 'The expressions to evaluate if the test is falsy.'],
@@ -26927,16 +26805,16 @@ var specialExpressionsReference = {
         ],
         description: 'Either `true-expr` or `false-expr` branch is taken. `true-expr` is selected when $test is falsy. If $test is truthy `false-expr` is executed, if no `false-expr` exists, `null` is returned.',
         examples: [
-            "\nunless (true) {\n  write!(\"TRUE\")\n} else {\n  write!(\"FALSE\")\n}",
-            'unless (false) write!("TRUE") else write!("FALSE")',
-            'unless (true) write!("TRUE")',
-            'unless (false) write!("TRUE")',
+            "\nunless true then {\n  write!(\"TRUE\")\n} else {\n  write!(\"FALSE\")\n}",
+            'unless false then write!("TRUE") else write!("FALSE")',
+            'unless true then write!("TRUE")',
+            'unless false then write!("TRUE")',
         ],
     },
     'cond': {
         title: 'cond',
         category: 'Special expression',
-        customVariants: ['cond { cond-branch cond-branch ... }'],
+        customVariants: ['cond cond-branch cond-branch ... end'],
         details: [
             ['cond-branch', 'case test then body', 'A branch of the cond expression.'],
             ['test', 'expression', 'The condition to test.'],
@@ -26944,15 +26822,15 @@ var specialExpressionsReference = {
         ],
         description: 'Used for branching. `cond-branches` are tested sequentially from the top. If no branch is tested truthy, `null` is returned.',
         examples: [
-            "\ncond {\n  case false: write!(\"FALSE\")\n  case true: write!(\"TRUE\")\n}",
-            "\ncond {\n  case false: write!(\"FALSE\")\n  case null: write!(\"null\")\n} ?? write!(\"TRUE\")",
-            "\ncond {\n  case false: write!(\"FALSE\")\n  case null: write!(\"null\")\n} ?? write!(\"TRUE\")",
+            "\ncond\n  case false then write!(\"FALSE\")\n  case true then write!(\"TRUE\")\nend",
+            "\ncond\n  case false then write!(\"FALSE\")\n  case null then write!(\"null\")\nend ?? write!(\"TRUE\")",
+            "\ncond\n  case false then write!(\"FALSE\")\n  case null then write!(\"null\")\nend ?? write!(\"TRUE\")",
         ],
     },
     'switch': {
         title: 'switch',
         category: 'Special expression',
-        customVariants: ['switch (value) { switch-branch switch-branch ... }'],
+        customVariants: ['switch value switch-branch switch-branch ... end'],
         details: [
             ['value', 'any', 'The value to test.'],
             ['switch-branch', 'case test then body', 'A branch of the switch expression.'],
@@ -26961,9 +26839,9 @@ var specialExpressionsReference = {
         ],
         description: 'Used for branching. `switch-branches` are tested sequentially from the top against `value`. If no branch is tested truthy, `null` is returned.',
         examples: [
-            "\nswitch (1) {\n  case 1: write!(\"One\")\n  case 2: write!(\"Two\")\n}",
-            "\nswitch (2) {\n  case 1: write!(\"One\")\n  case 2: write!(\"Two\")\n}",
-            "\nswitch (3) {\n  case 1: write!(\"One\")\n  case 2: write!(\"Two\")\n}",
+            "\nswitch 1\n  case 1 then write!(\"One\")\n  case 2 then write!(\"Two\")\nend",
+            "\nswitch 2\n  case 1 then write!(\"One\")\n  case 2 then write!(\"Two\")\nend",
+            "\nswitch 3\n  case 1 then write!(\"One\")\n  case 2 then write!(\"Two\")\nend",
         ],
     },
     'block': {
@@ -26984,9 +26862,9 @@ var specialExpressionsReference = {
         customVariants: ['recur(...recur-args)'],
         description: 'Recursevly calls enclosing function or loop with its evaluated `recur-args`.',
         examples: [
-            "\nfunction foo(n) {\n  write!(n);\n  if (!(zero?(n))) {\n    recur(n - 1)\n  }\n};\nfoo(3)",
-            "\n(n -> {\n  write!(n);\n  if (!(zero?(n))) {\n    recur(n - 1)\n  }\n})(3)",
-            "\nloop (n = 3) {\n  write!(n);\n  if (!(zero?(n))) {\n    recur(n - 1)\n  }\n}",
+            "\nlet foo = (n) -> {\n  write!(n);\n  if !(zero?(n)) then {\n    recur(n - 1)\n  }\n};\nfoo(3)",
+            "\n(n -> {\n  write!(n);\n  if !(zero?(n)) then {\n    recur(n - 1)\n  }\n})(3)",
+            "\nloop (n = 3) -> {\n  write!(n);\n  if !(zero?(n)) then {\n    recur(n - 1)\n  }\n}",
         ],
     },
 };
@@ -31444,1382 +31322,6 @@ function isAbstractLitsError(error) {
     return error instanceof LitsError;
 }
 
-const defaultConfig = {
-    spaceSeparation: false,
-    precision: 8,
-    epsilon: 1e-10,
-};
-const CONFIG = {
-    spaceSeparation: false,
-    precision: 8,
-    epsilon: 1e-10,
-};
-function setConfig(newConfig) {
-    CONFIG.spaceSeparation = newConfig.spaceSeparation ?? defaultConfig.spaceSeparation;
-    CONFIG.precision = newConfig.precision ?? defaultConfig.precision;
-    CONFIG.epsilon = newConfig.epsilon ?? defaultConfig.epsilon;
-}
-/**
- * Mathematical constants used for symbolic representation
- */
-const CONSTANTS = [
-    { getSymbol: () => 'π', value: Math.PI },
-    { getSymbol: () => 'e', value: Math.E },
-    { getSymbol: () => 'φ', value: (1 + Math.sqrt(5)) / 2 },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(2)' : '√2', value: Math.sqrt(2) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(3)' : '√3', value: Math.sqrt(3) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(5)' : '√5', value: Math.sqrt(5) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(7)' : '√7', value: Math.sqrt(7) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(11)' : '√11', value: Math.sqrt(11) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(13)' : '√13', value: Math.sqrt(13) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(17)' : '√17', value: Math.sqrt(17) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(19)' : '√19', value: Math.sqrt(19) },
-    { getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? '√(π)' : '√π', value: Math.sqrt(Math.PI) },
-    { getSymbol: () => 'ln(2)', value: Math.LN2 },
-    { getSymbol: () => 'ln(10)', value: Math.LN10 },
-    { getSymbol: () => 'log₂(e)', value: Math.LOG2E },
-    { getSymbol: () => 'log₁₀(e)', value: Math.LOG10E },
-];
-/**
- * Trigonometric values with their exact symbolic representations
- */
-const TRIG_VALUES = [
-    // sin values
-    { value: Math.sin(Math.PI / 6), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 6)' : 'sin(π/6)', getExactForm: () => CONFIG.spaceSeparation ? '1 / 2' : '1/2' },
-    { value: Math.sin(Math.PI / 4), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 4)' : 'sin(π/4)', getExactForm: () => CONFIG.spaceSeparation ? '√2 / 2' : '√2/2' },
-    { value: Math.sin(Math.PI / 3), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 3)' : 'sin(π/3)', getExactForm: () => CONFIG.spaceSeparation ? '√3 / 2' : '√3/2' },
-    { value: Math.sin(Math.PI / 2), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'sin(π / 2)' : 'sin(π/2)', getExactForm: () => '1' },
-    // cos values
-    { value: Math.cos(0), getSymbol: () => 'cos(0)', getExactForm: () => '1' },
-    { value: Math.cos(Math.PI / 6), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 6)' : 'cos(π/6)', getExactForm: () => CONFIG.spaceSeparation ? '√(3) / 2' : '√3/2' },
-    { value: Math.cos(Math.PI / 4), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 4)' : 'cos(π/4)', getExactForm: () => CONFIG.spaceSeparation ? '√(2) / 2' : '√2/2' },
-    { value: Math.cos(Math.PI / 3), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 3)' : 'cos(π/3)', getExactForm: () => CONFIG.spaceSeparation ? '1 / 2' : '1/2' },
-    { value: Math.cos(Math.PI / 2), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'cos(π / 2)' : 'cos(π/2)', getExactForm: () => '0' },
-    // tan values
-    { value: Math.tan(Math.PI / 6), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'tan(π / 6)' : 'tan(π/6)', getExactForm: () => CONFIG.spaceSeparation ? '1 / √(3)' : '1/√3' },
-    { value: Math.tan(Math.PI / 4), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'tan(π / 4)' : 'tan(π/4)', getExactForm: () => '1' },
-    { value: Math.tan(Math.PI / 3), getSymbol: noSpaceSeparation => CONFIG.spaceSeparation && !noSpaceSeparation ? 'tan(π / 3)' : 'tan(π/3)', getExactForm: () => CONFIG.spaceSeparation ? '√(3)' : '√3' },
-];
-
-/**
- * Factorizes a number under a radical to extract perfect square factors
- * @param n The number to factorize
- * @returns Object containing the coefficient and remaining radicand
- */
-function factorizeRadicand(n) {
-    // Find largest perfect square factor
-    let coefficient = 1;
-    let i = 2;
-    while (i * i <= n) {
-        // Check if i² is a factor of n
-        if (n % (i * i) === 0) {
-            coefficient *= i;
-            n /= (i * i);
-            // Continue with the same i to check for multiple powers
-            continue;
-        }
-        i++;
-    }
-    return { coefficient, radicand: n };
-}
-/**
- * Finds the greatest common divisor of two numbers
- * @param a First number
- * @param b Second number
- * @returns The GCD of a and b
- */
-function findGCD(a, b) {
-    a = Math.abs(a);
-    b = Math.abs(b);
-    while (b !== 0) {
-        const temp = b;
-        b = a % b;
-        a = temp;
-    }
-    return a;
-}
-/**
- * Checks if a number is prime
- * @param n The number to check
- * @returns True if n is prime, false otherwise
- */
-function isPrime(n) {
-    if (n <= 1)
-        return false;
-    if (n <= 3)
-        return true;
-    if (n % 2 === 0 || n % 3 === 0)
-        return false;
-    let i = 5;
-    while (i * i <= n) {
-        if (n % i === 0 || n % (i + 2) === 0)
-            return false;
-        i += 6;
-    }
-    return true;
-}
-/**
- * Determines if a number's square root should be preserved in direct form
- * @param n The number to check
- * @returns True if the square root should be kept in direct form
- */
-function shouldPreserveDirectRadical(n) {
-    // Always preserve direct form for prime numbers
-    if (isPrime(n))
-        return true;
-    // Always preserve direct form for small integers
-    if (n <= 30)
-        return true;
-    // Check if n has any perfect square factors
-    const factorized = factorizeRadicand(n);
-    // If no perfect square factors were found, preserve direct form
-    return factorized.coefficient === 1;
-}
-
-function isNumberNode(node) {
-    return node.type === 'Number';
-}
-function isUnaryOpNode(node) {
-    return node.type === 'UnaryOp';
-}
-function isBinaryOpNode(node) {
-    return node.type === 'BinaryOp';
-}
-function isRootNode(node) {
-    return node.type === 'Root';
-}
-function isConstantNode(node) {
-    return node.type === 'Constant';
-}
-function isPowerNode(node) {
-    return node.type === 'Power';
-}
-
-/**
- * Helper function to determine expression type priority for ordering
- * @returns A priority number (lower number = higher priority)
- */
-function getExpressionPriority(node) {
-    // Priority order: Number < Root/Power < Constant < Other
-    if (isNumberNode(node))
-        return 1;
-    if (isRootNode(node))
-        return 2;
-    // Handle other node types here
-    return 6; // Default for other types
-}
-/**
- * Determines if two expressions should be swapped in multiplication
- * @returns true if expressions should be swapped
- */
-function shouldSwapInMultiplication(left, right) {
-    const leftPriority = getExpressionPriority(left);
-    const rightPriority = getExpressionPriority(right);
-    // Lower priority number should come first
-    return leftPriority > rightPriority;
-}
-
-/**
- * Base abstract class for all expression nodes
- */
-class ExprNode {
-}
-
-/**
- * Checks if a node represents exactly zero within epsilon tolerance
- */
-function isZero(node) {
-    return isNumberNode(node) && Math.abs(node.evaluate()) < 1e-10;
-}
-/**
- * Checks if a node represents exactly one within epsilon tolerance
- */
-function isOne(node) {
-    return isNumberNode(node) && Math.abs(node.evaluate() - 1) < 1e-10;
-}
-/**
- * Node for numeric constants (integers, simple fractions, etc.)
- */
-class NumberNode extends ExprNode {
-    constructor(value) {
-        super();
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: value
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Number'
-        });
-    }
-    evaluate() {
-        return this.value;
-    }
-    toString() {
-        // Round values extremely close to zero to exactly zero
-        if (Math.abs(this.value) < CONFIG.epsilon) {
-            return "0";
-        }
-        if (this.value === Number.POSITIVE_INFINITY) {
-            return "∞";
-        }
-        if (this.value === Number.NEGATIVE_INFINITY) {
-            return "-∞";
-        }
-        if (Number.isInteger(this.value)) {
-            return this.value.toString();
-        }
-        // Handle fractions if it's a "nice" fraction
-        const MAX_DENOMINATOR = 1000;
-        for (let denominator = 2; denominator <= MAX_DENOMINATOR; denominator++) {
-            const numerator = Math.round(this.value * denominator);
-            if (Math.abs(this.value - numerator / denominator) < CONFIG.epsilon) {
-                const gcd = findGCD(Math.abs(numerator), denominator);
-                return CONFIG.spaceSeparation ? `${numerator / gcd} / ${denominator / gcd}` : `${numerator / gcd}/${denominator / gcd}`;
-            }
-        }
-        // Just return the decimal representation
-        const valueStr = this.value.toString();
-        if (valueStr.includes('.')) {
-            const [, decimalPart] = valueStr.split('.');
-            if (decimalPart.length > 8) {
-                return this.value.toFixed(CONFIG.precision);
-            }
-        }
-        return this.value.toString();
-    }
-    simplify() {
-        return this; // Numbers are already in simplest form
-    }
-    equals(other) {
-        if (!(isNumberNode(other)))
-            return false;
-        return Math.abs(this.value - other.evaluate()) < CONFIG.epsilon;
-    }
-}
-
-/**
- * Node for binary operations (+, -, *, /)
- */
-class BinaryOpNode extends ExprNode {
-    constructor(op, left, right) {
-        super();
-        Object.defineProperty(this, "op", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: op
-        });
-        Object.defineProperty(this, "left", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: left
-        });
-        Object.defineProperty(this, "right", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: right
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'BinaryOp'
-        });
-        // Apply automatic ordering for multiplication operations
-        if (this.op === '*' && shouldSwapInMultiplication(left, right)) {
-            // Swap the operands if they're in the wrong order
-            this.left = right;
-            this.right = left;
-        }
-    }
-    evaluate() {
-        const leftVal = this.left.evaluate();
-        const rightVal = this.right.evaluate();
-        switch (this.op) {
-            case '+': return leftVal + rightVal;
-            case '-': return leftVal - rightVal;
-            case '*': return leftVal * rightVal;
-            case '/': return leftVal / rightVal;
-        }
-    }
-    toString() {
-        let leftStr = this.left.toString();
-        let rightStr = this.right.toString();
-        // Add parentheses if needed
-        if ((this.op === '+' || this.op === '-')
-            && (isBinaryOpNode(this.left) && (this.left.getOp() === '+' || this.left.getOp() === '-'))) {
-            leftStr = `(${leftStr})`;
-        }
-        else if ((this.op === '+' || this.op === '-')
-            && (isBinaryOpNode(this.right) && (this.right.getOp() === '+' || this.right.getOp() === '-'))) {
-            rightStr = `(${rightStr})`;
-        }
-        if (this.op === '*') {
-            // Double-check order at display time
-            if (shouldSwapInMultiplication(this.left, this.right)) {
-                return CONFIG.spaceSeparation
-                    ? `${this.right.toString()} · ${this.left.toString()}`
-                    : `${this.right.toString()}·${this.left.toString()}`;
-            }
-            return CONFIG.spaceSeparation
-                ? `${this.left.toString()} · ${this.right.toString()}`
-                : `${this.left.toString()}·${this.right.toString()}`;
-        }
-        else {
-            return CONFIG.spaceSeparation
-                ? `${leftStr} ${this.op} ${rightStr}`
-                : `${leftStr}${this.op}${rightStr}`;
-        }
-    }
-    getOp() {
-        return this.op;
-    }
-    getLeft() {
-        return this.left;
-    }
-    getRight() {
-        return this.right;
-    }
-    simplify() {
-        // First simplify both children
-        const left = this.left.simplify();
-        const right = this.right.simplify();
-        // If both are numbers, perform the operation
-        if (isNumberNode(left) && isNumberNode(right)) {
-            return new NumberNode(this.evaluate());
-        }
-        // Simplification rules for addition
-        if (this.op === '+') {
-            // a + 0 = a
-            if (isNumberNode(right) && right.evaluate() === 0) {
-                return left;
-            }
-            // 0 + a = a
-            if (isNumberNode(left) && left.evaluate() === 0) {
-                return right;
-            }
-        }
-        // Simplification rules for subtraction
-        if (this.op === '-') {
-            // a - 0 = a
-            if (isNumberNode(right) && right.evaluate() === 0) {
-                return left;
-            }
-            // 0 - a = -a
-            if (isNumberNode(left) && left.evaluate() === 0) {
-                return new UnaryOpNode('-', right);
-            }
-            // a - a = 0
-            if (left.equals(right)) {
-                return new NumberNode(0);
-            }
-        }
-        // Simplification rules for multiplication
-        if (this.op === '*') {
-            // a * 0 = 0
-            if (isZero(left) || isZero(right)) {
-                return new NumberNode(0);
-            }
-            // a * 1 = a
-            if (isOne(right)) {
-                return left;
-            }
-            // 1 * a = a
-            if (isOne(left)) {
-                return right;
-            }
-            // Special case for n·√m/2 (12·√3/2 case)
-            if (isNumberNode(left)
-                && isBinaryOpNode(right)
-                && right.getOp() === '/'
-                && isNumberNode(right.getRight())
-                && right.getRight().evaluate() === 2
-                && isRootNode(right.getLeft())) {
-                const n = left.evaluate();
-                const rootNode = right.getLeft();
-                return new BinaryOpNode('*', new NumberNode(n / 2), rootNode);
-            }
-            // Handle multiplications with fractions
-            if (isBinaryOpNode(left) && left.getOp() === '/') {
-                // (a/b) * c = (a*c)/b
-                const fraction = left;
-                const numerator = fraction.getLeft();
-                const denominator = fraction.getRight();
-                return new BinaryOpNode('/', new BinaryOpNode('*', numerator, right), denominator).simplify();
-            }
-            if (isBinaryOpNode(right) && right.getOp() === '/') {
-                // c * (a/b) = (c*a)/b
-                const fraction = right;
-                const numerator = fraction.getLeft();
-                const denominator = fraction.getRight();
-                return new BinaryOpNode('/', new BinaryOpNode('*', left, numerator), denominator).simplify();
-            }
-            // Multiple numeric factors: (2·3)·π = 6·π
-            if (isNumberNode(left)
-                && isBinaryOpNode(right)
-                && right.getOp() === '*'
-                && isNumberNode(right.getLeft())) {
-                const n1 = left.evaluate();
-                const n2 = (right).getLeft().evaluate();
-                const restTerm = right.getRight();
-                return new BinaryOpNode('*', new NumberNode(n1 * n2), restTerm).simplify();
-            }
-            // Consolidate products of square roots: √a·√b = √(a·b)
-            if (isRootNode(left) && isRootNode(right)) {
-                const leftOperand = getRootOperand(left);
-                const rightOperand = getRootOperand(right);
-                // Create √(a·b) instead of √a·√b
-                if (isNumberNode(leftOperand) && isNumberNode(rightOperand)) {
-                    const newRadicand = leftOperand.evaluate() * rightOperand.evaluate();
-                    return new RootNode(new NumberNode(newRadicand)).simplify();
-                }
-            }
-        }
-        // Simplification rules for division
-        if (this.op === '/') {
-            // 0 / a = 0
-            if (isZero(left)) {
-                return new NumberNode(0);
-            }
-            // a / 1 = a
-            if (isOne(right)) {
-                return left;
-            }
-            // a / a = 1
-            if (left.equals(right)) {
-                return new NumberNode(1);
-            }
-            // Simplify numeric fractions
-            if (isNumberNode(left) && isNumberNode(right)) {
-                const num = left.evaluate();
-                const denom = right.evaluate();
-                if (Number.isInteger(num) && Number.isInteger(denom)) {
-                    const gcd = findGCD(Math.abs(num), Math.abs(denom));
-                    if (gcd > 1) {
-                        return new BinaryOpNode('/', new NumberNode(num / gcd), new NumberNode(denom / gcd));
-                    }
-                }
-            }
-            // (a*b) / b = a
-            if (isBinaryOpNode(left) && left.getOp() === '*') {
-                const product = left;
-                // Case for n·something / n = something (6·√3/6 = √3)
-                if (isNumberNode(product.getLeft())
-                    && isNumberNode(right)
-                    && Math.abs(product.getLeft().evaluate() - right.evaluate()) < 1e-10) {
-                    return product.getRight();
-                }
-                if (isNumberNode(product.getRight())
-                    && isNumberNode(right)
-                    && Math.abs(product.getRight().evaluate() - right.evaluate()) < 1e-10) {
-                    return product.getLeft();
-                }
-                // General case
-                if (product.getLeft().equals(right)) {
-                    return product.getRight();
-                }
-                if (product.getRight().equals(right)) {
-                    return product.getLeft();
-                }
-            }
-        }
-        // If no simplification rules apply, return a new node with simplified children
-        return new BinaryOpNode(this.op, left, right);
-    }
-    equals(other) {
-        if (!(isBinaryOpNode(other)))
-            return false;
-        const otherOp = other;
-        return this.op === otherOp.getOp()
-            && this.left.equals(otherOp.getLeft())
-            && this.right.equals(otherOp.getRight());
-    }
-}
-/**
- * Extracts the radicand from a square root expression
- */
-function getRootOperand(node) {
-    if (isRootNode(node)) {
-        return node.getOperand();
-    }
-    if (isUnaryOpNode(node) && node.getOp() === 'sqrt') {
-        return node.getOperand();
-    }
-    throw new Error('Not a root node');
-}
-/**
- * Checks if a node represents a square root expression
- */
-function isRootLikeNode(node) {
-    return isRootNode(node)
-        || (isUnaryOpNode(node) && node.getOp() === 'sqrt');
-}
-/**
- * Specialized node for square roots for nicer formatting
- */
-class RootNode extends ExprNode {
-    constructor(operand) {
-        super();
-        Object.defineProperty(this, "operand", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: operand
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Root'
-        });
-    }
-    evaluate() {
-        return Math.sqrt(this.operand.evaluate());
-    }
-    toString() {
-        if (CONFIG.spaceSeparation) {
-            const operandStr = this.operand.toString();
-            if (!isNumberNode(this.operand) || operandStr.includes('/')) {
-                return `√(${operandStr})`;
-            }
-            else {
-                return `√${operandStr}`;
-            }
-        }
-        else {
-            return `√${this.operand.toString()}`;
-        }
-    }
-    simplify() {
-        const operand = this.operand.simplify();
-        // Simplify sqrt of perfect squares
-        if (isNumberNode(operand)) {
-            const val = operand.evaluate();
-            const sqrtVal = Math.sqrt(val);
-            // If it's a perfect square, return the number
-            if (Number.isInteger(sqrtVal)) {
-                return new NumberNode(sqrtVal);
-            }
-            // Otherwise, check if we can simplify the radicand
-            const factorized = factorizeRadicand(val);
-            if (factorized.coefficient > 1) {
-                // If there's a perfect square factor, extract it
-                return new BinaryOpNode('*', new NumberNode(factorized.coefficient), new RootNode(new NumberNode(factorized.radicand)));
-            }
-        }
-        // Handle product of radicands under a root
-        if (isBinaryOpNode(operand) && operand.getOp() === '*') {
-            const left = operand.getLeft();
-            const right = operand.getRight();
-            // We can't simplify if they aren't both numbers
-            if (isNumberNode(left) && isNumberNode(right)) {
-                const leftVal = left.evaluate();
-                const rightVal = right.evaluate();
-                // Try to factorize the product
-                const factorized = factorizeRadicand(leftVal * rightVal);
-                if (factorized.coefficient > 1) {
-                    // If there's a perfect square factor, extract it
-                    return new BinaryOpNode('*', new NumberNode(factorized.coefficient), new RootNode(new NumberNode(factorized.radicand))).simplify();
-                }
-            }
-        }
-        return new RootNode(operand);
-    }
-    getOperand() {
-        return this.operand;
-    }
-    equals(other) {
-        if (!(isRootLikeNode(other)))
-            return false;
-        return this.operand.equals(other.getOperand());
-    }
-}
-/**
- * Specialized node for power expressions
- */
-class PowerNode extends ExprNode {
-    constructor(base, exponent) {
-        super();
-        Object.defineProperty(this, "base", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: base
-        });
-        Object.defineProperty(this, "exponent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: exponent
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Power'
-        });
-    }
-    evaluate() {
-        return this.base.evaluate() ** this.exponent.evaluate();
-    }
-    toString() {
-        const baseStr = this.base.toString();
-        const expVal = this.exponent.evaluate();
-        // Use superscript for powers 2 and 3
-        if (expVal === 2)
-            return `${baseStr}²`;
-        if (expVal === 3)
-            return `${baseStr}³`;
-        return CONFIG.spaceSeparation ? `${baseStr} ^ ${this.exponent.toString()}` : `${baseStr}^${this.exponent.toString()}`;
-    }
-    simplify() {
-        const base = this.base.simplify();
-        const exponent = this.exponent.simplify();
-        // Anything to the power of 0 is 1
-        if (isNumberNode(exponent) && exponent.evaluate() === 0) {
-            return new NumberNode(1);
-        }
-        // Anything to the power of 1 is itself
-        if (isNumberNode(exponent) && exponent.evaluate() === 1) {
-            return base;
-        }
-        // 0 to any positive power is 0
-        if (isNumberNode(base) && base.evaluate() === 0
-            && isNumberNode(exponent) && exponent.evaluate() > 0) {
-            return new NumberNode(0);
-        }
-        // 1 to any power is 1
-        if (isNumberNode(base) && base.evaluate() === 1) {
-            return new NumberNode(1);
-        }
-        // If both are numbers, compute the power
-        if (isNumberNode(base) && isNumberNode(exponent)) {
-            return new NumberNode(base.evaluate() ** exponent.evaluate());
-        }
-        return new PowerNode(base, exponent);
-    }
-    equals(other) {
-        if (!(isPowerNode(other)))
-            return false;
-        const otherPower = other;
-        return this.base.equals(otherPower.base)
-            && this.exponent.equals(otherPower.exponent);
-    }
-    getBase() {
-        return this.base;
-    }
-    getExponent() {
-        return this.exponent;
-    }
-}
-/**
- * Node for unary operations (-, sqrt, cbrt, etc.)
- */
-class UnaryOpNode extends ExprNode {
-    constructor(op, operand) {
-        super();
-        Object.defineProperty(this, "op", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: op
-        });
-        Object.defineProperty(this, "operand", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: operand
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'UnaryOp'
-        });
-    }
-    evaluate() {
-        const val = this.operand.evaluate();
-        switch (this.op) {
-            case '-': return -val;
-            case 'sqrt': return Math.sqrt(val);
-            case 'cbrt': return Math.cbrt(val);
-        }
-    }
-    toString() {
-        const operandStr = this.operand.toString();
-        if (operandStr === '0') {
-            return '0';
-        }
-        switch (this.op) {
-            case '-': return CONFIG.spaceSeparation && (!isNumberNode(this.operand) || operandStr.includes('/')) ? `-(${operandStr})` : `-${operandStr}`;
-            case 'sqrt': return CONFIG.spaceSeparation ? `√(${operandStr})` : `√${operandStr}`;
-            case 'cbrt': return CONFIG.spaceSeparation ? `∛(${operandStr})` : `∛${operandStr}`;
-        }
-    }
-    simplify() {
-        const operand = this.operand.simplify();
-        // Double negation: --a = a
-        if (this.op === '-' && isUnaryOpNode(operand)
-            && operand.getOp() === '-') {
-            return operand.getOperand();
-        }
-        // Simplify sqrt of perfect squares
-        if (this.op === 'sqrt' && isNumberNode(operand)) {
-            const val = operand.evaluate();
-            const sqrtVal = Math.sqrt(val);
-            if (Number.isInteger(sqrtVal)) {
-                return new NumberNode(sqrtVal);
-            }
-        }
-        // Simplify cbrt of perfect cubes
-        if (this.op === 'cbrt' && isNumberNode(operand)) {
-            const val = operand.evaluate();
-            const cbrtVal = Math.cbrt(val);
-            if (Number.isInteger(cbrtVal)) {
-                return new NumberNode(cbrtVal);
-            }
-        }
-        return new UnaryOpNode(this.op, operand);
-    }
-    getOp() {
-        return this.op;
-    }
-    getOperand() {
-        return this.operand;
-    }
-    equals(other) {
-        if (!(isUnaryOpNode(other)))
-            return false;
-        const otherOp = other;
-        return this.op === otherOp.getOp()
-            && this.operand.equals(otherOp.getOperand());
-    }
-}
-
-/**
- * Node for mathematical constants (π, e, etc.)
- */
-class ConstantNode extends ExprNode {
-    constructor(symbol, value) {
-        super();
-        Object.defineProperty(this, "symbol", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: symbol
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: value
-        });
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'Constant'
-        });
-    }
-    evaluate() {
-        return this.value;
-    }
-    toString() {
-        return this.symbol;
-    }
-    simplify() {
-        return this; // Constants are already in simplest form
-    }
-    equals(other) {
-        if (!(isConstantNode(other)))
-            return false;
-        return this.symbol === other.symbol;
-    }
-    getSymbol() {
-        return this.symbol;
-    }
-}
-
-/**
- * Converts a number to its continued fraction representation
- * @param x The number to convert
- * @param maxTerms Maximum number of terms to compute
- * @returns Array of continued fraction terms [a0, a1, a2, ...]
- */
-function toContinuedFraction(x, maxTerms = 20) {
-    const terms = [];
-    for (let i = 0; i < maxTerms; i++) {
-        const a = Math.floor(x);
-        terms.push(a);
-        // If we've reached a very small remainder, we're done
-        if (Math.abs(x - a) < CONFIG.epsilon) {
-            break;
-        }
-        // Prevent division by zero and avoid floating point issues
-        const remainder = x - a;
-        if (Math.abs(remainder) < CONFIG.epsilon) {
-            break;
-        }
-        x = 1 / remainder;
-    }
-    return terms;
-}
-/**
- * Converts continued fraction terms to a fraction [numerator, denominator]
- * @param terms Array of continued fraction terms
- * @returns [numerator, denominator]
- */
-function fromContinuedFraction(terms) {
-    if (terms.length === 0)
-        return [0, 1];
-    if (terms.length === 1)
-        return [terms[0], 1];
-    // Start with the last term
-    let numerator = terms[terms.length - 1];
-    let denominator = 1;
-    // Work backwards through the terms
-    for (let i = terms.length - 2; i >= 0; i--) {
-        // For each term, compute the new fraction 
-        // a_i + 1/previous
-        const newNumerator = terms[i] * numerator + denominator;
-        const newDenominator = numerator;
-        // Update for next iteration
-        numerator = newNumerator;
-        denominator = newDenominator;
-    }
-    return [numerator, denominator];
-}
-/**
- * Generates all convergents (approximations) from continued fraction terms
- * @param terms Array of continued fraction terms
- * @returns Array of [numerator, denominator] pairs
- */
-function getConvergents(terms) {
-    const convergents = [];
-    for (let i = 1; i <= terms.length; i++) {
-        convergents.push(fromContinuedFraction(terms.slice(0, i)));
-    }
-    return convergents;
-}
-/**
- * Tries to identify if a number is a simple quadratic irrational
- * @param x The number to check
- * @returns The identified form or null if not recognized
- */
-function identifyQuadraticIrrational(x) {
-    // Direct checks for common values
-    // Check for square roots of integers
-    for (let n = 2; n <= 20; n++) {
-        if (Math.abs(x - Math.sqrt(n)) < CONFIG.epsilon) {
-            return `√${n}`;
-        }
-    }
-    // Check for golden ratio and its conjugate
-    if (Math.abs(x - (1 + Math.sqrt(5)) / 2) < CONFIG.epsilon) {
-        return "φ"; // Already defined as a constant
-    }
-    if (Math.abs(x - (Math.sqrt(5) - 1) / 2) < CONFIG.epsilon) {
-        return "(√5-1)/2";
-    }
-    // Check for expressions of form (√n ± m)/k where n, m, k are small integers
-    for (let n = 2; n <= 30; n++) {
-        const sqrtN = Math.sqrt(n);
-        for (let m = 1; m <= 10; m++) {
-            for (let k = 2; k <= 10; k++) {
-                // Check (√n + m)/k
-                if (Math.abs(x - (sqrtN + m) / k) < CONFIG.epsilon) {
-                    if (m === 1 && k === 2) {
-                        return `(√${n}+1)/2`;
-                    }
-                    else {
-                        return `(√${n}+${m})/${k}`;
-                    }
-                }
-                // Check (√n - m)/k
-                if (Math.abs(x - (sqrtN - m) / k) < CONFIG.epsilon) {
-                    if (m === 1 && k === 2) {
-                        return `(√${n}-1)/2`;
-                    }
-                    else {
-                        return `(√${n}-${m})/${k}`;
-                    }
-                }
-            }
-        }
-    }
-    // Get continued fraction for pattern analysis
-    const terms = toContinuedFraction(x, 30);
-    // Analyze the continued fraction for periodic patterns
-    const period = detectPeriod(terms);
-    if (period) {
-        // For purely periodic CFs (√D): [a0; a1, a2, ..., aN, a1, a2, ...]
-        // where a0 = floor(√D) and the sequence after a0 is periodic
-        // For √2: [1; 2, 2, 2, ...]
-        if (period.length === 1 && period[0] === 2 && terms[0] === 1) {
-            return "√2";
-        }
-        // For √3: [1; 1, 2, 1, 2, ...]
-        if (period.length === 2 && period[0] === 1 && period[1] === 2 && terms[0] === 1) {
-            return "√3";
-        }
-        // For √5: [2; 4, 4, 4, ...]
-        if (period.length === 1 && period[0] === 4 && terms[0] === 2) {
-            return "√5";
-        }
-        // For √6: [2; 2, 4, 2, 4, ...] 
-        if (period.length === 2 && period[0] === 2 && period[1] === 4 && terms[0] === 2) {
-            return "√6";
-        }
-        // For √7: [2; 1, 1, 1, 4, 1, 1, 1, 4, ...] 
-        if (period.length === 4 &&
-            period[0] === 1 && period[1] === 1 &&
-            period[2] === 1 && period[3] === 4 &&
-            terms[0] === 2) {
-            return "√7";
-        }
-        // For √8: [2; 1, 4, 1, 4, ...]
-        if (period.length === 2 && period[0] === 1 && period[1] === 4 && terms[0] === 2) {
-            return "√8";
-        }
-        // Try to reconstruct the quadratic form from the pattern
-        // (Complex algorithm that would determine D from periodic CF)
-        const D = reconstructD(terms[0], period);
-        if (D > 0 && Math.abs(x - Math.sqrt(D)) < CONFIG.epsilon) {
-            return `√${D}`;
-        }
-    }
-    return null; // Could not identify
-}
-// Helper function to detect periodic patterns in continued fractions
-function detectPeriod(terms) {
-    // Need at least a few terms to detect patterns
-    if (terms.length < 6)
-        return null;
-    // Check for single repeating digit (like √2 = [1; 2, 2, 2, ...])
-    const allSameAfterFirst = terms.slice(1).every(t => t === terms[1]);
-    if (allSameAfterFirst) {
-        return [terms[1]];
-    }
-    // For period of length 2
-    const periodLength2 = terms.slice(1, 3).every((val, idx) => {
-        for (let i = 1; i < Math.floor((terms.length - 1) / 2); i++) {
-            if (terms[1 + idx + 2 * i] !== val)
-                return false;
-        }
-        return true;
-    });
-    if (periodLength2) {
-        return terms.slice(1, 3);
-    }
-    // For period of length 4
-    if (terms.length >= 9) {
-        const periodLength4 = terms.slice(1, 5).every((val, idx) => {
-            return terms[1 + idx + 4] === val && (terms.length >= 13 ? terms[1 + idx + 8] === val : true);
-        });
-        if (periodLength4) {
-            return terms.slice(1, 5);
-        }
-    }
-    // Could add more pattern detection logic here
-    return null;
-}
-// Helper function to reconstruct D from continued fraction pattern
-function reconstructD(a0, period) {
-    // Simple cases
-    if (period.length === 1 && period[0] === 2)
-        return 2;
-    if (period.length === 2 && period[0] === 1 && period[1] === 2)
-        return 3;
-    if (period.length === 1 && period[0] === 4)
-        return 5;
-    if (period.length === 2 && period[0] === 2 && period[1] === 4)
-        return 6;
-    if (period.length === 4 &&
-        period[0] === 1 && period[1] === 1 &&
-        period[2] === 1 && period[3] === 4)
-        return 7;
-    if (period.length === 2 && period[0] === 1 && period[1] === 4)
-        return 8;
-    // For purely periodic CFs, D = a0² + P where P depends on the period
-    // This is a simplified heuristic approach
-    if (period.length === 1) {
-        // If period has form [n], then D ≈ a0² + 1/n
-        return Math.round(a0 * a0 + 1 / period[0]);
-    }
-    // Generalized approach for reconstructing D would be more complex
-    // and would involve solving the Pell equation
-    return -1; // Couldn't determine D
-}
-
-/**
- * Parser to convert numeric values to expression trees
- */
-class ExpressionParser {
-    /**
-     * Main parsing function that converts a number to an expression tree
-     */
-    parseNumber(num, depth = 0) {
-        const MAX_DEPTH = 3;
-        // Handle zero
-        if (Math.abs(num) < CONFIG.epsilon) {
-            return new NumberNode(0);
-        }
-        // Handle negative numbers
-        if (num < 0) {
-            return new UnaryOpNode('-', this.parseNumber(-num, depth));
-        }
-        // Handle integers
-        if (Math.abs(num - Math.round(num)) < CONFIG.epsilon) {
-            return new NumberNode(Math.round(num));
-        }
-        const cfTerms = toContinuedFraction(num, 20);
-        const convergents = getConvergents(cfTerms);
-        for (const [numerator, denominator] of convergents) {
-            // Only consider fractions with reasonably-sized components
-            if (denominator <= 1000 && Math.abs(numerator) <= 10000) {
-                // Verify the approximation is within our epsilon
-                if (Math.abs(num - numerator / denominator) < CONFIG.epsilon) {
-                    const gcd = this.findGCD(Math.abs(numerator), denominator);
-                    return new BinaryOpNode('/', new NumberNode(numerator / gcd), new NumberNode(denominator / gcd));
-                }
-            }
-        }
-        // Try direct matches to constants
-        for (const constant of CONSTANTS) {
-            if (Math.abs(num - constant.value) < CONFIG.epsilon) {
-                return new ConstantNode(constant.getSymbol(), constant.value);
-            }
-        }
-        // Try direct matches to trig values
-        for (const trigValue of TRIG_VALUES) {
-            if (Math.abs(num - trigValue.value) < CONFIG.epsilon) {
-                // If it has an exact form, parse that instead
-                if (trigValue.getExactForm) {
-                    return this.parseExactForm(trigValue.getExactForm());
-                }
-                return new ConstantNode(trigValue.getSymbol(), trigValue.value);
-            }
-        }
-        const quadraticForm = identifyQuadraticIrrational(num);
-        if (quadraticForm) {
-            // If we identified something like "√7" or "(√13-3)/2"
-            return this.parseExactForm(quadraticForm);
-        }
-        // Direct check for square roots before other decompositions
-        // This ensures square roots of integers are handled directly
-        for (let i = 2; i <= 100; i++) {
-            if (Math.abs(num - Math.sqrt(i)) < CONFIG.epsilon) {
-                // Use our enhanced check to determine if we should keep direct form
-                if (shouldPreserveDirectRadical(i)) {
-                    return new RootNode(new NumberNode(i));
-                }
-                // Only factorize if appropriate
-                const factorized = factorizeRadicand(i);
-                if (factorized.coefficient > 1) {
-                    return new BinaryOpNode('*', new NumberNode(factorized.coefficient), new RootNode(new NumberNode(factorized.radicand)));
-                }
-                // Default to direct representation
-                return new RootNode(new NumberNode(i));
-            }
-        }
-        // Check for powers
-        for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-            for (let power = 2; power <= 3; power++) {
-                if (Math.abs(num - constant.value ** power) < CONFIG.epsilon) {
-                    const baseNode = constant.getExactForm
-                        ? this.parseExactForm(constant.getExactForm())
-                        : new ConstantNode(constant.getSymbol(), constant.value);
-                    return new PowerNode(baseNode, new NumberNode(power));
-                }
-            }
-        }
-        // Recursive decomposition with extra care for square roots
-        if (depth < MAX_DEPTH) {
-            // Check for π/n pattern
-            for (const constant of CONSTANTS) {
-                for (let denominator = 2; denominator <= 12; denominator++) {
-                    if (Math.abs(num - constant.value / denominator) < CONFIG.epsilon) {
-                        return new BinaryOpNode('/', constant.getExactForm
-                            ? this.parseExactForm(constant.getExactForm())
-                            : new ConstantNode(constant.getSymbol(), constant.value), new NumberNode(denominator));
-                    }
-                }
-            }
-            // Check for products with more careful handling of square roots
-            for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-                if (Math.abs(constant.value) > CONFIG.epsilon) {
-                    const multiplier = num / constant.value;
-                    // Skip square root decomposition attempts for prime square roots
-                    if (constant.getSymbol() && constant.getSymbol().startsWith('√')
-                        && isPrime(Number.parseInt(constant.getSymbol(true).substring(1)))) {
-                        continue;
-                    }
-                    // Skip common fractions that might be misidentified as complex expressions
-                    if ((Math.abs(multiplier - 0.75) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.5) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.25) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.3333333333333333) < CONFIG.epsilon)
-                        || (Math.abs(multiplier - 0.6666666666666666) < CONFIG.epsilon)) {
-                        continue;
-                    }
-                    if (this.isNiceValue(multiplier)) {
-                        const multiplierNode = this.parseNumber(multiplier, depth + 1);
-                        const valueNode = constant.getExactForm
-                            ? this.parseExactForm(constant.getExactForm())
-                            : new ConstantNode(constant.getSymbol(), constant.value);
-                        // If multiplier is 1, just return the constant
-                        if (isNumberNode(multiplierNode)
-                            && Math.abs(multiplierNode.evaluate() - 1) < CONFIG.epsilon) {
-                            return valueNode;
-                        }
-                        // Create the product node with canonical ordering
-                        let productNode;
-                        // Define a priority order for constants
-                        // Lower number = higher priority (should appear first)
-                        const getConstantPriority = (node) => {
-                            if (!(isConstantNode(node)))
-                                return 100;
-                            const symbol = node.getSymbol();
-                            if (symbol === 'e')
-                                return 1;
-                            if (symbol === 'π')
-                                return 2;
-                            if (symbol === 'φ')
-                                return 3;
-                            if (symbol.startsWith('√'))
-                                return 10;
-                            return 50; // Other constants
-                        };
-                        // Apply the priority ordering
-                        if (isConstantNode(multiplierNode) && isConstantNode(valueNode)) {
-                            // When multiplying two constants, order them by priority
-                            const multiplierPriority = getConstantPriority(multiplierNode);
-                            const valuePriority = getConstantPriority(valueNode);
-                            if (multiplierPriority <= valuePriority) {
-                                productNode = new BinaryOpNode('*', multiplierNode, valueNode);
-                            }
-                            else {
-                                productNode = new BinaryOpNode('*', valueNode, multiplierNode);
-                            }
-                        }
-                        else if (isNumberNode(multiplierNode)) {
-                            // Number multiplier always goes first
-                            productNode = new BinaryOpNode('*', multiplierNode, valueNode);
-                        }
-                        else if (getConstantPriority(valueNode) < 50) {
-                            // Special constants (e, π, φ) go before other expressions
-                            productNode = new BinaryOpNode('*', valueNode, multiplierNode);
-                        }
-                        else {
-                            // Default ordering
-                            productNode = new BinaryOpNode('*', multiplierNode, valueNode);
-                        }
-                        // Check if this product is part of a sum
-                        // Try to see if the product plus a nice value equals our number
-                        for (let addend = 1; addend <= 10; addend++) {
-                            const productValue = productNode.evaluate();
-                            const sum = productValue + addend;
-                            if (Math.abs(num - sum) < CONFIG.epsilon) {
-                                return new BinaryOpNode('+', productNode, new NumberNode(addend));
-                            }
-                        }
-                        return productNode;
-                    }
-                }
-            }
-            // Check for sums and differences with base constants
-            for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-                const remainder = num - constant.value;
-                if (this.isNiceValue(remainder)) {
-                    const remainderNode = this.parseNumber(remainder, depth + 1);
-                    const valueNode = constant.getExactForm
-                        ? this.parseExactForm(constant.getExactForm())
-                        : new ConstantNode(constant.getSymbol(), constant.value);
-                    // If remainder is 0, just return the constant
-                    if (isNumberNode(remainderNode)
-                        && Math.abs(remainderNode.evaluate()) < CONFIG.epsilon) {
-                        return valueNode;
-                    }
-                    // If remainder is negative, use subtraction
-                    if (remainder < 0) {
-                        return new BinaryOpNode('-', valueNode, this.parseNumber(-remainder, depth + 1));
-                    }
-                    return new BinaryOpNode('+', valueNode, remainderNode);
-                }
-            }
-            // Check for sums and differences with multiples of constants
-            for (const constant of [...CONSTANTS, ...TRIG_VALUES]) {
-                for (let multiplier = 2; multiplier <= 5; multiplier++) {
-                    const multipleValue = multiplier * constant.value;
-                    const remainder = num - multipleValue;
-                    if (this.isNiceValue(remainder)) {
-                        // Create the multiple constant node
-                        const constantNode = constant.getExactForm
-                            ? this.parseExactForm(constant.getExactForm())
-                            : new ConstantNode(constant.getSymbol(), constant.value);
-                        const multipleNode = new BinaryOpNode('*', new NumberNode(multiplier), constantNode);
-                        // Create the remainder node
-                        const remainderNode = this.parseNumber(remainder, depth + 1);
-                        // If remainder is 0, just return the multiple
-                        if (isNumberNode(remainderNode)
-                            && Math.abs(remainderNode.evaluate()) < CONFIG.epsilon) {
-                            return multipleNode;
-                        }
-                        // If remainder is negative, use subtraction
-                        if (remainder < 0) {
-                            return new BinaryOpNode('-', multipleNode, this.parseNumber(-remainder, depth + 1));
-                        }
-                        return new BinaryOpNode('+', multipleNode, remainderNode);
-                    }
-                }
-            }
-            // Check for cube roots of integers
-            for (let i = 2; i <= 100; i++) {
-                if (Math.abs(num - Math.cbrt(i)) < CONFIG.epsilon) {
-                    return new UnaryOpNode('cbrt', new NumberNode(i));
-                }
-            }
-        }
-        // Final direct check for square roots before giving up
-        // This ensures we catch any square roots we might have missed
-        const possibleRadicand = Math.round(num * num);
-        if (Math.abs(num - Math.sqrt(possibleRadicand)) < CONFIG.epsilon) {
-            return new RootNode(new NumberNode(possibleRadicand));
-        }
-        // Fallback to decimal representation
-        return new NumberNode(num);
-    }
-    /**
-     * Helper method to parse exact forms like "√2/2"
-     */
-    parseExactForm(exactForm) {
-        // Handle fractions
-        if (exactForm.includes('/')) {
-            const [numerator, denominator] = exactForm.split('/');
-            return new BinaryOpNode('/', this.parseExactForm(numerator), this.parseExactForm(denominator));
-        }
-        // Handle square roots
-        if (exactForm.startsWith('√')) {
-            const argument = exactForm.substring(1);
-            return new RootNode(this.parseExactForm(argument));
-        }
-        // Handle simple numbers
-        if (/^\d+$/.test(exactForm)) {
-            return new NumberNode(Number.parseInt(exactForm));
-        }
-        // Handle known constants
-        for (const constant of CONSTANTS) {
-            if (exactForm === constant.getSymbol()) {
-                return new ConstantNode(constant.getSymbol(), constant.value);
-            }
-        }
-        // If we don't recognize it, treat it as a symbol
-        return new ConstantNode(exactForm, Number.NaN);
-    }
-    /**
-     * Helper to determine if a value is "nice"
-     */
-    isNiceValue(num) {
-        // Check if it's close to an integer
-        if (Math.abs(num - Math.round(num)) < CONFIG.epsilon) {
-            return true;
-        }
-        const cfTerms = toContinuedFraction(num, 10);
-        const convergents = getConvergents(cfTerms);
-        // Check if any convergent is a good approximation and reasonably simple
-        for (const [numerator, denominator] of convergents) {
-            // Only consider "nice" fractions (reasonable size numerator/denominator)
-            if (denominator <= 20 && Math.abs(numerator) <= 50) {
-                if (Math.abs(num - numerator / denominator) < CONFIG.epsilon) {
-                    return true;
-                }
-            }
-        }
-        // Check if it's a square root of a small integer (highest priority)
-        // This helps prefer direct √n forms
-        for (let i = 2; i <= 30; i++) {
-            if (Math.abs(num - Math.sqrt(i)) < CONFIG.epsilon) {
-                // Give very high priority to prime square roots
-                if (isPrime(i)) {
-                    return true;
-                }
-                // Also prioritize other small square roots
-                if (i <= 20) {
-                    return true;
-                }
-            }
-        }
-        // Check if it's close to a common constant
-        for (const constant of CONSTANTS) {
-            if (Math.abs(num - constant.value) < CONFIG.epsilon) {
-                return true;
-            }
-        }
-        // Check trig values
-        for (const value of TRIG_VALUES) {
-            if (Math.abs(num - value.value) < CONFIG.epsilon) {
-                return true;
-            }
-        }
-        // Other common values with lower priority
-        const COMMON_VALUES = [
-            Math.sin(Math.PI / 3),
-            Math.cos(Math.PI / 4),
-        ];
-        for (const value of COMMON_VALUES) {
-            if (Math.abs(num - value) < CONFIG.epsilon) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Find greatest common divisor helper method
-     */
-    findGCD(a, b) {
-        a = Math.abs(a);
-        b = Math.abs(b);
-        while (b !== 0) {
-            const temp = b;
-            b = a % b;
-            a = temp;
-        }
-        return a;
-    }
-}
-
-/**
- * Symbolic Number Printer using Expression Tree Representation
- *
- * This implementation uses a proper expression tree to represent mathematical
- * expressions, enabling more sophisticated simplification and consistent formatting.
- */
-/**
- * Main function to convert a number to its symbolic representation
- * @param num The number to convert to symbolic form
- * @returns A string containing the symbolic representation
- */
-function prettyPi(num, config = {}) {
-    if (!isFinite(num)) {
-        if (isNaN(num)) {
-            return "NaN";
-        }
-        return num > 0 ? "∞" : "-∞";
-    }
-    setConfig(config);
-    const parser = new ExpressionParser();
-    const exprTree = parser.parseNumber(num);
-    const simplified = exprTree.simplify();
-    return simplified.toString();
-}
-
 function stringifyValue(value, html) {
     var _a;
     var gt = '>';
@@ -32837,7 +31339,7 @@ function stringifyValue(value, html) {
     if (typeof value === 'object' && value instanceof RegExp)
         return "".concat(value);
     if (typeof value === 'number') {
-        return prettyPi(value);
+        return "".concat(value);
     }
     if (isRegularExpression(value))
         return "/".concat(value.s, "/").concat(value.f);
@@ -32850,12 +31352,12 @@ function stringifyValue(value, html) {
             return '[]';
         if (value.length > 8) {
             return "[\n  ".concat(value.map(function (cell) {
-                return prettyPi(cell);
+                return cell;
             }).join(',\n  '), "\n]");
         }
         else {
             return "[".concat(value.map(function (cell) {
-                return prettyPi(cell);
+                return cell;
             }).join(', '), "]");
         }
     }
@@ -32891,45 +31393,11 @@ function replaceInfinities(value) {
     }
     return value;
 }
-function prettyIfNumber(value) {
-    if (typeof value === 'number') {
-        return prettyPi(value);
-    }
-    return "".concat(value);
-}
 function stringifyMatrix(matrix) {
-    var padding = matrix.flat().reduce(function (max, cell) { return Math.max(max, prettyIfNumber(cell).length); }, 0) + 1;
-    var rows = matrix.map(function (row) { return "[".concat(row.map(function (cell) { return prettyIfNumber(cell).padStart(padding); }).join(' '), " ]"); });
+    var padding = matrix.flat().reduce(function (max, cell) { return Math.max(max, "".concat(cell).length); }, 0) + 1;
+    var rows = matrix.map(function (row) { return "[".concat(row.map(function (cell) { return "".concat(cell).padStart(padding); }).join(' '), " ]"); });
     return rows.join('\n');
 }
-// function isMatrix(value: unknown): value is (null | number | string | boolean)[][] {
-//   if (!Array.isArray(value)) {
-//     return false
-//   }
-//   if (!value.every(row => Array.isArray(row))) {
-//     return false
-//   }
-//   let cols = -1
-//   for (const row of value) {
-//     if (cols === -1) {
-//       cols = row.length
-//       if (cols === 0) {
-//         return false
-//       }
-//     }
-//     else {
-//       if (row.length !== cols) {
-//         return false
-//       }
-//     }
-//     for (const cell of row) {
-//       if (typeof cell !== 'number' && typeof cell !== 'string' && typeof cell !== 'boolean' && cell !== null) {
-//         return false
-//       }
-//     }
-//   }
-//   return true
-// }
 function findAllOccurrences(input, pattern) {
     var matches = __spreadArray([], __read(input.matchAll(pattern)), false);
     return new Set(matches.map(function (match) { return match[0]; }));