affinirum 1.0.0

package/dst/cjs/constant/Enumerable.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.funcInject = exports.funcSplice = exports.funcSlice = exports.funcAdd = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const Buffer_js_1 = require("./Buffer.js");
+const aggregate = (value1, value2) => {
+    if (value1 instanceof ArrayBuffer && value2 instanceof ArrayBuffer) {
+        return (0, Buffer_js_1.concatBuffers)(value1, value2);
+    }
+    if (typeof value1 === 'string' && typeof value2 === 'string') {
+        return value1.concat(value2);
+    }
+    return [value1].flat().concat([value2].flat());
+};
+const add = (value1, value2) => {
+    if (typeof value1 === 'bigint' && typeof value2 === 'bigint') {
+        return BigInt.asIntN(64, value1 + value2);
+    }
+    if (typeof value1 === 'number' || typeof value2 === 'number') {
+        return Number(value1) + Number(value2);
+    }
+    return aggregate(value1, value2);
+};
+exports.funcAdd = new Constant_js_1.Constant((value1, value2) => add(value1, value2), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Float, Type_js_1.Type.Integer]), Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Integer, Type_js_1.Type.Float]), Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Integer, Type_js_1.Type.Integer]), Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Buffer, Type_js_1.Type.Buffer]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.String, Type_js_1.Type.String]), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.Array])));
+exports.funcSlice = new Constant_js_1.Constant((value, start = 0n, end) => value == null
+    ? undefined
+    : value.slice(Number(start), end == null ? undefined : Number(end)), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Buffer, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalInteger]), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.String, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalInteger]), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalInteger])));
+exports.funcSplice = new Constant_js_1.Constant((value, start, remove, ...inject) => value == null
+    ? undefined
+    : aggregate(inject.reduce((acc, val) => aggregate(acc, val), value.slice(0, Number(start))), value.slice(Number(start + remove))), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Buffer, Type_js_1.Type.Integer, Type_js_1.Type.Integer, Type_js_1.Type.Enumerable], true), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.String, Type_js_1.Type.Integer, Type_js_1.Type.Integer, Type_js_1.Type.Enumerable], true), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.Integer, Type_js_1.Type.Integer, Type_js_1.Type.Enumerable], true)));
+exports.funcInject = new Constant_js_1.Constant((value, start, ...inject) => value == null
+    ? undefined
+    : aggregate(inject.reduce((acc, val) => aggregate(acc, val), value.slice(0, Number(start))), value.slice(Number(start))), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Buffer, [Type_js_1.Type.Buffer, Type_js_1.Type.Integer, Type_js_1.Type.Enumerable], true), Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.String, Type_js_1.Type.Integer, Type_js_1.Type.Enumerable], true), Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Array, Type_js_1.Type.Integer, Type_js_1.Type.Enumerable], true)));

package/dst/cjs/constant/Float.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constFloat = exports.formatFloat = exports.encodeFloat = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const encodeFloat = (value, encoding = 'float64') => {
+    if (value == null) {
+        return new Uint8Array(0).buffer;
+    }
+    let bits = '';
+    for (let i = 0; i < encoding.length; ++i) {
+        const c = encoding[i];
+        if (c >= '0' && c <= '9') {
+            bits += c;
+        }
+    }
+    const dv = new DataView(new Uint8Array(Number.parseInt(bits) / 8).buffer);
+    switch (encoding) {
+        case 'float32':
+            dv.setFloat32(0, value);
+            break;
+        case 'float32le':
+            dv.setFloat32(0, value, true);
+            break;
+        case 'float64':
+            dv.setFloat64(0, value);
+            break;
+        case 'float64le':
+            dv.setFloat64(0, value, true);
+            break;
+        default: throw new Error(`${encoding} encoding not supported`);
+    }
+    return dv.buffer;
+};
+exports.encodeFloat = encodeFloat;
+const decodeFloat = (value, encoding = 'float64', byteOffset) => {
+    if (value == null) {
+        return undefined;
+    }
+    const dv = new DataView(value, byteOffset);
+    switch (encoding) {
+        case 'float32': return dv.getFloat32(0);
+        case 'float32le': return dv.getFloat32(0, true);
+        case 'float64': return dv.getFloat64(0);
+        case 'float64le': return dv.getFloat64(0, true);
+        default: throw new Error(`${encoding} encoding not supported`);
+    }
+};
+const formatFloat = (value, radix) => value.toString(radix) + (Number.isInteger(value) ? '.0' : '');
+exports.formatFloat = formatFloat;
+const typeNumberOrArray = Type_js_1.Type.union(Type_js_1.Type.Float, Type_js_1.Type.arrayType([Type_js_1.Type.Float]));
+const typeAggregator = Type_js_1.Type.functionType(Type_js_1.Type.Float, [typeNumberOrArray], true);
+const typeNumberTransform = Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Float]);
+const funcSum = new Constant_js_1.Constant((...values) => values.flat().reduce((acc, val) => acc + val, 0), typeAggregator);
+const funcMin = new Constant_js_1.Constant((...values) => Math.min(Number.POSITIVE_INFINITY, ...values.flat()), typeAggregator);
+const funcMax = new Constant_js_1.Constant((...values) => Math.max(Number.NEGATIVE_INFINITY, ...values.flat()), typeAggregator);
+const funcExponent = new Constant_js_1.Constant((value) => Math.exp(value), typeNumberTransform);
+const funcLogarithm = new Constant_js_1.Constant((value) => Math.log(value), typeNumberTransform);
+const funcAbs = new Constant_js_1.Constant((value) => Math.abs(value), typeNumberTransform);
+const funcCeil = new Constant_js_1.Constant((value) => Math.ceil(value), typeNumberTransform);
+const funcFloor = new Constant_js_1.Constant((value) => Math.floor(value), typeNumberTransform);
+const funcRound = new Constant_js_1.Constant((value) => Math.round(value), typeNumberTransform);
+const funcTruncate = new Constant_js_1.Constant((value) => Math.trunc(value), typeNumberTransform);
+const funcRandomFloat = new Constant_js_1.Constant((value) => value == null ? undefined : Math.random() * value, Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Float]), false);
+const funcDecodeFloat = new Constant_js_1.Constant((value, encoding = 'float64', byteOffset) => decodeFloat(value, encoding, byteOffset == null ? undefined : Number(byteOffset)), Type_js_1.Type.functionType(Type_js_1.Type.OptionalFloat, [Type_js_1.Type.Buffer, Type_js_1.Type.OptionalString, Type_js_1.Type.OptionalInteger]));
+const funcParseFloat = new Constant_js_1.Constant((value) => value ? Number.parseFloat(value) : undefined, Type_js_1.Type.functionType(Type_js_1.Type.OptionalFloat, [Type_js_1.Type.String]));
+exports.constFloat = {
+    NAN: new Constant_js_1.Constant(Number.NaN),
+    PositiveInfinity: new Constant_js_1.Constant(Number.POSITIVE_INFINITY),
+    NegativeInfinity: new Constant_js_1.Constant(Number.NEGATIVE_INFINITY),
+    Epsilon: new Constant_js_1.Constant(Number.EPSILON),
+    Sum: funcSum,
+    Min: funcMin,
+    Max: funcMax,
+    Exponent: funcExponent,
+    Logarithm: funcLogarithm,
+    Abs: funcAbs,
+    Ceil: funcCeil,
+    Floor: funcFloor,
+    Round: funcRound,
+    Truncate: funcTruncate,
+    Random: funcRandomFloat,
+    Decode: funcDecodeFloat,
+    Parse: funcParseFloat,
+};

package/dst/cjs/constant/Integer.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constInteger = exports.encodeInteger = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const encodeInteger = (value, encoding = 'int64') => {
+    if (value == null) {
+        return new Uint8Array(0).buffer;
+    }
+    let bits = '';
+    for (let i = 0; i < encoding.length; ++i) {
+        const c = encoding[i];
+        if (c >= '0' && c <= '9') {
+            bits += c;
+        }
+    }
+    const dv = new DataView(new Uint8Array(Number.parseInt(bits) / 8).buffer);
+    switch (encoding) {
+        case 'int8':
+            dv.setInt8(0, Number(value));
+            break;
+        case 'int16':
+            dv.setInt16(0, Number(value));
+            break;
+        case 'int16le':
+            dv.setInt16(0, Number(value), true);
+            break;
+        case 'int32':
+            dv.setInt32(0, Number(value));
+            break;
+        case 'int32le':
+            dv.setInt32(0, Number(value), true);
+            break;
+        case 'uint8':
+            dv.setUint8(0, Number(value));
+            break;
+        case 'uint16':
+            dv.setUint16(0, Number(value));
+            break;
+        case 'uint16le':
+            dv.setUint16(0, Number(value), true);
+            break;
+        case 'uint32':
+            dv.setUint32(0, Number(value));
+            break;
+        case 'uint32le':
+            dv.setUint32(0, Number(value), true);
+            break;
+        case 'int64':
+            dv.setBigInt64(0, value);
+            break;
+        case 'int64le':
+            dv.setBigInt64(0, value, true);
+            break;
+        case 'uint64':
+            dv.setBigUint64(0, value);
+            break;
+        case 'uint64le':
+            dv.setBigUint64(0, value, true);
+            break;
+        default: throw new Error(`${encoding} encoding not supported`);
+    }
+    return dv.buffer;
+};
+exports.encodeInteger = encodeInteger;
+const decodeInteger = (value, encoding = 'int64', byteOffset) => {
+    if (value == null) {
+        return undefined;
+    }
+    const dv = new DataView(value, byteOffset == null ? undefined : Number(byteOffset));
+    switch (encoding) {
+        case 'int8': return BigInt(dv.getInt8(0));
+        case 'int16': return BigInt(dv.getInt16(0));
+        case 'int16le': return BigInt(dv.getInt16(0, true));
+        case 'int32': return BigInt(dv.getInt32(0));
+        case 'int32le': return BigInt(dv.getInt32(0, true));
+        case 'int64': return dv.getBigInt64(0);
+        case 'int64le': return dv.getBigInt64(0, true);
+        case 'uint8': return BigInt(dv.getUint8(0));
+        case 'uint16': return BigInt(dv.getUint16(0));
+        case 'uint16le': return BigInt(dv.getUint16(0, true));
+        case 'uint32': return BigInt(dv.getUint32(0));
+        case 'uint32le': return BigInt(dv.getUint32(0, true));
+        case 'uint64': return dv.getBigUint64(0);
+        case 'uint64le': return dv.getBigUint64(0, true);
+        default: throw new Error(`${encoding} encoding not supported`);
+    }
+};
+const typeIntegerOrArray = Type_js_1.Type.union(Type_js_1.Type.Integer, Type_js_1.Type.arrayType([Type_js_1.Type.Integer]));
+const typeAggregator = Type_js_1.Type.functionType(Type_js_1.Type.Integer, [typeIntegerOrArray], true);
+const funcSum = new Constant_js_1.Constant((...values) => BigInt.asIntN(64, values.flat().reduce((acc, val) => acc + val, 0n)), typeAggregator);
+const funcMin = new Constant_js_1.Constant((...values) => BigInt.asIntN(64, values.flat().reduce((min, val) => val < min ? val : min)), typeAggregator);
+const funcMax = new Constant_js_1.Constant((...values) => BigInt.asIntN(64, values.flat().reduce((max, val) => val > max ? val : max)), typeAggregator);
+const funcRandomInteger = new Constant_js_1.Constant((value) => value == null ? undefined : BigInt.asIntN(64, BigInt(Math.floor(Math.random() * Number(value)))), Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Integer]), false);
+const funcDecodeInteger = new Constant_js_1.Constant((value, encoding = 'int64', byteOffset) => decodeInteger(value, encoding, byteOffset == null ? undefined : Number(byteOffset)), Type_js_1.Type.functionType(Type_js_1.Type.OptionalInteger, [Type_js_1.Type.Buffer, Type_js_1.Type.OptionalString, Type_js_1.Type.OptionalInteger]));
+const funcParseInteger = new Constant_js_1.Constant((value) => value ? BigInt.asIntN(64, BigInt(value)) : undefined, Type_js_1.Type.functionType(Type_js_1.Type.OptionalInteger, [Type_js_1.Type.String]));
+exports.constInteger = {
+    Sum: funcSum,
+    Min: funcMin,
+    Max: funcMax,
+    Random: funcRandomInteger,
+    Decode: funcDecodeInteger,
+    Parse: funcParseInteger,
+};

package/dst/cjs/constant/Iterable.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.funcAt = exports.funcLength = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+exports.funcLength = new Constant_js_1.Constant((value) => BigInt.asIntN(64, BigInt(value == null
+    ? 0
+    : value instanceof ArrayBuffer
+        ? value.byteLength
+        : typeof value === 'string' || Array.isArray(value)
+            ? value.length
+            : Object.keys(value).length)), Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Iterable]));
+exports.funcAt = new Constant_js_1.Constant((value, index) => {
+    if (value == null) {
+        return undefined;
+    }
+    else if (Array.isArray(value)) {
+        const ix = Number(index);
+        return value[ix < 0 ? value.length + ix : ix];
+    }
+    else {
+        return value[String(index)];
+    }
+}, Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Array, Type_js_1.Type.Integer]), Type_js_1.Type.functionType(Type_js_1.Type.Unknown, [Type_js_1.Type.Object, Type_js_1.Type.String])));

package/dst/cjs/constant/Number.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.funcCast = exports.funcNegate = exports.funcRoot = exports.funcPower = exports.funcModulo = exports.funcRemainder = exports.funcDivide = exports.funcMultiply = exports.funcSubtract = exports.funcLessOrEqual = exports.funcGreaterOrEqual = exports.funcLessThan = exports.funcGreaterThan = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const typeComparator = Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [Type_js_1.Type.Number, Type_js_1.Type.Number]);
+const typeOperator = Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Float, Type_js_1.Type.Integer]), Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Integer, Type_js_1.Type.Float]), Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Integer, Type_js_1.Type.Integer]));
+exports.funcGreaterThan = new Constant_js_1.Constant((value1, value2) => value1 > value2, typeComparator);
+exports.funcLessThan = new Constant_js_1.Constant((value1, value2) => value1 < value2, typeComparator);
+exports.funcGreaterOrEqual = new Constant_js_1.Constant((value1, value2) => value1 >= value2, typeComparator);
+exports.funcLessOrEqual = new Constant_js_1.Constant((value1, value2) => value1 <= value2, typeComparator);
+exports.funcSubtract = new Constant_js_1.Constant((value, subtrahend) => typeof value === 'bigint' && typeof subtrahend === 'bigint'
+    ? BigInt.asIntN(64, value - subtrahend)
+    : Number(value) - Number(subtrahend), typeOperator);
+exports.funcMultiply = new Constant_js_1.Constant((value1, value2) => typeof value1 === 'bigint' && typeof value2 === 'bigint'
+    ? BigInt.asIntN(64, value1 * value2)
+    : Number(value1) * Number(value2), typeOperator);
+exports.funcDivide = new Constant_js_1.Constant((value, divisor) => typeof value === 'bigint' && typeof divisor === 'bigint'
+    ? BigInt.asIntN(64, value / divisor)
+    : Number(value) / Number(divisor), typeOperator);
+exports.funcRemainder = new Constant_js_1.Constant((value, divisor) => typeof value === 'bigint' && typeof divisor === 'bigint'
+    ? BigInt.asIntN(64, value % divisor)
+    : Number(value) % Number(divisor), typeOperator);
+exports.funcModulo = new Constant_js_1.Constant((value, divisor) => typeof value === 'bigint' && typeof divisor === 'bigint'
+    ? BigInt.asIntN(64, (value % divisor + divisor) % divisor)
+    : (Number(value) % Number(divisor) + Number(divisor)) % Number(divisor), typeOperator);
+exports.funcPower = new Constant_js_1.Constant((value, exponent) => typeof value === 'bigint' && typeof exponent === 'bigint'
+    ? BigInt.asIntN(64, value ** BigInt(exponent))
+    : Number(value) ** Number(exponent), typeOperator);
+exports.funcRoot = new Constant_js_1.Constant((value, exponent) => {
+    if (typeof value === 'bigint' && typeof exponent === 'bigint') {
+        const e = BigInt(exponent);
+        if (value < 0n && e % 2n === 0n) {
+            return undefined;
+        }
+        if (value < 2n || e === 1n) {
+            return value;
+        }
+        let low = 0n, high = value, result = 0n;
+        while (low <= high) {
+            const mid = low + high >> 1n;
+            const midPow = mid ** e;
+            if (midPow === value) {
+                return mid;
+            }
+            else if (midPow < value) {
+                result = mid;
+                low = mid + 1n;
+            }
+            else {
+                high = mid - 1n;
+            }
+        }
+        return BigInt.asIntN(64, result);
+    }
+    return Math.pow(Number(value), 1 / Number(exponent));
+}, typeOperator);
+exports.funcNegate = new Constant_js_1.Constant((value) => typeof value === 'number' ? -value : BigInt.asIntN(64, -value), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Float]), Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Integer])));
+exports.funcCast = new Constant_js_1.Constant((value) => typeof value === 'number' ? BigInt.asIntN(64, BigInt(Math.trunc(value))) : Number(value), Type_js_1.Type.union(Type_js_1.Type.functionType(Type_js_1.Type.Float, [Type_js_1.Type.Integer]), Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Float])));

package/dst/cjs/constant/Object.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constObject = exports.funcValues = exports.funcKeys = exports.funcEntries = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const typeAccessor = Type_js_1.Type.functionType(Type_js_1.Type.Array, [Type_js_1.Type.Object]);
+exports.funcEntries = new Constant_js_1.Constant((value) => Object.entries(value), typeAccessor);
+exports.funcKeys = new Constant_js_1.Constant((value) => Object.keys(value), Type_js_1.Type.functionType(Type_js_1.Type.arrayType([Type_js_1.Type.String]), [Type_js_1.Type.Object]));
+exports.funcValues = new Constant_js_1.Constant((value) => Object.values(value), typeAccessor);
+const funcMerge = new Constant_js_1.Constant((...values) => values.flat().reduce((acc, val) => Object.assign(acc, val), {}), Type_js_1.Type.functionType(Type_js_1.Type.Object, [Type_js_1.Type.union(Type_js_1.Type.arrayType([Type_js_1.Type.Object]), Type_js_1.Type.Object)], true));
+exports.constObject = {
+    Merge: funcMerge,
+};

package/dst/cjs/constant/String.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constString = exports.funcSplit = exports.funcUpperCase = exports.funcLowerCase = exports.funcTrimEnd = exports.funcTrimStart = exports.funcTrim = exports.funcCharCode = exports.funcChar = exports.funcEndsWith = exports.funcStartsWith = exports.funcContains = exports.funcUnlike = exports.funcLike = exports.encodeString = exports.endsWithString = exports.startsWithString = exports.containsString = exports.equateStrings = exports.isCaseSpaceEtc = exports.isQuotation = exports.isHexadecimal = exports.isDateTimeSeparator = exports.isTimeSymbol = exports.isDateSymbol = exports.isAlphanumeric = exports.isNumeric = exports.isAlpha = exports.isSign = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const isSign = (c) => c === '+' || c === '-';
+exports.isSign = isSign;
+const isAlpha = (c) => c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c === '_';
+exports.isAlpha = isAlpha;
+const isNumeric = (c) => c >= '0' && c <= '9';
+exports.isNumeric = isNumeric;
+const isAlphanumeric = (c) => (0, exports.isAlpha)(c) || (0, exports.isNumeric)(c);
+exports.isAlphanumeric = isAlphanumeric;
+const isDateSymbol = (c) => (0, exports.isNumeric)(c) || c === '-';
+exports.isDateSymbol = isDateSymbol;
+const isTimeSymbol = (c) => (0, exports.isNumeric)(c) || c === ':';
+exports.isTimeSymbol = isTimeSymbol;
+const isDateTimeSeparator = (c) => c === 'T' || c === ' ' || c === '@';
+exports.isDateTimeSeparator = isDateTimeSeparator;
+const isHexadecimal = (c) => (0, exports.isNumeric)(c) || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
+exports.isHexadecimal = isHexadecimal;
+const isQuotation = (c) => c === '\'' || c === '"' || c === '`';
+exports.isQuotation = isQuotation;
+const isCaseSpaceEtc = (c) => (c < 'a' || c > 'z') && (c < '0' || c > '9');
+exports.isCaseSpaceEtc = isCaseSpaceEtc;
+const equateStrings = (value1, value2, ignoreCaseSpaceEtc) => {
+    if (!ignoreCaseSpaceEtc) {
+        return value1 === value2;
+    }
+    const str1 = value1.toLowerCase();
+    const str2 = value2.toLowerCase();
+    for (let i1 = 0, i2 = 0; i1 < str1.length && i2 < str2.length; ++i1, ++i2) {
+        while ((0, exports.isCaseSpaceEtc)(str1[i1]) && i1 < str1.length) {
+            ++i1;
+        }
+        while ((0, exports.isCaseSpaceEtc)(str2[i2]) && i2 < str2.length) {
+            ++i2;
+        }
+        if (str1[i1] != str2[i2]) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.equateStrings = equateStrings;
+const containsString = (value, search, startPos, ignoreCaseSpaceEtc) => {
+    if (!ignoreCaseSpaceEtc) {
+        return value.includes(search, startPos);
+    }
+    const valueStr = value.toLowerCase();
+    const searchStr = search.toLowerCase();
+    if (valueStr.length < searchStr.length) {
+        return false;
+    }
+    const pos = startPos == null ? 0 : startPos < 0 ? value.length + startPos : startPos;
+    for (let i1 = pos, i2 = 0; i1 < valueStr.length && i2 < searchStr.length; ++i1, ++i2) {
+        while ((0, exports.isCaseSpaceEtc)(valueStr[i1]) && i1 < valueStr.length) {
+            ++i1;
+        }
+        while ((0, exports.isCaseSpaceEtc)(searchStr[i2]) && i2 < searchStr.length) {
+            ++i2;
+        }
+        while (valueStr[i1] != searchStr[i2] && i1 < valueStr.length) {
+            ++i1;
+        }
+        if (valueStr[i1] != searchStr[i2] && i2 < searchStr.length) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.containsString = containsString;
+const startsWithString = (value, search, startPos, ignoreCaseSpaceEtc) => {
+    if (!ignoreCaseSpaceEtc) {
+        return value.startsWith(search, startPos);
+    }
+    const valueStr = value.toLowerCase();
+    const searchStr = search.toLowerCase();
+    if (valueStr.length < searchStr.length) {
+        return false;
+    }
+    const pos = startPos == null ? 0 : startPos < 0 ? value.length + startPos : startPos;
+    for (let i1 = pos, i2 = 0; i1 < valueStr.length && i2 < searchStr.length; ++i1, ++i2) {
+        while ((0, exports.isCaseSpaceEtc)(valueStr[i1]) && i1 < valueStr.length) {
+            ++i1;
+        }
+        while ((0, exports.isCaseSpaceEtc)(searchStr[i2]) && i2 < searchStr.length) {
+            ++i2;
+        }
+        if (valueStr[i1] != searchStr[i2] && i2 < searchStr.length) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.startsWithString = startsWithString;
+const endsWithString = (value, search, endPos, ignoreCaseSpaceEtc) => {
+    if (!ignoreCaseSpaceEtc) {
+        return value.endsWith(search, endPos);
+    }
+    const valueStr = value.toLowerCase();
+    const searchStr = search.toLowerCase();
+    if (valueStr.length < searchStr.length) {
+        return false;
+    }
+    const pos = endPos == null ? valueStr.length : endPos < 0 ? value.length + endPos : endPos;
+    for (let i1 = pos - 1, i2 = searchStr.length - 1; i1 > -1 && i2 > -1; --i1, --i2) {
+        while ((0, exports.isCaseSpaceEtc)(valueStr[i1]) && i1 > -1) {
+            --i1;
+        }
+        while ((0, exports.isCaseSpaceEtc)(searchStr[i2]) && i2 > -1) {
+            --i2;
+        }
+        if (valueStr[i1] != searchStr[i2] && i2 > -1) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.endsWithString = endsWithString;
+const encodeString = (value, encoding = 'utf8') => {
+    if (value == null) {
+        return new Uint8Array(0).buffer;
+    }
+    if (encoding === 'utf8') {
+        return new TextEncoder().encode(value).buffer;
+    }
+    else {
+        const dv = new DataView(new Uint16Array(value.length).buffer);
+        const lessOrEqual = encoding.endsWith('le');
+        for (let i = 0; i < value.length; ++i) {
+            dv.setUint16(i << 1, value.charCodeAt(i), lessOrEqual);
+        }
+        return dv.buffer;
+    }
+};
+exports.encodeString = encodeString;
+const decodeString = (value, encoding = 'utf8', byteOffset, byteLength) => {
+    if (value == null) {
+        return undefined;
+    }
+    if (encoding === 'utf8') {
+        return new TextDecoder().decode(new DataView(value, byteOffset, byteLength));
+    }
+    else {
+        const dv = new DataView(value, byteOffset, byteLength);
+        const lessOrEqual = encoding.endsWith('le');
+        let str = '';
+        for (let i = 0; i < dv.byteLength; i += 2) {
+            str += String.fromCharCode(dv.getUint16(i, lessOrEqual));
+        }
+        return str;
+    }
+};
+const typeStringEquator = Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [Type_js_1.Type.String, Type_js_1.Type.String]);
+const typeStringComparator = Type_js_1.Type.functionType(Type_js_1.Type.Boolean, [Type_js_1.Type.String, Type_js_1.Type.String, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalBoolean]);
+const typeStringMutator = Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.String]);
+exports.funcLike = new Constant_js_1.Constant((value1, value2) => (0, exports.equateStrings)(value1, value2, true), typeStringEquator);
+exports.funcUnlike = new Constant_js_1.Constant((value1, value2) => !(0, exports.equateStrings)(value1, value2, true), typeStringEquator);
+exports.funcContains = new Constant_js_1.Constant((value, search, start, ignoreCaseSpaceEtc) => (0, exports.containsString)(value, search, start == null ? undefined : Number(start), ignoreCaseSpaceEtc), typeStringComparator);
+exports.funcStartsWith = new Constant_js_1.Constant((value, search, start, ignoreCaseSpaceEtc) => (0, exports.startsWithString)(value, search, start == null ? undefined : Number(start), ignoreCaseSpaceEtc), typeStringComparator);
+exports.funcEndsWith = new Constant_js_1.Constant((value, search, end, ignoreCaseSpaceEtc) => (0, exports.endsWithString)(value, search, end == null ? undefined : Number(end), ignoreCaseSpaceEtc), typeStringComparator);
+exports.funcChar = new Constant_js_1.Constant((value, pos) => value == null
+    ? undefined
+    : value.charAt(pos < 0 ? value.length + Number(pos) : Number(pos)), Type_js_1.Type.functionType(Type_js_1.Type.OptionalString, [Type_js_1.Type.String, Type_js_1.Type.Integer]));
+exports.funcCharCode = new Constant_js_1.Constant((value, pos) => value == null
+    ? undefined
+    : value.charCodeAt(pos < 0 ? value.length + Number(pos) : Number(pos)), Type_js_1.Type.functionType(Type_js_1.Type.OptionalInteger, [Type_js_1.Type.String, Type_js_1.Type.Float]));
+exports.funcTrim = new Constant_js_1.Constant((value) => value.trim(), typeStringMutator);
+exports.funcTrimStart = new Constant_js_1.Constant((value) => value.trimStart(), typeStringMutator);
+exports.funcTrimEnd = new Constant_js_1.Constant((value) => value.trimEnd(), typeStringMutator);
+exports.funcLowerCase = new Constant_js_1.Constant((value) => value.toLowerCase(), typeStringMutator);
+exports.funcUpperCase = new Constant_js_1.Constant((value) => value.toUpperCase(), typeStringMutator);
+exports.funcSplit = new Constant_js_1.Constant((value, separator = ' ') => value.split(separator), Type_js_1.Type.functionType(Type_js_1.Type.arrayType([Type_js_1.Type.String]), [Type_js_1.Type.String, Type_js_1.Type.OptionalString]));
+const funcAlphanum = new Constant_js_1.Constant((value) => {
+    const lowerCase = value.toLowerCase();
+    let result = '';
+    for (let i = 0; i < lowerCase.length; ++i) {
+        if (!(0, exports.isCaseSpaceEtc)(value[i])) {
+            result += value[i];
+        }
+    }
+    return result;
+}, typeStringMutator);
+const funcRandomString = new Constant_js_1.Constant((value) => {
+    let str = '';
+    while (str.length < value) {
+        str += Math.random().toString(36).slice(2);
+    }
+    return str.slice(0, Number(value));
+}, Type_js_1.Type.functionType(Type_js_1.Type.String, [Type_js_1.Type.Integer]), false);
+const funcDecodeString = new Constant_js_1.Constant((value, encoding = 'utf8', byteOffset, byteLength) => decodeString(value, encoding, byteOffset == null ? undefined : Number(byteOffset), byteLength == null ? undefined : Number(byteLength)), Type_js_1.Type.functionType(Type_js_1.Type.OptionalString, [Type_js_1.Type.Buffer, Type_js_1.Type.OptionalString, Type_js_1.Type.OptionalInteger, Type_js_1.Type.OptionalInteger]));
+exports.constString = {
+    Alphanum: funcAlphanum,
+    Random: funcRandomString,
+    Decode: funcDecodeString,
+};

package/dst/cjs/constant/Timestamp.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constTimestamp = exports.funcEpochTime = exports.funcMillisecond = exports.funcSecond = exports.funcMinute = exports.funcHour = exports.funcDay = exports.funcWeekdayIndex = exports.funcMonthIndex = exports.funcMonth = exports.funcYear = exports.formatTimestamp = exports.decodeTimestamp = exports.encodeTimestamp = void 0;
+const Constant_js_1 = require("../Constant.js");
+const Type_js_1 = require("../Type.js");
+const typeTimestampPart = Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Timestamp, Type_js_1.Type.OptionalBoolean]);
+const encodeTimestamp = (value, encoding = 'int64') => {
+    const buf = new ArrayBuffer(8);
+    const dv = new DataView(buf);
+    dv.setBigInt64(0, BigInt(value.getTime()), encoding === 'int64le');
+    return buf;
+};
+exports.encodeTimestamp = encodeTimestamp;
+const decodeTimestamp = (value, encoding = 'int64', byteOffset) => new Date(Number(new DataView(value).getBigInt64(byteOffset == null ? 0 : Number(byteOffset), encoding === 'int64le')));
+exports.decodeTimestamp = decodeTimestamp;
+const formatTimestamp = (value, radix) => {
+    const str = value.toISOString();
+    switch (radix) {
+        case 1: return str.slice(0, 4);
+        case 2: return str.slice(5, 7);
+        case 3: return str.slice(8, 10);
+        case 4: return str.slice(11, 13);
+        case 5: return str.slice(14, 16);
+        case 6: return str.slice(17, 19);
+        case 7: return str.slice(20, 23);
+        default: return str;
+    }
+};
+exports.formatTimestamp = formatTimestamp;
+const parseTimestamp = (value) => {
+    if (value == null) {
+        return undefined;
+    }
+    const date = new Date(value);
+    return isNaN(date.getTime()) ? undefined : date;
+};
+const funcNow = new Constant_js_1.Constant(() => new Date(), Type_js_1.Type.functionType(Type_js_1.Type.Timestamp, []), false);
+exports.funcYear = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCFullYear() : value.getFullYear()), typeTimestampPart);
+exports.funcMonth = new Constant_js_1.Constant((value, utc = false) => BigInt(1 + (utc ? value.getUTCMonth() : value.getMonth())), typeTimestampPart);
+exports.funcMonthIndex = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCMonth() : value.getMonth()), typeTimestampPart);
+exports.funcWeekdayIndex = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCDay() : value.getDay()), typeTimestampPart);
+exports.funcDay = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCDate() : value.getDate()), typeTimestampPart);
+exports.funcHour = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCHours() : value.getHours()), typeTimestampPart);
+exports.funcMinute = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCMinutes() : value.getMinutes()), typeTimestampPart);
+exports.funcSecond = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCSeconds() : value.getSeconds()), typeTimestampPart);
+exports.funcMillisecond = new Constant_js_1.Constant((value, utc = false) => BigInt(utc ? value.getUTCMilliseconds() : value.getMilliseconds()), typeTimestampPart);
+exports.funcEpochTime = new Constant_js_1.Constant((value, epoch = new Date(0)) => BigInt.asIntN(64, BigInt(value.getTime() - epoch.getTime())), Type_js_1.Type.functionType(Type_js_1.Type.Integer, [Type_js_1.Type.Timestamp, Type_js_1.Type.OptionalTimestamp]));
+const funcEpochTimestamp = new Constant_js_1.Constant((value, epoch = new Date(0)) => new Date(Number(value) + epoch.getTime()), Type_js_1.Type.functionType(Type_js_1.Type.Timestamp, [Type_js_1.Type.Number, Type_js_1.Type.OptionalTimestamp]));
+const funcDecodeTimestamp = new Constant_js_1.Constant((value, encoding = 'int64', byteOffset) => (0, exports.decodeTimestamp)(value, encoding, byteOffset), Type_js_1.Type.functionType(Type_js_1.Type.OptionalTimestamp, [Type_js_1.Type.Buffer, Type_js_1.Type.OptionalString, Type_js_1.Type.OptionalInteger]));
+const funcParseTimestamp = new Constant_js_1.Constant((value) => parseTimestamp(value), Type_js_1.Type.functionType(Type_js_1.Type.OptionalTimestamp, [Type_js_1.Type.String]));
+exports.constTimestamp = {
+    Now: funcNow,
+    Epoch: funcEpochTimestamp,
+    Decode: funcDecodeTimestamp,
+    Parse: funcParseTimestamp,
+};