affinirum 1.0.0

package/dst/constant/Buffer.d.ts

@@ -0,0 +1,10 @@
+import { Constant } from '../Constant.js';
+export declare const equateBuffers: (value1: ArrayBuffer, value2: ArrayBuffer) => boolean;
+export declare const concatBuffers: (value1: ArrayBuffer, value2: ArrayBuffer) => ArrayBuffer;
+export declare const formatBuffer: (value?: ArrayBuffer) => string;
+export declare const parseBuffer: (value?: string) => ArrayBuffer | undefined;
+export declare const funcByte: Constant;
+export declare const constBuffer: {
+    Random: Constant;
+    Parse: Constant;
+};

package/dst/constant/Buffer.js

@@ -0,0 +1,61 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+export 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;
+};
+export 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;
+};
+export 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;
+};
+export 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;
+};
+export const funcByte = new Constant((value, pos) => value == null
+    ? undefined
+    : value.slice(Number(pos), Number(pos) + 1), Type.functionType(Type.OptionalBuffer, [Type.Buffer, Type.Integer]));
+const funcRandomBuffer = new Constant((value) => value == null || value < 0 ? undefined : crypto.getRandomValues(new Uint8Array(Number(value))), Type.functionType(Type.Buffer, [Type.Integer]), false);
+const funcParseBuffer = new Constant((value) => parseBuffer(value), Type.functionType(Type.OptionalBuffer, [Type.String]));
+export const constBuffer = {
+    Random: funcRandomBuffer,
+    Parse: funcParseBuffer,
+};

package/dst/constant/Enumerable.d.ts

@@ -0,0 +1,5 @@
+import { Constant } from '../Constant.js';
+export declare const funcAdd: Constant;
+export declare const funcSlice: Constant;
+export declare const funcSplice: Constant;
+export declare const funcInject: Constant;

package/dst/constant/Enumerable.js

@@ -0,0 +1,31 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+import { concatBuffers } from './Buffer.js';
+const aggregate = (value1, value2) => {
+    if (value1 instanceof ArrayBuffer && value2 instanceof ArrayBuffer) {
+        return 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);
+};
+export const funcAdd = new Constant((value1, value2) => add(value1, value2), Type.union(Type.functionType(Type.Float, [Type.Float, Type.Integer]), Type.functionType(Type.Float, [Type.Integer, Type.Float]), Type.functionType(Type.Integer, [Type.Integer, Type.Integer]), Type.functionType(Type.Buffer, [Type.Buffer, Type.Buffer]), Type.functionType(Type.String, [Type.String, Type.String]), Type.functionType(Type.Array, [Type.Array, Type.Array])));
+export const funcSlice = new Constant((value, start = 0n, end) => value == null
+    ? undefined
+    : value.slice(Number(start), end == null ? undefined : Number(end)), Type.union(Type.functionType(Type.Buffer, [Type.Buffer, Type.OptionalInteger, Type.OptionalInteger]), Type.functionType(Type.String, [Type.String, Type.OptionalInteger, Type.OptionalInteger]), Type.functionType(Type.Array, [Type.Array, Type.OptionalInteger, Type.OptionalInteger])));
+export const funcSplice = new 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.union(Type.functionType(Type.Buffer, [Type.Buffer, Type.Integer, Type.Integer, Type.Enumerable], true), Type.functionType(Type.String, [Type.String, Type.Integer, Type.Integer, Type.Enumerable], true), Type.functionType(Type.Array, [Type.Array, Type.Integer, Type.Integer, Type.Enumerable], true)));
+export const funcInject = new 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.union(Type.functionType(Type.Buffer, [Type.Buffer, Type.Integer, Type.Enumerable], true), Type.functionType(Type.String, [Type.String, Type.Integer, Type.Enumerable], true), Type.functionType(Type.Array, [Type.Array, Type.Integer, Type.Enumerable], true)));

package/dst/constant/Float.d.ts

@@ -0,0 +1,22 @@
+import { Constant } from '../Constant.js';
+export declare const encodeFloat: (value: number, encoding?: "float32" | "float32le" | "float64" | "float64le") => ArrayBuffer;
+export declare const formatFloat: (value: number, radix?: number) => string;
+export declare const constFloat: {
+    NAN: Constant;
+    PositiveInfinity: Constant;
+    NegativeInfinity: Constant;
+    Epsilon: Constant;
+    Sum: Constant;
+    Min: Constant;
+    Max: Constant;
+    Exponent: Constant;
+    Logarithm: Constant;
+    Abs: Constant;
+    Ceil: Constant;
+    Floor: Constant;
+    Round: Constant;
+    Truncate: Constant;
+    Random: Constant;
+    Decode: Constant;
+    Parse: Constant;
+};

package/dst/constant/Float.js

@@ -0,0 +1,80 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+export 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;
+};
+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`);
+    }
+};
+export const formatFloat = (value, radix) => value.toString(radix) + (Number.isInteger(value) ? '.0' : '');
+const typeNumberOrArray = Type.union(Type.Float, Type.arrayType([Type.Float]));
+const typeAggregator = Type.functionType(Type.Float, [typeNumberOrArray], true);
+const typeNumberTransform = Type.functionType(Type.Float, [Type.Float]);
+const funcSum = new Constant((...values) => values.flat().reduce((acc, val) => acc + val, 0), typeAggregator);
+const funcMin = new Constant((...values) => Math.min(Number.POSITIVE_INFINITY, ...values.flat()), typeAggregator);
+const funcMax = new Constant((...values) => Math.max(Number.NEGATIVE_INFINITY, ...values.flat()), typeAggregator);
+const funcExponent = new Constant((value) => Math.exp(value), typeNumberTransform);
+const funcLogarithm = new Constant((value) => Math.log(value), typeNumberTransform);
+const funcAbs = new Constant((value) => Math.abs(value), typeNumberTransform);
+const funcCeil = new Constant((value) => Math.ceil(value), typeNumberTransform);
+const funcFloor = new Constant((value) => Math.floor(value), typeNumberTransform);
+const funcRound = new Constant((value) => Math.round(value), typeNumberTransform);
+const funcTruncate = new Constant((value) => Math.trunc(value), typeNumberTransform);
+const funcRandomFloat = new Constant((value) => value == null ? undefined : Math.random() * value, Type.functionType(Type.Float, [Type.Float]), false);
+const funcDecodeFloat = new Constant((value, encoding = 'float64', byteOffset) => decodeFloat(value, encoding, byteOffset == null ? undefined : Number(byteOffset)), Type.functionType(Type.OptionalFloat, [Type.Buffer, Type.OptionalString, Type.OptionalInteger]));
+const funcParseFloat = new Constant((value) => value ? Number.parseFloat(value) : undefined, Type.functionType(Type.OptionalFloat, [Type.String]));
+export const constFloat = {
+    NAN: new Constant(Number.NaN),
+    PositiveInfinity: new Constant(Number.POSITIVE_INFINITY),
+    NegativeInfinity: new Constant(Number.NEGATIVE_INFINITY),
+    Epsilon: new 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/constant/Integer.d.ts

@@ -0,0 +1,10 @@
+import { Constant } from '../Constant.js';
+export declare const encodeInteger: (value: bigint, encoding?: "int8" | "int16" | "int16le" | "int32" | "int32le" | "uint8" | "uint16" | "uint16le" | "uint32" | "uint32le" | "int64" | "int64le" | "uint64" | "uint64le") => ArrayBuffer;
+export declare const constInteger: {
+    Sum: Constant;
+    Min: Constant;
+    Max: Constant;
+    Random: Constant;
+    Decode: Constant;
+    Parse: Constant;
+};

package/dst/constant/Integer.js

@@ -0,0 +1,100 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+export 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;
+};
+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.union(Type.Integer, Type.arrayType([Type.Integer]));
+const typeAggregator = Type.functionType(Type.Integer, [typeIntegerOrArray], true);
+const funcSum = new Constant((...values) => BigInt.asIntN(64, values.flat().reduce((acc, val) => acc + val, 0n)), typeAggregator);
+const funcMin = new Constant((...values) => BigInt.asIntN(64, values.flat().reduce((min, val) => val < min ? val : min)), typeAggregator);
+const funcMax = new Constant((...values) => BigInt.asIntN(64, values.flat().reduce((max, val) => val > max ? val : max)), typeAggregator);
+const funcRandomInteger = new Constant((value) => value == null ? undefined : BigInt.asIntN(64, BigInt(Math.floor(Math.random() * Number(value)))), Type.functionType(Type.Integer, [Type.Integer]), false);
+const funcDecodeInteger = new Constant((value, encoding = 'int64', byteOffset) => decodeInteger(value, encoding, byteOffset == null ? undefined : Number(byteOffset)), Type.functionType(Type.OptionalInteger, [Type.Buffer, Type.OptionalString, Type.OptionalInteger]));
+const funcParseInteger = new Constant((value) => value ? BigInt.asIntN(64, BigInt(value)) : undefined, Type.functionType(Type.OptionalInteger, [Type.String]));
+export const constInteger = {
+    Sum: funcSum,
+    Min: funcMin,
+    Max: funcMax,
+    Random: funcRandomInteger,
+    Decode: funcDecodeInteger,
+    Parse: funcParseInteger,
+};

package/dst/constant/Iterable.d.ts

@@ -0,0 +1,3 @@
+import { Constant } from '../Constant.js';
+export declare const funcLength: Constant;
+export declare const funcAt: Constant;

package/dst/constant/Iterable.js

@@ -0,0 +1,21 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+export const funcLength = new 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.functionType(Type.Integer, [Type.Iterable]));
+export const funcAt = new 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.union(Type.functionType(Type.Unknown, [Type.Array, Type.Integer]), Type.functionType(Type.Unknown, [Type.Object, Type.String])));

package/dst/constant/Number.d.ts

@@ -0,0 +1,14 @@
+import { Constant } from '../Constant.js';
+export declare const funcGreaterThan: Constant;
+export declare const funcLessThan: Constant;
+export declare const funcGreaterOrEqual: Constant;
+export declare const funcLessOrEqual: Constant;
+export declare const funcSubtract: Constant;
+export declare const funcMultiply: Constant;
+export declare const funcDivide: Constant;
+export declare const funcRemainder: Constant;
+export declare const funcModulo: Constant;
+export declare const funcPower: Constant;
+export declare const funcRoot: Constant;
+export declare const funcNegate: Constant;
+export declare const funcCast: Constant;

package/dst/constant/Number.js

@@ -0,0 +1,56 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+const typeComparator = Type.functionType(Type.Boolean, [Type.Number, Type.Number]);
+const typeOperator = Type.union(Type.functionType(Type.Float, [Type.Float, Type.Integer]), Type.functionType(Type.Float, [Type.Integer, Type.Float]), Type.functionType(Type.Integer, [Type.Integer, Type.Integer]));
+export const funcGreaterThan = new Constant((value1, value2) => value1 > value2, typeComparator);
+export const funcLessThan = new Constant((value1, value2) => value1 < value2, typeComparator);
+export const funcGreaterOrEqual = new Constant((value1, value2) => value1 >= value2, typeComparator);
+export const funcLessOrEqual = new Constant((value1, value2) => value1 <= value2, typeComparator);
+export const funcSubtract = new Constant((value, subtrahend) => typeof value === 'bigint' && typeof subtrahend === 'bigint'
+    ? BigInt.asIntN(64, value - subtrahend)
+    : Number(value) - Number(subtrahend), typeOperator);
+export const funcMultiply = new Constant((value1, value2) => typeof value1 === 'bigint' && typeof value2 === 'bigint'
+    ? BigInt.asIntN(64, value1 * value2)
+    : Number(value1) * Number(value2), typeOperator);
+export const funcDivide = new Constant((value, divisor) => typeof value === 'bigint' && typeof divisor === 'bigint'
+    ? BigInt.asIntN(64, value / divisor)
+    : Number(value) / Number(divisor), typeOperator);
+export const funcRemainder = new Constant((value, divisor) => typeof value === 'bigint' && typeof divisor === 'bigint'
+    ? BigInt.asIntN(64, value % divisor)
+    : Number(value) % Number(divisor), typeOperator);
+export const funcModulo = new 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);
+export const funcPower = new Constant((value, exponent) => typeof value === 'bigint' && typeof exponent === 'bigint'
+    ? BigInt.asIntN(64, value ** BigInt(exponent))
+    : Number(value) ** Number(exponent), typeOperator);
+export const funcRoot = new 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);
+export const funcNegate = new Constant((value) => typeof value === 'number' ? -value : BigInt.asIntN(64, -value), Type.union(Type.functionType(Type.Float, [Type.Float]), Type.functionType(Type.Integer, [Type.Integer])));
+export const funcCast = new Constant((value) => typeof value === 'number' ? BigInt.asIntN(64, BigInt(Math.trunc(value))) : Number(value), Type.union(Type.functionType(Type.Float, [Type.Integer]), Type.functionType(Type.Integer, [Type.Float])));

package/dst/constant/Object.d.ts

@@ -0,0 +1,7 @@
+import { Constant } from '../Constant.js';
+export declare const funcEntries: Constant;
+export declare const funcKeys: Constant;
+export declare const funcValues: Constant;
+export declare const constObject: {
+    Merge: Constant;
+};

package/dst/constant/Object.js

@@ -0,0 +1,10 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+const typeAccessor = Type.functionType(Type.Array, [Type.Object]);
+export const funcEntries = new Constant((value) => Object.entries(value), typeAccessor);
+export const funcKeys = new Constant((value) => Object.keys(value), Type.functionType(Type.arrayType([Type.String]), [Type.Object]));
+export const funcValues = new Constant((value) => Object.values(value), typeAccessor);
+const funcMerge = new Constant((...values) => values.flat().reduce((acc, val) => Object.assign(acc, val), {}), Type.functionType(Type.Object, [Type.union(Type.arrayType([Type.Object]), Type.Object)], true));
+export const constObject = {
+    Merge: funcMerge,
+};

package/dst/constant/String.d.ts

@@ -0,0 +1,34 @@
+import { Constant } from '../Constant.js';
+export declare const isSign: (c: string) => c is "+" | "-";
+export declare const isAlpha: (c: string) => boolean;
+export declare const isNumeric: (c: string) => boolean;
+export declare const isAlphanumeric: (c: string) => boolean;
+export declare const isDateSymbol: (c: string) => boolean;
+export declare const isTimeSymbol: (c: string) => boolean;
+export declare const isDateTimeSeparator: (c: string) => c is " " | "T" | "@";
+export declare const isHexadecimal: (c: string) => boolean;
+export declare const isQuotation: (c: string) => c is "'" | "\"" | "`";
+export declare const isCaseSpaceEtc: (c: string) => boolean;
+export declare const equateStrings: (value1: string, value2: string, ignoreCaseSpaceEtc?: boolean) => boolean;
+export declare const containsString: (value: string, search: string, startPos?: number, ignoreCaseSpaceEtc?: boolean) => boolean;
+export declare const startsWithString: (value: string, search: string, startPos?: number, ignoreCaseSpaceEtc?: boolean) => boolean;
+export declare const endsWithString: (value: string, search: string, endPos?: number, ignoreCaseSpaceEtc?: boolean) => boolean;
+export declare const encodeString: (value: string, encoding?: "utf8" | "ucs2" | "ucs2le") => ArrayBufferLike;
+export declare const funcLike: Constant;
+export declare const funcUnlike: Constant;
+export declare const funcContains: Constant;
+export declare const funcStartsWith: Constant;
+export declare const funcEndsWith: Constant;
+export declare const funcChar: Constant;
+export declare const funcCharCode: Constant;
+export declare const funcTrim: Constant;
+export declare const funcTrimStart: Constant;
+export declare const funcTrimEnd: Constant;
+export declare const funcLowerCase: Constant;
+export declare const funcUpperCase: Constant;
+export declare const funcSplit: Constant;
+export declare const constString: {
+    Alphanum: Constant;
+    Random: Constant;
+    Decode: Constant;
+};

package/dst/constant/String.js

@@ -0,0 +1,179 @@
+import { Constant } from '../Constant.js';
+import { Type } from '../Type.js';
+export const isSign = (c) => c === '+' || c === '-';
+export const isAlpha = (c) => c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c === '_';
+export const isNumeric = (c) => c >= '0' && c <= '9';
+export const isAlphanumeric = (c) => isAlpha(c) || isNumeric(c);
+export const isDateSymbol = (c) => isNumeric(c) || c === '-';
+export const isTimeSymbol = (c) => isNumeric(c) || c === ':';
+export const isDateTimeSeparator = (c) => c === 'T' || c === ' ' || c === '@';
+export const isHexadecimal = (c) => isNumeric(c) || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F';
+export const isQuotation = (c) => c === '\'' || c === '"' || c === '`';
+export const isCaseSpaceEtc = (c) => (c < 'a' || c > 'z') && (c < '0' || c > '9');
+export 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 (isCaseSpaceEtc(str1[i1]) && i1 < str1.length) {
+            ++i1;
+        }
+        while (isCaseSpaceEtc(str2[i2]) && i2 < str2.length) {
+            ++i2;
+        }
+        if (str1[i1] != str2[i2]) {
+            return false;
+        }
+    }
+    return true;
+};
+export 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 (isCaseSpaceEtc(valueStr[i1]) && i1 < valueStr.length) {
+            ++i1;
+        }
+        while (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;
+};
+export 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 (isCaseSpaceEtc(valueStr[i1]) && i1 < valueStr.length) {
+            ++i1;
+        }
+        while (isCaseSpaceEtc(searchStr[i2]) && i2 < searchStr.length) {
+            ++i2;
+        }
+        if (valueStr[i1] != searchStr[i2] && i2 < searchStr.length) {
+            return false;
+        }
+    }
+    return true;
+};
+export 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 (isCaseSpaceEtc(valueStr[i1]) && i1 > -1) {
+            --i1;
+        }
+        while (isCaseSpaceEtc(searchStr[i2]) && i2 > -1) {
+            --i2;
+        }
+        if (valueStr[i1] != searchStr[i2] && i2 > -1) {
+            return false;
+        }
+    }
+    return true;
+};
+export 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;
+    }
+};
+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.functionType(Type.Boolean, [Type.String, Type.String]);
+const typeStringComparator = Type.functionType(Type.Boolean, [Type.String, Type.String, Type.OptionalInteger, Type.OptionalBoolean]);
+const typeStringMutator = Type.functionType(Type.String, [Type.String]);
+export const funcLike = new Constant((value1, value2) => equateStrings(value1, value2, true), typeStringEquator);
+export const funcUnlike = new Constant((value1, value2) => !equateStrings(value1, value2, true), typeStringEquator);
+export const funcContains = new Constant((value, search, start, ignoreCaseSpaceEtc) => containsString(value, search, start == null ? undefined : Number(start), ignoreCaseSpaceEtc), typeStringComparator);
+export const funcStartsWith = new Constant((value, search, start, ignoreCaseSpaceEtc) => startsWithString(value, search, start == null ? undefined : Number(start), ignoreCaseSpaceEtc), typeStringComparator);
+export const funcEndsWith = new Constant((value, search, end, ignoreCaseSpaceEtc) => endsWithString(value, search, end == null ? undefined : Number(end), ignoreCaseSpaceEtc), typeStringComparator);
+export const funcChar = new Constant((value, pos) => value == null
+    ? undefined
+    : value.charAt(pos < 0 ? value.length + Number(pos) : Number(pos)), Type.functionType(Type.OptionalString, [Type.String, Type.Integer]));
+export const funcCharCode = new Constant((value, pos) => value == null
+    ? undefined
+    : value.charCodeAt(pos < 0 ? value.length + Number(pos) : Number(pos)), Type.functionType(Type.OptionalInteger, [Type.String, Type.Float]));
+export const funcTrim = new Constant((value) => value.trim(), typeStringMutator);
+export const funcTrimStart = new Constant((value) => value.trimStart(), typeStringMutator);
+export const funcTrimEnd = new Constant((value) => value.trimEnd(), typeStringMutator);
+export const funcLowerCase = new Constant((value) => value.toLowerCase(), typeStringMutator);
+export const funcUpperCase = new Constant((value) => value.toUpperCase(), typeStringMutator);
+export const funcSplit = new Constant((value, separator = ' ') => value.split(separator), Type.functionType(Type.arrayType([Type.String]), [Type.String, Type.OptionalString]));
+const funcAlphanum = new Constant((value) => {
+    const lowerCase = value.toLowerCase();
+    let result = '';
+    for (let i = 0; i < lowerCase.length; ++i) {
+        if (!isCaseSpaceEtc(value[i])) {
+            result += value[i];
+        }
+    }
+    return result;
+}, typeStringMutator);
+const funcRandomString = new Constant((value) => {
+    let str = '';
+    while (str.length < value) {
+        str += Math.random().toString(36).slice(2);
+    }
+    return str.slice(0, Number(value));
+}, Type.functionType(Type.String, [Type.Integer]), false);
+const funcDecodeString = new Constant((value, encoding = 'utf8', byteOffset, byteLength) => decodeString(value, encoding, byteOffset == null ? undefined : Number(byteOffset), byteLength == null ? undefined : Number(byteLength)), Type.functionType(Type.OptionalString, [Type.Buffer, Type.OptionalString, Type.OptionalInteger, Type.OptionalInteger]));
+export const constString = {
+    Alphanum: funcAlphanum,
+    Random: funcRandomString,
+    Decode: funcDecodeString,
+};