affinirum 1.0.0

package/dst/cjs/StaticScope.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticScope = void 0;
+class StaticScope {
+    _superscope;
+    _subscopes = [];
+    _variables = new Map();
+    _locals = new Set();
+    has(name) {
+        return this._variables.has(name) || Boolean(this._superscope?.has(name));
+    }
+    get(name) {
+        return this._variables.get(name) ?? this._superscope?.get(name);
+    }
+    global(name, variable) {
+        if (this._superscope) {
+            this._superscope.global(name, variable);
+        }
+        else {
+            this._variables.set(name, variable);
+        }
+        return this;
+    }
+    local(name, variable) {
+        this._variables.set(name, variable);
+        this._locals.add(name);
+        return this;
+    }
+    subscope(variables) {
+        const scope = new StaticScope();
+        scope._superscope = this;
+        this._subscopes.push(scope);
+        for (const [name, variable] of variables) {
+            scope.local(name, variable);
+        }
+        return scope;
+    }
+    variables() {
+        const variables = {};
+        for (const [name, variable] of this._variables) {
+            if (!this._locals.has(name)) {
+                variables[name] = variable;
+            }
+        }
+        return variables;
+    }
+}
+exports.StaticScope = StaticScope;

package/dst/cjs/Type.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = void 0;
+const PrimitiveAtom_js_1 = require("./atom/PrimitiveAtom.js");
+const ArrayAtom_js_1 = require("./atom/ArrayAtom.js");
+const ObjectAtom_js_1 = require("./atom/ObjectAtom.js");
+const FunctionAtom_js_1 = require("./atom/FunctionAtom.js");
+class Type {
+    _atoms;
+    constructor(_atoms = []) {
+        this._atoms = _atoms;
+    }
+    get isUnknown() {
+        return this._atoms.length === 0;
+    }
+    get isAtom() {
+        return this._atoms.length === 1;
+    }
+    get isOptional() {
+        return this.isUnknown || this._atoms.length > 1 && this._atoms.some((i) => i.match(Type.Void._atoms[0]));
+    }
+    get isVoid() {
+        return this.isAtom && this._atoms[0].match(Type.Void._atoms[0]);
+    }
+    get isBoolean() {
+        return this.isAtom && this._atoms[0].match(Type.Boolean._atoms[0]);
+    }
+    get isTimestamp() {
+        return this.isAtom && this._atoms[0].match(Type.Timestamp._atoms[0]);
+    }
+    get isFloat() {
+        return this.isAtom && this._atoms[0].match(Type.Float._atoms[0]);
+    }
+    get isInteger() {
+        return this.isAtom && this._atoms[0].match(Type.Integer._atoms[0]);
+    }
+    get isBuffer() {
+        return this.isAtom && this._atoms[0].match(Type.Buffer._atoms[0]);
+    }
+    get isString() {
+        return this.isAtom && this._atoms[0].match(Type.String._atoms[0]);
+    }
+    get isArray() {
+        return this._atoms.every((i) => i instanceof ArrayAtom_js_1.ArrayAtom);
+    }
+    get isObject() {
+        return this._atoms.every((i) => i instanceof ObjectAtom_js_1.ObjectAtom);
+    }
+    get isFunction() {
+        return this._atoms.every((i) => i instanceof FunctionAtom_js_1.FunctionAtom);
+    }
+    get isNumeric() {
+        return this._atoms.length === 2
+            && (this._atoms[0].match(Type.Float._atoms[0]) || this._atoms[0].match(Type.Integer._atoms[0]));
+    }
+    toOptional() {
+        return this._atoms.length ? Type.union(Type.Void, this) : this;
+    }
+    mergeFunctionAtomRetType(type) {
+        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom_js_1.FunctionAtom && (!i.retType || i.retType.match(type)));
+        return Type.union(...atoms.map((i) => i.retType ?? Type.Unknown));
+    }
+    mergeFunctionAtom(type, argc) {
+        if (this.isUnknown || type.isVoid) {
+            return Type._functionAtom(type, Array.from({ length: argc }).map(() => Type.Unknown), false);
+        }
+        const atoms = this._atoms.filter((i) => i instanceof FunctionAtom_js_1.FunctionAtom && i.minArity <= argc && i.maxArity >= argc && (!i.retType || i.retType.match(type)));
+        if (!atoms.length) {
+            return undefined;
+        }
+        return Type._functionAtom(Type.union(...atoms.map((i) => i.retType ?? Type.Unknown)), Array.from({ length: argc }).map((_, ix) => Type.union(...atoms.map((i) => i.argType(ix)))), atoms.some((i) => i.isVariadic));
+    }
+    reduce(mask) {
+        if (mask.isUnknown || mask.isVoid) {
+            return this;
+        }
+        if (this.isUnknown) {
+            return mask;
+        }
+        const list = this._atoms.filter((i) => mask.match(i));
+        return list.length === 0
+            ? undefined
+            : list.length === this._atoms.length
+                ? this
+                : new Type(list);
+    }
+    match(type) {
+        if (type instanceof Type) {
+            return this.isUnknown || type.isUnknown || type.isVoid || this._atoms.some((i) => type._atoms.some((j) => i.match(j)));
+        }
+        else {
+            return this._atoms.some((i) => i.match(type));
+        }
+    }
+    weight() {
+        return this._atoms.reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        return this._atoms.length
+            ? this._atoms.sort((a, b) => a.weight() - b.weight()).map((i) => i.toString()).join('|')
+            : '??';
+    }
+    static union(...types) {
+        if (types.some((i) => i.isUnknown)) {
+            return Type.Unknown;
+        }
+        const type = new Type([]);
+        types.map((i) => i._atoms).flat().forEach((i) => {
+            if (!type.match(i)) {
+                type._atoms.push(i);
+            }
+        });
+        return type;
+    }
+    static of(value) {
+        return value == null
+            ? Type.Void
+            : typeof value === 'boolean'
+                ? Type.Boolean
+                : value instanceof Date
+                    ? Type.Timestamp
+                    : typeof value === 'number'
+                        ? Type.Float
+                        : typeof value === 'bigint'
+                            ? Type.Integer
+                            : value instanceof ArrayBuffer
+                                ? Type.Buffer
+                                : typeof value === 'string'
+                                    ? Type.String
+                                    : Array.isArray(value)
+                                        ? Type.Array
+                                        : typeof value === 'object'
+                                            ? Type.Object
+                                            : Type.Function;
+    }
+    static isPrimitiveType(value) {
+        return value == null
+            || typeof value === 'boolean'
+            || value instanceof Date
+            || typeof value === 'number'
+            || typeof value === 'bigint'
+            || value instanceof ArrayBuffer
+            || typeof value === 'string';
+    }
+    static arrayType(itemTypes = []) {
+        return new Type([new ArrayAtom_js_1.ArrayAtom(itemTypes)]);
+    }
+    static objectType(propTypes = {}) {
+        return new Type([new ObjectAtom_js_1.ObjectAtom(propTypes)]);
+    }
+    static functionType(retType, argTypes = [], isVariadic = false) {
+        return new Type([Type._functionAtom(retType, argTypes, isVariadic)]);
+    }
+    static Unknown = new Type();
+    static Void = Type._primitiveType('void');
+    static Boolean = Type._primitiveType('boolean');
+    static OptionalBoolean = Type.union(Type.Void, Type.Boolean);
+    static Timestamp = Type._primitiveType('timestamp');
+    static OptionalTimestamp = Type.union(Type.Void, Type.Timestamp);
+    static Float = Type._primitiveType('float');
+    static OptionalFloat = Type.union(Type.Void, Type.Float);
+    static Integer = Type._primitiveType('integer');
+    static OptionalInteger = Type.union(Type.Void, Type.Integer);
+    static Buffer = Type._primitiveType('buffer');
+    static OptionalBuffer = Type.union(Type.Void, Type.Buffer);
+    static String = Type._primitiveType('string');
+    static OptionalString = Type.union(Type.Void, Type.String);
+    static Array = Type.arrayType();
+    static OptionalArray = Type.union(Type.Void, Type.Array);
+    static Object = Type.objectType();
+    static OptionalObject = Type.union(Type.Void, Type.Object);
+    static Function = Type.functionType();
+    static OptionalFunction = Type.union(Type.Void, Type.Function);
+    static Number = Type.union(Type.Float, Type.Integer);
+    static OptionalNumber = Type.union(Type.Void, Type.Float, Type.Integer);
+    static Enumerable = Type.union(Type.Buffer, Type.String, Type.Array);
+    static OptionalEnumerable = Type.union(Type.Void, Type.Buffer, Type.String, Type.Array);
+    static Iterable = Type.union(Type.Buffer, Type.String, Type.Array, Type.Object);
+    static OptionalIterable = Type.union(Type.Void, Type.Buffer, Type.String, Type.Array, Type.Object);
+    static _primitiveType(primitive) {
+        return new Type([new PrimitiveAtom_js_1.PrimitiveAtom(primitive)]);
+    }
+    static _functionAtom(retType, argTypes = [], isVariadic = false) {
+        let ix = 0;
+        while (ix < argTypes.length && !argTypes[ix].isOptional) {
+            ++ix;
+        }
+        const minArity = ix;
+        if (ix < argTypes.length) {
+            while (ix < argTypes.length && argTypes[ix].isOptional) {
+                ++ix;
+            }
+            if (ix < argTypes.length) {
+                throw new Error('a required parameter illegally follows an optional one');
+            }
+        }
+        return new FunctionAtom_js_1.FunctionAtom(retType, argTypes, minArity, isVariadic);
+    }
+}
+exports.Type = Type;

package/dst/cjs/Value.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dst/cjs/Variable.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Variable = void 0;
+const Type_js_1 = require("./Type.js");
+class Variable {
+    _type;
+    _constant;
+    _value;
+    constructor(_type = Type_js_1.Type.Unknown, _constant = false) {
+        this._type = _type;
+        this._constant = _constant;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(type) {
+        this._type = type;
+    }
+    get constant() {
+        return this._constant;
+    }
+}
+exports.Variable = Variable;

package/dst/cjs/atom/ArrayAtom.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayAtom = void 0;
+class ArrayAtom {
+    _itemTypes;
+    constructor(_itemTypes = []) {
+        this._itemTypes = _itemTypes;
+    }
+    get empty() {
+        return this._itemTypes.length === 0;
+    }
+    subtypes() {
+        return this._itemTypes;
+    }
+    itemType(index) {
+        return this._itemTypes[index];
+    }
+    match(type) {
+        if (type instanceof ArrayAtom) {
+            if (this.empty || type.empty) {
+                return true;
+            }
+            if (this.subtypes().length !== type.subtypes().length) {
+                return false;
+            }
+            for (let i = 0; i < this._itemTypes.length; ++i) {
+                if (!this._itemTypes[i].match(type._itemTypes[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    weight() {
+        return 0x10000 + this.subtypes().reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        return `[${this._itemTypes.join(',')}]`;
+    }
+}
+exports.ArrayAtom = ArrayAtom;

package/dst/cjs/atom/FunctionAtom.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionAtom = void 0;
+class FunctionAtom {
+    _retType;
+    _argTypes;
+    _minArity;
+    _isVariadic;
+    constructor(_retType, _argTypes = [], _minArity = _argTypes.length, _isVariadic = false) {
+        this._retType = _retType;
+        this._argTypes = _argTypes;
+        this._minArity = _minArity;
+        this._isVariadic = _isVariadic;
+    }
+    get retType() {
+        return this._retType;
+    }
+    get minArity() {
+        return this._minArity;
+    }
+    get maxArity() {
+        return this._isVariadic ? Number.POSITIVE_INFINITY : this._argTypes.length;
+    }
+    get isVariadic() {
+        return this._isVariadic;
+    }
+    subtypes() {
+        return this._retType ? [this._retType, ...this._argTypes] : [];
+    }
+    argType(index) {
+        return this._argTypes[index] ?? this._argTypes[this._argTypes.length - 1];
+    }
+    match(type) {
+        if (type instanceof FunctionAtom) {
+            if (!this._retType || !type._retType) {
+                return true;
+            }
+            if (!this._retType.match(type._retType) || this.minArity > type.maxArity || this.maxArity < type.minArity) {
+                return false;
+            }
+            for (let i = 0, argc = Math.max(this.minArity, type.minArity); i < argc; ++i) {
+                if (!this.argType(i).match(type.argType(i))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    weight() {
+        return 0x1000000000000 + this.subtypes().reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        const argTypes = this._argTypes.map((i) => i.toString()).join(',');
+        return this._retType ? `~${this._retType.toString()}(${argTypes}${this.isVariadic ? '...' : ''})` : '~()';
+    }
+}
+exports.FunctionAtom = FunctionAtom;

package/dst/cjs/atom/ObjectAtom.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectAtom = void 0;
+class ObjectAtom {
+    _propTypes;
+    constructor(_propTypes = {}) {
+        this._propTypes = _propTypes;
+    }
+    get empty() {
+        return Object.keys(this._propTypes).length === 0;
+    }
+    subtypes() {
+        return Object.values(this._propTypes);
+    }
+    propType(property) {
+        return this._propTypes[property];
+    }
+    match(type) {
+        if (type instanceof ObjectAtom) {
+            if (this.empty || type.empty) {
+                return true;
+            }
+            for (const prop in this._propTypes) {
+                if (!type.propType(prop)) {
+                    return false;
+                }
+                if (!this._propTypes[prop].match(type._propTypes[prop])) {
+                    return false;
+                }
+            }
+            for (const prop in type._propTypes) {
+                if (!this.propType(prop)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    weight() {
+        return 0x100000000 + this.subtypes().reduce((acc, i) => acc + i.weight(), 0);
+    }
+    toString() {
+        const entries = Object.entries(this._propTypes);
+        return entries.length ? `[${entries.map((i) => i[0] + ':' + i[1].toString()).join(',')}]` : '[:]';
+    }
+}
+exports.ObjectAtom = ObjectAtom;

package/dst/cjs/atom/PrimitiveAtom.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimitiveAtom = void 0;
+class PrimitiveAtom {
+    _primitive;
+    constructor(_primitive = 'void') {
+        this._primitive = _primitive;
+    }
+    match(type) {
+        if (type instanceof PrimitiveAtom) {
+            return type._primitive === this._primitive;
+        }
+        return false;
+    }
+    weight() {
+        switch (this._primitive) {
+            case 'void': return 0x0;
+            case 'boolean': return 0x2;
+            case 'timestamp': return 0x3;
+            case 'float': return 0x8;
+            case 'integer': return 0x10;
+            case 'buffer': return 0x20;
+            case 'string': return 0x30;
+        }
+    }
+    toString() {
+        return this._primitive;
+    }
+}
+exports.PrimitiveAtom = PrimitiveAtom;

package/dst/cjs/constant/Array.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constArray = exports.funcAppend = exports.funcPrepend = exports.funcCompose = exports.funcReduce = exports.funcFilter = exports.funcMutate = exports.funcReverse = exports.funcFlatten = exports.funcAny = exports.funcEvery = exports.funcLastIndex = exports.funcFirstIndex = exports.funcLast = exports.funcFirst = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const Unknown_js_1 = require("./Unknown.js");
+const typePredicate = Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [Type_js_1.Type.Unknown, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalArray]);
+const typeItemFinder = Type_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Array, typePredicate]);
+const typeIndexFinder = Type_js_1.Type.functionType(Type_js_1.Type.OptionalInteger, [Type_js_1.Type.Array, typePredicate]);
+const typeConditionSet = Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [Type_js_1.Type.Array, typePredicate]);
+const typeVariadicInsert = Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.Unknown], true);
+const typeArrayOperator = Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.Array]);
+exports.funcFirst = new Constant_js_1.Constant((value, predicate) => value?.find((v, i, a) => predicate(v, BigInt(i), a)), typeItemFinder);
+exports.funcLast = new Constant_js_1.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);
+exports.funcFirstIndex = new Constant_js_1.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);
+exports.funcLastIndex = new Constant_js_1.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);
+exports.funcEvery = new Constant_js_1.Constant((value, predicate) => value?.every((v, i, a) => predicate(v, BigInt(i), a)), typeConditionSet);
+exports.funcAny = new Constant_js_1.Constant((value, predicate) => value?.some((v, i, a) => predicate(v, BigInt(i), a)), typeConditionSet);
+exports.funcFlatten = new Constant_js_1.Constant((values, depth = 1n) => values?.flat(Number(depth)), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.OptionalInteger]));
+exports.funcReverse = new Constant_js_1.Constant((value) => [...value].reverse(), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array]));
+exports.funcMutate = new Constant_js_1.Constant((value, transform) => value?.map((v, i, a) => transform(v, BigInt(i), a)), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Unknown, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalArray])]));
+exports.funcFilter = new Constant_js_1.Constant((value, predicate) => value?.filter((v, i, a) => predicate(v, BigInt(i), a)), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, typePredicate]));
+exports.funcReduce = new Constant_js_1.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_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Array, Type_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Unknown, Type_js_1.Type.Unknown, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalArray])]));
+exports.funcCompose = new Constant_js_1.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_js_1.Type.functionType(Type_js_1.Type.Object, [Type_js_1.Type.Array, Type_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Object, Type_js_1.Type.String, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalArray])]));
+exports.funcPrepend = new Constant_js_1.Constant((value, ...items) => {
+    value.unshift(items);
+    return value;
+}, typeVariadicInsert);
+exports.funcAppend = new Constant_js_1.Constant((value, ...items) => {
+    value.push(items);
+    return value;
+}, typeVariadicInsert);
+const funcJoin = new Constant_js_1.Constant((...values) => values.flat(Infinity).reduce((acc, val) => [...acc, val], []), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array], true));
+const funcRange = new Constant_js_1.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_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Integer, Type_js_1.Type.Integer]));
+const funcUnique = new Constant_js_1.Constant((value) => {
+    const result = [];
+    value.forEach((i) => {
+        if (result.every((v) => !(0, Unknown_js_1.equate)(v, i))) {
+            result.push(i);
+        }
+    });
+    return result;
+}, Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array]));
+const funcIntersection = new Constant_js_1.Constant((value1, value2) => value1.filter((i) => value2.some((v) => (0, Unknown_js_1.equate)(v, i))), typeArrayOperator);
+const funcDifference = new Constant_js_1.Constant((value1, value2) => [...value1.filter((i) => value2.every((v) => !(0, Unknown_js_1.equate)(v, i))), ...value2.filter((i) => value1.every((v) => !(0, Unknown_js_1.equate)(v, i)))], typeArrayOperator);
+exports.constArray = {
+    Join: funcJoin,
+    Range: funcRange,
+    Unique: funcUnique,
+    Intersection: funcIntersection,
+    Difference: funcDifference,
+};

package/dst/cjs/constant/Boolean.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constBoolean = exports.funcNot = exports.funcAnd = exports.funcOr = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const typeBooleanOrArray = Type_js_1.Type.union(Type_js_1.Type.Boolean, Type_js_1.Type.arrayType([Type_js_1.Type.Boolean]));
+const typeBooleanLogic = Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [typeBooleanOrArray], true);
+exports.funcOr = new Constant_js_1.Constant((...values) => values.flat().some((v) => v), typeBooleanLogic);
+exports.funcAnd = new Constant_js_1.Constant((...values) => values.flat().every((v) => v), typeBooleanLogic);
+exports.funcNot = new Constant_js_1.Constant((value) => !value, Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [Type_js_1.Type.Boolean]));
+const funcDecodeBoolean = new Constant_js_1.Constant((value, byteOffset) => Boolean(new Uint8Array(value)[byteOffset == null ? 0 : Number(byteOffset)]), Type_js_1.Type.functionType(Type_js_1.Type.OptionalBoolean, [Type_js_1.Type.Buffer, Type_js_1.Type.OptionalInteger]));
+const funcParseBoolean = new Constant_js_1.Constant((value) => {
+    if (value == null) {
+        return undefined;
+    }
+    const v = value.toLowerCase();
+    return v === 'true' ? true : v === 'false' ? false : undefined;
+}, Type_js_1.Type.functionType(Type_js_1.Type.OptionalBoolean, [Type_js_1.Type.String]));
+exports.constBoolean = {
+    Or: exports.funcOr,
+    And: exports.funcAnd,
+    Not: exports.funcNot,
+    Decode: funcDecodeBoolean,
+    Parse: funcParseBoolean,
+};

package/dst/cjs/constant/Buffer.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constBuffer = exports.funcByte = exports.parseBuffer = exports.formatBuffer = exports.concatBuffers = exports.equateBuffers = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const equateBuffers = (value1, value2) => {
+    if (value1.byteLength !== value2.byteLength) {
+        return false;
+    }
+    const dv1 = new DataView(value1);
+    const dv2 = new DataView(value2);
+    const length = dv1.byteLength;
+    for (let lfi = length - 3, i = 0; i < length;) {
+        if (i < lfi) {
+            if (dv1.getUint32(i) !== dv2.getUint32(i)) {
+                return false;
+            }
+            i += 4;
+        }
+        else {
+            if (dv1.getUint8(i) !== dv2.getUint8(i)) {
+                return false;
+            }
+            ++i;
+        }
+    }
+    return true;
+};
+exports.equateBuffers = equateBuffers;
+const concatBuffers = (value1, value2) => {
+    const bytes = new Uint8Array(value1.byteLength + value2.byteLength);
+    bytes.set(new Uint8Array(value1), 0);
+    bytes.set(new Uint8Array(value2), value1.byteLength);
+    return bytes.buffer;
+};
+exports.concatBuffers = concatBuffers;
+const formatBuffer = (value) => {
+    if (value == null) {
+        return '';
+    }
+    const bytes = new Uint8Array(value);
+    let str = '';
+    for (let i = 0; i < bytes.byteLength; ++i) {
+        str += bytes[i].toString(16).padStart(2, '0');
+    }
+    return str;
+};
+exports.formatBuffer = formatBuffer;
+const parseBuffer = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    const bytes = new Uint8Array(Math.ceil(value.length / 2));
+    for (let i = 0, c = 0; c < value.length; ++i) {
+        bytes[i] = Number.parseInt(value.slice(c, c += 2), 16);
+    }
+    return bytes.buffer;
+};
+exports.parseBuffer = parseBuffer;
+exports.funcByte = new Constant_js_1.Constant((value, pos) => value == null
+    ? undefined
+    : value.slice(Number(pos), Number(pos) + 1), Type_js_1.Type.functionType(Type_js_1.Type.OptionalBuffer, [Type_js_1.Type.Buffer, Type_js_1.Type.Integer]));
+const funcRandomBuffer = new Constant_js_1.Constant((value) => value == null || value < 0 ? undefined : crypto.getRandomValues(new Uint8Array(Number(value))), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Integer]), false);
+const funcParseBuffer = new Constant_js_1.Constant((value) => (0, exports.parseBuffer)(value), Type_js_1.Type.functionType(Type_js_1.Type.OptionalBuffer, [Type_js_1.Type.String]));
+exports.constBuffer = {
+    Random: funcRandomBuffer,
+    Parse: funcParseBuffer,
+};