affinirum 1.0.0

package/dst/cjs/constant/Unknown.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.funcFormat = exports.funcEncode = exports.funcNotEqual = exports.funcEqual = exports.funcCoalesce = exports.format = exports.encode = exports.equate = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const Float_js_1 = require("./Float.js");
+const Integer_js_1 = require("./Integer.js");
+const Buffer_js_1 = require("./Buffer.js");
+const String_js_1 = require("./String.js");
+const Timestamp_js_1 = require("./Timestamp.js");
+const equate = (value1, value2) => {
+    if (value1 == null || value2 == null) {
+        return value1 == value2;
+    }
+    if (typeof value1 !== typeof value2) {
+        if (typeof value1 === 'number' && typeof value2 === 'bigint') {
+            return value1 === Number(value2);
+        }
+        if (typeof value1 === 'bigint' && typeof value2 === 'number') {
+            return Number.isInteger(value2) && value1 === BigInt(value2);
+        }
+        return false;
+    }
+    if (typeof value1 === 'number') {
+        return isNaN(value1) && isNaN(value2) ? true : value1 === value2;
+    }
+    if (typeof value1 === 'boolean' || typeof value1 === 'bigint' || typeof value1 === 'string' || typeof value1 === 'function') {
+        return value1 === value2;
+    }
+    if (value1 instanceof Date && value2 instanceof Date) {
+        return value1.getTime() === value2.getTime();
+    }
+    if (value1 instanceof ArrayBuffer && value2 instanceof ArrayBuffer) {
+        return (0, Buffer_js_1.equateBuffers)(value1, value2);
+    }
+    if (Array.isArray(value1) && Array.isArray(value2)) {
+        if (value1.length === value2.length) {
+            for (let i = 0; i < value1.length; ++i) {
+                if (!(0, exports.equate)(value1[i], value2[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    const props = new Set([...Object.getOwnPropertyNames(value1), ...Object.getOwnPropertyNames(value2)]);
+    for (const prop of props) {
+        if (!(0, exports.equate)(value1[prop], value2[prop])) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.equate = equate;
+const encode = (value, encoding) => value == null
+    ? new Uint8Array(0).buffer
+    : typeof value === 'boolean'
+        ? new Uint8Array([value ? 255 : 0]).buffer
+        : value instanceof Date
+            ? (0, Timestamp_js_1.encodeTimestamp)(value, encoding ?? 'int64')
+            : typeof value === 'number'
+                ? (0, Float_js_1.encodeFloat)(value, encoding ?? 'float64')
+                : typeof value === 'bigint'
+                    ? (0, Integer_js_1.encodeInteger)(value, encoding ?? 'int64')
+                    : value instanceof ArrayBuffer
+                        ? value
+                        : typeof value === 'string'
+                            ? (0, String_js_1.encodeString)(value, encoding ?? 'utf8')
+                            : Array.isArray(value)
+                                ? value.map((i) => (0, exports.encode)(i, encoding)).reduce((acc, val) => (0, Buffer_js_1.concatBuffers)(acc, val))
+                                : typeof value === 'object'
+                                    ? Object.entries(value).map(([k, v]) => (0, Buffer_js_1.concatBuffers)((0, exports.encode)(k, encoding), (0, exports.encode)(v, encoding))).reduce((acc, val) => (0, Buffer_js_1.concatBuffers)(acc, val))
+                                    : new Uint8Array(0).buffer;
+exports.encode = encode;
+const format = (value, radix, separator = '') => value == null
+    ? 'null'
+    : typeof value === 'boolean'
+        ? value.toString()
+        : value instanceof Date
+            ? (0, Timestamp_js_1.formatTimestamp)(value, radix ? Number(radix) : undefined)
+            : typeof value === 'number'
+                ? (0, Float_js_1.formatFloat)(value, radix ? Number(radix) : undefined)
+                : typeof value === 'bigint'
+                    ? value.toString(radix ? Number(radix) : undefined)
+                    : value instanceof ArrayBuffer
+                        ? (0, Buffer_js_1.formatBuffer)(value)
+                        : typeof value === 'string'
+                            ? value
+                            : Array.isArray(value)
+                                ? value.map((i) => (0, exports.format)(i, radix)).join(separator)
+                                : typeof value === 'object'
+                                    ? Object.entries(value).map(([k, v]) => `${(0, exports.format)(k)}${radix}${(0, exports.format)(v)}`).join(separator)
+                                    : 'function';
+exports.format = format;
+const typeEquator = Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [Type_js_1.Type.Unknown, Type_js_1.Type.Unknown]);
+exports.funcCoalesce = new Constant_js_1.Constant((value, valueOtherwise) => value ?? valueOtherwise, Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Unknown, Type_js_1.Type.Unknown]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalFloat, [Type_js_1.Type.OptionalFloat, Type_js_1.Type.OptionalFloat]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalBoolean, [Type_js_1.Type.OptionalBoolean, Type_js_1.Type.OptionalBoolean]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalTimestamp, [Type_js_1.Type.OptionalTimestamp, Type_js_1.Type.OptionalTimestamp]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalInteger, [Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalInteger]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalBuffer, [Type_js_1.Type.OptionalBuffer, Type_js_1.Type.OptionalBuffer]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalString, [Type_js_1.Type.OptionalString, Type_js_1.Type.OptionalString]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalArray, [Type_js_1.Type.OptionalArray, Type_js_1.Type.OptionalArray]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalObject, [Type_js_1.Type.OptionalObject, Type_js_1.Type.OptionalObject]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalFunction, [Type_js_1.Type.OptionalFunction, Type_js_1.Type.OptionalFunction])));
+exports.funcEqual = new Constant_js_1.Constant((value1, value2) => (0, exports.equate)(value1, value2), typeEquator);
+exports.funcNotEqual = new Constant_js_1.Constant((value1, value2) => !(0, exports.equate)(value1, value2), typeEquator);
+exports.funcEncode = new Constant_js_1.Constant((value, encoding) => (0, exports.encode)(value, encoding), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Boolean]), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Timestamp, Type_js_1.Type.OptionalString]), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Float, Type_js_1.Type.OptionalString]), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Integer, Type_js_1.Type.OptionalString]), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.String, Type_js_1.Type.OptionalString]), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Array, Type_js_1.Type.OptionalString]), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Object, Type_js_1.Type.OptionalString])));
+exports.funcFormat = new Constant_js_1.Constant((value, radix, separator = '') => (0, exports.format)(value, radix == null ? undefined : Number(radix), separator), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Boolean]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Timestamp, Type_js_1.Type.OptionalInteger]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Float, Type_js_1.Type.OptionalInteger]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Integer, Type_js_1.Type.OptionalInteger]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Buffer]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Array, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalString]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Object, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalString])));

package/dst/cjs/constant/notation/AN.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constAN = exports.formatAN = void 0;
+const Constant_js_1 = require("../../Constant.js");
+const Type_js_1 = require("../../Type.js");
+const Float_js_1 = require("../Float.js");
+const Buffer_js_1 = require("../Buffer.js");
+const formatAN = (value, whitespace) => {
+    if (value == null) {
+        return 'null';
+    }
+    if (typeof value === 'boolean') {
+        return value.toString();
+    }
+    if (value instanceof Date) {
+        return `@${value.toISOString()}`;
+    }
+    if (typeof value === 'number') {
+        return (0, Float_js_1.formatFloat)(value);
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (value instanceof ArrayBuffer) {
+        return `#${(0, Buffer_js_1.formatBuffer)(value)}`;
+    }
+    if (typeof value === 'string') {
+        return `"${value}"`;
+    }
+    if (Array.isArray(value)) {
+        const [prefix, suffix] = whitespace ? ['\n' + whitespace, '\n'] : ['', ''];
+        const lines = value.map((i) => `${prefix}${(0, exports.formatAN)(i, whitespace).split('\n').join(prefix)}`);
+        return `[${lines.join(',')}${suffix}]`;
+    }
+    if (typeof value === 'object') {
+        const [prefix, suffix] = whitespace ? ['\n' + whitespace, '\n'] : ['', ''];
+        const lines = Object.entries(value).map(([k, v]) => `${prefix}"${k}":${(0, exports.formatAN)(v, whitespace).split('\n').join(prefix)}`);
+        return `[${lines.join(',')}${suffix}]`;
+    }
+    return 'function';
+};
+exports.formatAN = formatAN;
+const funcFormatAN = new Constant_js_1.Constant((value, whitespace) => (0, exports.formatAN)(value ?? null, whitespace), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Unknown, Type_js_1.Type.OptionalString]));
+exports.constAN = {
+    Format: funcFormatAN,
+};

package/dst/cjs/constant/notation/JSON.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constJSON = exports.formatJSON = void 0;
+const Constant_js_1 = require("../../Constant.js");
+const Type_js_1 = require("../../Type.js");
+const typeJson = Type_js_1.Type.union(Type_js_1.Type.Void, Type_js_1.Type.Boolean, Type_js_1.Type.Timestamp, Type_js_1.Type.Float, Type_js_1.Type.Integer, Type_js_1.Type.String, Type_js_1.Type.Array, Type_js_1.Type.Object);
+const formatJSON = (value, whitespace) => JSON.stringify(value, (_key, value) => typeof value === 'bigint' ? value.toString() : value, whitespace);
+exports.formatJSON = formatJSON;
+const funcFormatJSON = new Constant_js_1.Constant((value, whitespace) => (0, exports.formatJSON)(value ?? null, whitespace), Type_js_1.Type.functionType(Type_js_1.Type.String, [typeJson, Type_js_1.Type.OptionalString]));
+const funcParseJSON = new Constant_js_1.Constant((value) => JSON.parse(value), Type_js_1.Type.functionType(typeJson, [Type_js_1.Type.String]));
+exports.constJSON = {
+    Format: funcFormatJSON,
+    Parse: funcParseJSON,
+};

package/dst/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Value.js"), exports);
+__exportStar(require("./Type.js"), exports);
+__exportStar(require("./Affinirum.js"), exports);

package/dst/cjs/node/ArrayNode.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayNode = void 0;
+const Node_js_1 = require("../Node.js");
+const Constant_js_1 = require("../Constant.js");
+const ConstantNode_js_1 = require("./ConstantNode.js");
+const Type_js_1 = require("../Type.js");
+class ArrayNode extends Node_js_1.Node {
+    _subnodes;
+    constructor(frame, _subnodes) {
+        super(frame);
+        this._subnodes = _subnodes;
+    }
+    get type() {
+        return Type_js_1.Type.Array;
+    }
+    compile(type) {
+        this.reduceType(type);
+        let constant = true;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(Type_js_1.Type.Unknown);
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        return this._subnodes.map((s) => s.evaluate());
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} array node subnodes:\n${subnodes}`;
+    }
+}
+exports.ArrayNode = ArrayNode;

package/dst/cjs/node/BlockNode.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockNode = void 0;
+const Node_js_1 = require("../Node.js");
+const Constant_js_1 = require("../Constant.js");
+const ConstantNode_js_1 = require("./ConstantNode.js");
+const Type_js_1 = require("../Type.js");
+class BlockNode extends Node_js_1.Node {
+    _subnodes;
+    constructor(frame, _subnodes) {
+        super(frame);
+        this._subnodes = _subnodes;
+    }
+    get type() {
+        return this._subnodes[this._subnodes.length - 1].type;
+    }
+    compile(type) {
+        let constant = true;
+        for (let i = 0, last = this._subnodes.length - 1; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(i < last ? Type_js_1.Type.Unknown : type);
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        return this._subnodes.map((s) => s.evaluate())[this._subnodes.length - 1];
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} block node subnodes:\n${subnodes}`;
+    }
+}
+exports.BlockNode = BlockNode;

package/dst/cjs/node/CallNode.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallNode = void 0;
+const Node_js_1 = require("../Node.js");
+const Constant_js_1 = require("../Constant.js");
+const ConstantNode_js_1 = require("./ConstantNode.js");
+const Type_js_1 = require("../Type.js");
+class CallNode extends Node_js_1.Node {
+    _fnode;
+    _subnodes;
+    _type;
+    constructor(frame, _fnode, _subnodes) {
+        super(frame);
+        this._fnode = _fnode;
+        this._subnodes = _subnodes;
+        this._type = this._fnode.type.mergeFunctionAtom(Type_js_1.Type.Unknown, _subnodes.length)?.retType ?? Type_js_1.Type.Unknown;
+    }
+    get type() {
+        return this._type;
+    }
+    compile(type) {
+        this._fnode = this._fnode.compile(this._fnode.type);
+        const mergedFunctionAtom = this._fnode.type.mergeFunctionAtom(type, this._subnodes.length);
+        if (!mergedFunctionAtom) {
+            this.throwError(`function type ${this._fnode.type} mismatch with expected return type ${type} and ${this._subnodes.length} arguments`);
+        }
+        this._type = mergedFunctionAtom.retType;
+        if (this._subnodes.length < mergedFunctionAtom.minArity) {
+            this.throwError(`function requires ${mergedFunctionAtom.minArity} arguments not ${this._subnodes.length}`);
+        }
+        if (this._subnodes.length > mergedFunctionAtom.maxArity) {
+            this.throwError(`function requires ${mergedFunctionAtom.maxArity} arguments not ${this._subnodes.length}`);
+        }
+        let constant = this._fnode.constant;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(mergedFunctionAtom.argType(i));
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        const func = this._fnode.evaluate();
+        if (typeof func !== 'function') {
+            this.throwError(`function expected not ${Type_js_1.Type.of(func)}`);
+        }
+        return func(...this._subnodes.map((node) => node.evaluate()));
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} invocation node fnode:\n${this._fnode.toString(ident + 1)}\n`
+            + `${super.toString(ident)} invocation node subnodes:\n${subnodes}`;
+    }
+}
+exports.CallNode = CallNode;

package/dst/cjs/node/ConstantNode.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantNode = void 0;
+const Node_js_1 = require("../Node.js");
+class ConstantNode extends Node_js_1.Node {
+    _constant;
+    _subnode;
+    constructor(frame, _constant, _subnode) {
+        super(frame);
+        this._constant = _constant;
+        this._subnode = _subnode;
+    }
+    get type() {
+        return this._constant.type;
+    }
+    compile(type) {
+        this._constant.type = this.reduceType(type);
+        this._subnode = this._subnode?.compile(this._constant.type.mergeFunctionAtomRetType(type));
+        return this;
+    }
+    evaluate() {
+        return this._constant.value;
+    }
+    get constant() {
+        return !this._subnode && this._constant.deterministic;
+    }
+    toString(ident = 0) {
+        return this._subnode
+            ? `${super.toString(ident)} constant node subnode:\n${this._subnode.toString(ident + 1)}`
+            : `${super.toString(ident)} constant node`;
+    }
+}
+exports.ConstantNode = ConstantNode;

package/dst/cjs/node/LoopNode.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopNode = void 0;
+const Node_js_1 = require("../Node.js");
+const Type_js_1 = require("../Type.js");
+class LoopNode extends Node_js_1.Node {
+    _cnode;
+    _subnode;
+    constructor(frame, _cnode, _subnode) {
+        super(frame);
+        this._cnode = _cnode;
+        this._subnode = _subnode;
+    }
+    get type() {
+        return this._subnode.type;
+    }
+    compile(type) {
+        this._cnode = this._cnode.compile(Type_js_1.Type.Boolean);
+        this._subnode = this._subnode.compile(type);
+        return this;
+    }
+    evaluate() {
+        let value;
+        while (this._cnode.evaluate()) {
+            value = this._subnode.evaluate();
+        }
+        return value;
+    }
+    toString(ident = 0) {
+        return `${super.toString(ident)} loop node cnode:\n${this._cnode.toString(ident + 1)}\n`
+            + `${super.toString(ident)} subnode:\n${this._subnode.toString(ident + 1)}`;
+    }
+}
+exports.LoopNode = LoopNode;

package/dst/cjs/node/ObjectNode.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectNode = void 0;
+const Node_js_1 = require("../Node.js");
+const Constant_js_1 = require("../Constant.js");
+const ConstantNode_js_1 = require("./ConstantNode.js");
+const Type_js_1 = require("../Type.js");
+class ObjectNode extends Node_js_1.Node {
+    _subnodes;
+    _type;
+    constructor(frame, _subnodes) {
+        super(frame);
+        this._subnodes = _subnodes;
+        this._type = Type_js_1.Type.Object;
+    }
+    get type() {
+        return this._type;
+    }
+    compile(type) {
+        this._type = this.reduceType(type);
+        let constant = true;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i][0] = this._subnodes[i][0].compile(Type_js_1.Type.String);
+            constant &&= this._subnodes[i][0].constant;
+            this._subnodes[i][1] = this._subnodes[i][1].compile(Type_js_1.Type.Unknown);
+            constant &&= this._subnodes[i][1].constant;
+        }
+        return constant ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type)) : this;
+    }
+    evaluate() {
+        const obj = {};
+        for (const [key, value] of this._subnodes) {
+            obj[key.evaluate()] = value.evaluate();
+        }
+        return obj;
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map(([k, v]) => `${k.toString(ident + 1)}:\n${v.toString(ident + 1)}`).join('\n');
+        return `${super.toString(ident)} object node subnodes:\n${subnodes}`;
+    }
+}
+exports.ObjectNode = ObjectNode;

package/dst/cjs/node/SwitchNode.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchNode = void 0;
+const Node_js_1 = require("../Node.js");
+const Constant_js_1 = require("../Constant.js");
+const ConstantNode_js_1 = require("./ConstantNode.js");
+const Type_js_1 = require("../Type.js");
+class SwitchNode extends Node_js_1.Node {
+    _cnode;
+    _subnodes;
+    _type;
+    constructor(frame, _cnode, _subnodes) {
+        super(frame);
+        this._cnode = _cnode;
+        this._subnodes = _subnodes;
+        if (_subnodes.length !== 2) {
+            this.throwError(`switch requires 2 subnodes not ${_subnodes.length}`);
+        }
+        this._type = Type_js_1.Type.union(...this._subnodes.map((i) => i.type));
+    }
+    get type() {
+        return Type_js_1.Type.union(...this._subnodes.map((i) => i.type));
+    }
+    compile(type) {
+        this._cnode = this._cnode.compile(Type_js_1.Type.Boolean);
+        this._type = type;
+        let constant = this._cnode.constant;
+        for (let i = 0; i < this._subnodes.length; ++i) {
+            this._subnodes[i] = this._subnodes[i].compile(type);
+            constant &&= this._subnodes[i].constant;
+        }
+        return constant
+            ? new ConstantNode_js_1.ConstantNode(this, new Constant_js_1.Constant(this.evaluate(), this.type))
+            : this;
+    }
+    evaluate() {
+        return this._cnode.evaluate() ? this._subnodes[0].evaluate() : this._subnodes[1].evaluate();
+    }
+    toString(ident = 0) {
+        const subnodes = this._subnodes.map((s) => s.toString(ident + 1)).join('\n');
+        return `${super.toString(ident)} switch node cnode:\n${this._cnode.toString(ident + 1)}\n`
+            + `${super.toString(ident)} switch node subnodes:\n${subnodes}`;
+    }
+}
+exports.SwitchNode = SwitchNode;

package/dst/cjs/node/VariableNode.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableNode = void 0;
+const Node_js_1 = require("../Node.js");
+class VariableNode extends Node_js_1.Node {
+    _variable;
+    _subnode;
+    constructor(frame, _variable, _subnode) {
+        super(frame);
+        this._variable = _variable;
+        this._subnode = _subnode;
+    }
+    get type() {
+        return this._variable.type;
+    }
+    compile(type) {
+        this._subnode = this._subnode?.compile(type);
+        this._variable.type = this.reduceType(this._subnode?.type ?? type);
+        return this;
+    }
+    evaluate() {
+        return this._subnode ? this._variable.value = this._subnode.evaluate() : this._variable.value;
+    }
+    toString(ident = 0) {
+        return this._subnode
+            ? `${super.toString(ident)} variable node subnode:\n${this._subnode.toString(ident + 1)}`
+            : `${super.toString(ident)} variable node`;
+    }
+}
+exports.VariableNode = VariableNode;

package/dst/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dst/constant/Array.d.ts

@@ -0,0 +1,22 @@
+import { Constant } from '../Constant.js';
+export declare const funcFirst: Constant;
+export declare const funcLast: Constant;
+export declare const funcFirstIndex: Constant;
+export declare const funcLastIndex: Constant;
+export declare const funcEvery: Constant;
+export declare const funcAny: Constant;
+export declare const funcFlatten: Constant;
+export declare const funcReverse: Constant;
+export declare const funcMutate: Constant;
+export declare const funcFilter: Constant;
+export declare const funcReduce: Constant;
+export declare const funcCompose: Constant;
+export declare const funcPrepend: Constant;
+export declare const funcAppend: Constant;
+export declare const constArray: {
+    Join: Constant;
+    Range: Constant;
+    Unique: Constant;
+    Intersection: Constant;
+    Difference: Constant;
+};

package/dst/constant/Array.js

@@ -0,0 +1,90 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+import { equate } from './Unknown.js';
+const typePredicate = Type.functionType(Type.Boolean, [Type.Unknown, Type.OptionalInteger, Type.OptionalArray]);
+const typeItemFinder = Type.functionType(Type.Unknown, [Type.Array, typePredicate]);
+const typeIndexFinder = Type.functionType(Type.OptionalInteger, [Type.Array, typePredicate]);
+const typeConditionSet = Type.functionType(Type.Boolean, [Type.Array, typePredicate]);
+const typeVariadicInsert = Type.functionType(Type.Array, [Type.Array, Type.Unknown], true);
+const typeArrayOperator = Type.functionType(Type.Array, [Type.Array, Type.Array]);
+export const funcFirst = new Constant((value, predicate) => value?.find((v, i, a) => predicate(v, BigInt(i), a)), typeItemFinder);
+export const funcLast = new Constant((value, predicate) => {
+    if (value == null) {
+        return undefined;
+    }
+    for (let i = value.length - 1; i >= 0; --i) {
+        if (predicate(value[i], BigInt(i), value)) {
+            return value[i];
+        }
+    }
+    return undefined;
+}, typeItemFinder);
+export const funcFirstIndex = new Constant((value, predicate) => {
+    if (value == null) {
+        return undefined;
+    }
+    const ix = value.findIndex((v, i, a) => predicate(v, BigInt(i), a));
+    return ix < 0 ? undefined : BigInt.asIntN(64, BigInt(ix));
+}, typeIndexFinder);
+export const funcLastIndex = new Constant((value, predicate) => {
+    if (value == null) {
+        return undefined;
+    }
+    for (let i = value.length - 1; i >= 0; i--) {
+        if (predicate(value[i], BigInt(i), value)) {
+            return BigInt.asIntN(64, BigInt(i));
+        }
+    }
+    return undefined;
+}, typeIndexFinder);
+export const funcEvery = new Constant((value, predicate) => value?.every((v, i, a) => predicate(v, BigInt(i), a)), typeConditionSet);
+export const funcAny = new Constant((value, predicate) => value?.some((v, i, a) => predicate(v, BigInt(i), a)), typeConditionSet);
+export const funcFlatten = new Constant((values, depth = 1n) => values?.flat(Number(depth)), Type.functionType(Type.Array, [Type.Array, Type.OptionalInteger]));
+export const funcReverse = new Constant((value) => [...value].reverse(), Type.functionType(Type.Array, [Type.Array]));
+export const funcMutate = new Constant((value, transform) => value?.map((v, i, a) => transform(v, BigInt(i), a)), Type.functionType(Type.Array, [Type.Array, Type.functionType(Type.Unknown, [Type.Unknown, Type.OptionalInteger, Type.OptionalArray])]));
+export const funcFilter = new Constant((value, predicate) => value?.filter((v, i, a) => predicate(v, BigInt(i), a)), Type.functionType(Type.Array, [Type.Array, typePredicate]));
+export const funcReduce = new Constant((value, reducer, initial) => initial != null
+    ? value?.reduce((p, v, i, a) => reducer(p, v, BigInt(i), a), initial) : value?.reduce((p, v, i, a) => reducer(p, v, BigInt(i), a)), Type.functionType(Type.Unknown, [Type.Array, Type.functionType(Type.Unknown, [Type.Unknown, Type.Unknown, Type.OptionalInteger, Type.OptionalArray])]));
+export const funcCompose = new Constant((value, callback) => {
+    if (value == null) {
+        return undefined;
+    }
+    const obj = {};
+    for (let i = 0; i < value.length; ++i) {
+        const key = value[i];
+        obj[key] = callback(obj, key, BigInt(i), value);
+    }
+    return obj;
+}, Type.functionType(Type.Object, [Type.Array, Type.functionType(Type.Unknown, [Type.Object, Type.String, Type.OptionalInteger, Type.OptionalArray])]));
+export const funcPrepend = new Constant((value, ...items) => {
+    value.unshift(items);
+    return value;
+}, typeVariadicInsert);
+export const funcAppend = new Constant((value, ...items) => {
+    value.push(items);
+    return value;
+}, typeVariadicInsert);
+const funcJoin = new Constant((...values) => values.flat(Infinity).reduce((acc, val) => [...acc, val], []), Type.functionType(Type.Array, [Type.Array], true));
+const funcRange = new Constant((value1, value2) => {
+    const min = value1 < value2 ? value1 : value2;
+    const max = value1 > value2 ? value1 : value2;
+    return [...Array(Number(max - min)).keys()].map((i) => BigInt(i) + min);
+}, Type.functionType(Type.Array, [Type.Integer, Type.Integer]));
+const funcUnique = new Constant((value) => {
+    const result = [];
+    value.forEach((i) => {
+        if (result.every((v) => !equate(v, i))) {
+            result.push(i);
+        }
+    });
+    return result;
+}, Type.functionType(Type.Array, [Type.Array]));
+const funcIntersection = new Constant((value1, value2) => value1.filter((i) => value2.some((v) => equate(v, i))), typeArrayOperator);
+const funcDifference = new Constant((value1, value2) => [...value1.filter((i) => value2.every((v) => !equate(v, i))), ...value2.filter((i) => value1.every((v) => !equate(v, i)))], typeArrayOperator);
+export const constArray = {
+    Join: funcJoin,
+    Range: funcRange,
+    Unique: funcUnique,
+    Intersection: funcIntersection,
+    Difference: funcDifference,
+};

package/dst/constant/Boolean.d.ts

@@ -0,0 +1,11 @@
+import { Constant } from '../Constant.js';
+export declare const funcOr: Constant;
+export declare const funcAnd: Constant;
+export declare const funcNot: Constant;
+export declare const constBoolean: {
+    Or: Constant;
+    And: Constant;
+    Not: Constant;
+    Decode: Constant;
+    Parse: Constant;
+};

package/dst/constant/Boolean.js

@@ -0,0 +1,22 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+const typeBooleanOrArray = Type.union(Type.Boolean, Type.arrayType([Type.Boolean]));
+const typeBooleanLogic = Type.functionType(Type.Boolean, [typeBooleanOrArray], true);
+export const funcOr = new Constant((...values) => values.flat().some((v) => v), typeBooleanLogic);
+export const funcAnd = new Constant((...values) => values.flat().every((v) => v), typeBooleanLogic);
+export const funcNot = new Constant((value) => !value, Type.functionType(Type.Boolean, [Type.Boolean]));
+const funcDecodeBoolean = new Constant((value, byteOffset) => Boolean(new Uint8Array(value)[byteOffset == null ? 0 : Number(byteOffset)]), Type.functionType(Type.OptionalBoolean, [Type.Buffer, Type.OptionalInteger]));
+const funcParseBoolean = new Constant((value) => {
+    if (value == null) {
+        return undefined;
+    }
+    const v = value.toLowerCase();
+    return v === 'true' ? true : v === 'false' ? false : undefined;
+}, Type.functionType(Type.OptionalBoolean, [Type.String]));
+export const constBoolean = {
+    Or: funcOr,
+    And: funcAnd,
+    Not: funcNot,
+    Decode: funcDecodeBoolean,
+    Parse: funcParseBoolean,
+};