toiljs 0.0.16 → 0.0.19

package/build/io/BinaryReader.js

@@ -1,244 +0,0 @@
-import { I128_BYTE_LENGTH, I16_BYTE_LENGTH, I32_BYTE_LENGTH, I64_BYTE_LENGTH, I8_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U8_BYTE_LENGTH, } from './lengths.js';
-export class BinaryReader {
-    buffer;
-    currentOffset = 0;
-    constructor(bytes) {
-        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    }
-    get byteLength() {
-        return this.buffer.byteLength;
-    }
-    static stringCompare(a, b) {
-        return a.localeCompare(b);
-    }
-    static bigintCompare(a, b) {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    }
-    static numberCompare(a, b) {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    }
-    setBuffer(bytes) {
-        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        this.currentOffset = 0;
-    }
-    length() {
-        return this.buffer.byteLength;
-    }
-    bytesLeft() {
-        return this.buffer.byteLength - this.currentOffset;
-    }
-    readI8() {
-        this.verifyEnd(this.currentOffset + I8_BYTE_LENGTH);
-        const value = this.buffer.getInt8(this.currentOffset);
-        this.currentOffset += I8_BYTE_LENGTH;
-        return value;
-    }
-    readI16(be = true) {
-        this.verifyEnd(this.currentOffset + I16_BYTE_LENGTH);
-        const value = this.buffer.getInt16(this.currentOffset, !be);
-        this.currentOffset += I16_BYTE_LENGTH;
-        return value;
-    }
-    readI32(be = true) {
-        this.verifyEnd(this.currentOffset + I32_BYTE_LENGTH);
-        const value = this.buffer.getInt32(this.currentOffset, !be);
-        this.currentOffset += I32_BYTE_LENGTH;
-        return value;
-    }
-    readI64(be = true) {
-        this.verifyEnd(this.currentOffset + I64_BYTE_LENGTH);
-        const value = this.buffer.getBigInt64(this.currentOffset, !be);
-        this.currentOffset += I64_BYTE_LENGTH;
-        return value;
-    }
-    readU8() {
-        this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
-        const value = this.buffer.getUint8(this.currentOffset);
-        this.currentOffset += U8_BYTE_LENGTH;
-        return value;
-    }
-    readU16(be = true) {
-        this.verifyEnd(this.currentOffset + U16_BYTE_LENGTH);
-        const value = this.buffer.getUint16(this.currentOffset, !be);
-        this.currentOffset += U16_BYTE_LENGTH;
-        return value;
-    }
-    readU32(be = true) {
-        this.verifyEnd(this.currentOffset + U32_BYTE_LENGTH);
-        const value = this.buffer.getUint32(this.currentOffset, !be);
-        this.currentOffset += U32_BYTE_LENGTH;
-        return value;
-    }
-    readU64(be = true) {
-        this.verifyEnd(this.currentOffset + U64_BYTE_LENGTH);
-        const value = this.buffer.getBigUint64(this.currentOffset, !be);
-        this.currentOffset += U64_BYTE_LENGTH;
-        return value;
-    }
-    readU128(be = true) {
-        const raw = this.readBytes(U128_BYTE_LENGTH);
-        let bytes = raw;
-        if (!be) {
-            bytes = this.reverseBytes(raw);
-        }
-        return BigInt('0x' + this.toHexString(bytes));
-    }
-    readU256(be = true) {
-        const raw = this.readBytes(U256_BYTE_LENGTH);
-        let bytes = raw;
-        if (!be) {
-            bytes = this.reverseBytes(raw);
-        }
-        return BigInt('0x' + this.toHexString(bytes));
-    }
-    readI128(be = true) {
-        const raw = this.readBytes(I128_BYTE_LENGTH);
-        let bytes = raw;
-        if (!be) {
-            bytes = this.reverseBytes(raw);
-        }
-        let value = BigInt('0x' + this.toHexString(bytes));
-        const signBitMask = 0x80;
-        if (bytes[0] & signBitMask) {
-            const twoTo128 = BigInt(1) << BigInt(128);
-            value = value - twoTo128;
-        }
-        return value;
-    }
-    readBoolean() {
-        return this.readU8() !== 0;
-    }
-    readSelector() {
-        return this.readU32(true);
-    }
-    readBytes(length, zeroStop = false) {
-        this.verifyEnd(this.currentOffset + length);
-        let bytes = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            const b = this.buffer.getUint8(this.currentOffset++);
-            if (zeroStop && b === 0) {
-                bytes = new Uint8Array(bytes.subarray(0, i));
-                break;
-            }
-            bytes[i] = b;
-        }
-        return bytes;
-    }
-    readString(length) {
-        const textDecoder = new TextDecoder();
-        const bytes = this.readBytes(length, false);
-        return textDecoder.decode(bytes);
-    }
-    readStringWithLength(be = true) {
-        const length = this.readU32(be);
-        return this.readString(length);
-    }
-    readBytesWithLength(maxLength = 0, be = true) {
-        const length = this.readU32(be);
-        if (maxLength > 0 && length > maxLength) {
-            throw new Error('Data length exceeds maximum length.');
-        }
-        return this.readBytes(length);
-    }
-    readArrayOfBuffer(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readBytesWithLength();
-        }
-        return result;
-    }
-    readU256Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU256(be);
-        }
-        return result;
-    }
-    readU128Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU128(be);
-        }
-        return result;
-    }
-    readU64Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU64(be);
-        }
-        return result;
-    }
-    readU32Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU32(be);
-        }
-        return result;
-    }
-    readU16Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU16(be);
-        }
-        return result;
-    }
-    readU8Array() {
-        const length = this.readU16(true);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU8();
-        }
-        return result;
-    }
-    readStringArray(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readStringWithLength(be);
-        }
-        return result;
-    }
-    readBytesArray(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readBytesWithLength(0, be);
-        }
-        return result;
-    }
-    getOffset() {
-        return this.currentOffset;
-    }
-    setOffset(offset) {
-        this.currentOffset = offset;
-    }
-    verifyEnd(size) {
-        if (size > this.buffer.byteLength) {
-            throw new Error(`Attempt to read beyond buffer length: requested up to byte offset ${size}, but buffer is only ${this.buffer.byteLength} bytes.`);
-        }
-    }
-    reverseBytes(bytes) {
-        const out = new Uint8Array(bytes.length);
-        for (let i = 0; i < bytes.length; i++) {
-            out[i] = bytes[bytes.length - 1 - i];
-        }
-        return out;
-    }
-    toHexString(bytes) {
-        return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
-    }
-}

package/build/io/BinaryWriter.d.ts

@@ -1,44 +0,0 @@
-import type { i16, i32, i64, i8, Selector, u16, u32, u64, u8 } from './types.js';
-import { BinaryReader } from './BinaryReader.js';
-export declare class BinaryWriter implements Disposable {
-    private currentOffset;
-    private buffer;
-    constructor(length?: number);
-    static estimateArrayOfBufferLength(values: Uint8Array[]): u32;
-    writeU8(value: u8): void;
-    writeU16(value: u16, be?: boolean): void;
-    writeU32(value: u32, be?: boolean): void;
-    writeU64(value: u64, be?: boolean): void;
-    writeI8(value: i8): void;
-    writeI16(value: i16, be?: boolean): void;
-    writeI32(value: i32, be?: boolean): void;
-    writeI64(value: i64, be?: boolean): void;
-    writeSelector(value: Selector): void;
-    writeBoolean(value: boolean): void;
-    writeI128(bigIntValue: bigint, be?: boolean): void;
-    writeU256(bigIntValue: bigint, be?: boolean): void;
-    writeU128(bigIntValue: bigint, be?: boolean): void;
-    writeBytes(value: Uint8Array): void;
-    writeString(value: string): void;
-    writeStringWithLength(value: string): void;
-    getBuffer(clear?: boolean): Uint8Array;
-    reset(): void;
-    toBytesReader(): BinaryReader;
-    getOffset(): u32;
-    setOffset(offset: u32): void;
-    clear(): void;
-    [Symbol.dispose](): void;
-    allocSafe(size: u32): void;
-    writeBytesWithLength(value: Uint8Array): void;
-    writeArrayOfBuffer(values: Uint8Array[], be?: boolean): void;
-    writeU32Array(value: u32[], be?: boolean): void;
-    writeU256Array(value: bigint[], be?: boolean): void;
-    writeU128Array(value: bigint[], be?: boolean): void;
-    writeStringArray(value: string[]): void;
-    writeU16Array(value: u16[], be?: boolean): void;
-    writeU8Array(value: u8[]): void;
-    writeU64Array(value: bigint[], be?: boolean): void;
-    writeBytesArray(value: Uint8Array[]): void;
-    private resize;
-    private getDefaultBuffer;
-}

package/build/io/BinaryWriter.js

@@ -1,297 +0,0 @@
-import { I128_BYTE_LENGTH, I16_BYTE_LENGTH, I32_BYTE_LENGTH, I64_BYTE_LENGTH, I8_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U8_BYTE_LENGTH, } from './lengths.js';
-import { BinaryReader } from './BinaryReader.js';
-function bigIntToBytes(value, length = U256_BYTE_LENGTH) {
-    if (value < 0n) {
-        throw new RangeError('Value cannot be negative');
-    }
-    const hex = value.toString(16).padStart(length * 2, '0');
-    if (hex.length > length * 2) {
-        throw new RangeError(`Value exceeds ${length}-byte range`);
-    }
-    const out = new Uint8Array(length);
-    for (let i = 0; i < length; i++) {
-        out[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
-    }
-    return out;
-}
-export class BinaryWriter {
-    currentOffset = 0;
-    buffer;
-    constructor(length = 0) {
-        this.buffer = this.getDefaultBuffer(length);
-    }
-    static estimateArrayOfBufferLength(values) {
-        if (values.length > 65535)
-            throw new Error('Array size is too large');
-        let totalLength = U16_BYTE_LENGTH;
-        for (let i = 0; i < values.length; i++) {
-            totalLength += U32_BYTE_LENGTH + values[i].length;
-        }
-        return totalLength;
-    }
-    writeU8(value) {
-        if (value > 255)
-            throw new Error('u8 value is too large.');
-        this.allocSafe(U8_BYTE_LENGTH);
-        this.buffer.setUint8(this.currentOffset++, value);
-    }
-    writeU16(value, be = true) {
-        if (value > 65535)
-            throw new Error('u16 value is too large.');
-        this.allocSafe(U16_BYTE_LENGTH);
-        this.buffer.setUint16(this.currentOffset, value, !be);
-        this.currentOffset += 2;
-    }
-    writeU32(value, be = true) {
-        if (value > 4294967295)
-            throw new Error('u32 value is too large.');
-        this.allocSafe(U32_BYTE_LENGTH);
-        this.buffer.setUint32(this.currentOffset, value, !be);
-        this.currentOffset += 4;
-    }
-    writeU64(value, be = true) {
-        if (value > 18446744073709551615n)
-            throw new Error('u64 value is too large.');
-        this.allocSafe(U64_BYTE_LENGTH);
-        this.buffer.setBigUint64(this.currentOffset, value, !be);
-        this.currentOffset += 8;
-    }
-    writeI8(value) {
-        if (value < -128 || value > 127)
-            throw new Error('i8 value is out of range.');
-        this.allocSafe(I8_BYTE_LENGTH);
-        this.buffer.setInt8(this.currentOffset, value);
-        this.currentOffset += I8_BYTE_LENGTH;
-    }
-    writeI16(value, be = true) {
-        if (value < -32768 || value > 32767)
-            throw new Error('i16 value is out of range.');
-        this.allocSafe(I16_BYTE_LENGTH);
-        this.buffer.setInt16(this.currentOffset, value, !be);
-        this.currentOffset += I16_BYTE_LENGTH;
-    }
-    writeI32(value, be = true) {
-        if (value < -2147483648 || value > 2147483647)
-            throw new Error('i32 value is out of range.');
-        this.allocSafe(I32_BYTE_LENGTH);
-        this.buffer.setInt32(this.currentOffset, value, !be);
-        this.currentOffset += I32_BYTE_LENGTH;
-    }
-    writeI64(value, be = true) {
-        if (value < -9223372036854775808n || value > 9223372036854775807n) {
-            throw new Error('i64 value is out of range.');
-        }
-        this.allocSafe(I64_BYTE_LENGTH);
-        this.buffer.setBigInt64(this.currentOffset, value, !be);
-        this.currentOffset += I64_BYTE_LENGTH;
-    }
-    writeSelector(value) {
-        this.writeU32(value, true);
-    }
-    writeBoolean(value) {
-        this.writeU8(value ? 1 : 0);
-    }
-    writeI128(bigIntValue, be = true) {
-        if (bigIntValue > 170141183460469231731687303715884105727n ||
-            bigIntValue < -170141183460469231731687303715884105728n) {
-            throw new Error('i128 value is too large.');
-        }
-        this.allocSafe(I128_BYTE_LENGTH);
-        const bytes = bigIntToBytes(bigIntValue, I128_BYTE_LENGTH);
-        if (bytes.byteLength !== I128_BYTE_LENGTH) {
-            throw new Error(`Invalid i128 value: ${bigIntValue}`);
-        }
-        if (be) {
-            for (let i = 0; i < bytes.byteLength; i++) {
-                this.writeU8(bytes[i]);
-            }
-        }
-        else {
-            for (let i = bytes.byteLength - 1; i >= 0; i--) {
-                this.writeU8(bytes[i]);
-            }
-        }
-    }
-    writeU256(bigIntValue, be = true) {
-        if (bigIntValue >
-            115792089237316195423570985008687907853269984665640564039457584007913129639935n ||
-            bigIntValue < 0n) {
-            throw new Error('u256 value is too large or negative.');
-        }
-        this.allocSafe(U256_BYTE_LENGTH);
-        const bytes = bigIntToBytes(bigIntValue);
-        if (bytes.byteLength !== U256_BYTE_LENGTH) {
-            throw new Error(`Invalid u256 value: ${bigIntValue}`);
-        }
-        if (be) {
-            for (let i = 0; i < bytes.byteLength; i++) {
-                this.writeU8(bytes[i]);
-            }
-        }
-        else {
-            for (let i = bytes.byteLength - 1; i >= 0; i--) {
-                this.writeU8(bytes[i]);
-            }
-        }
-    }
-    writeU128(bigIntValue, be = true) {
-        if (bigIntValue > 340282366920938463463374607431768211455n || bigIntValue < 0n) {
-            throw new Error('u128 value is too large or negative.');
-        }
-        this.allocSafe(U128_BYTE_LENGTH);
-        const bytes = bigIntToBytes(bigIntValue, U128_BYTE_LENGTH);
-        if (bytes.byteLength !== U128_BYTE_LENGTH) {
-            throw new Error(`Invalid u128 value: ${bigIntValue}`);
-        }
-        if (be) {
-            for (let i = 0; i < bytes.byteLength; i++) {
-                this.writeU8(bytes[i]);
-            }
-        }
-        else {
-            for (let i = bytes.byteLength - 1; i >= 0; i--) {
-                this.writeU8(bytes[i]);
-            }
-        }
-    }
-    writeBytes(value) {
-        this.allocSafe(value.byteLength);
-        for (let i = 0; i < value.byteLength; i++) {
-            this.writeU8(value[i]);
-        }
-    }
-    writeString(value) {
-        const encoder = new TextEncoder();
-        const bytes = encoder.encode(value);
-        this.allocSafe(bytes.length);
-        this.writeBytes(bytes);
-    }
-    writeStringWithLength(value) {
-        const encoder = new TextEncoder();
-        const bytes = encoder.encode(value);
-        this.allocSafe(U32_BYTE_LENGTH + bytes.length);
-        this.writeU32(bytes.length);
-        this.writeBytes(bytes);
-    }
-    getBuffer(clear = true) {
-        const buf = new Uint8Array(this.buffer.byteLength);
-        for (let i = 0; i < this.buffer.byteLength; i++) {
-            buf[i] = this.buffer.getUint8(i);
-        }
-        if (clear)
-            this.clear();
-        return buf;
-    }
-    reset() {
-        this.currentOffset = 0;
-        this.buffer = this.getDefaultBuffer(4);
-    }
-    toBytesReader() {
-        return new BinaryReader(this.getBuffer());
-    }
-    getOffset() {
-        return this.currentOffset;
-    }
-    setOffset(offset) {
-        this.currentOffset = offset;
-    }
-    clear() {
-        this.currentOffset = 0;
-        this.buffer = this.getDefaultBuffer();
-    }
-    [Symbol.dispose]() {
-        this.clear();
-    }
-    allocSafe(size) {
-        if (this.currentOffset + size > this.buffer.byteLength) {
-            this.resize(size);
-        }
-    }
-    writeBytesWithLength(value) {
-        this.writeU32(value.length);
-        this.writeBytes(value);
-    }
-    writeArrayOfBuffer(values, be = true) {
-        const totalLength = BinaryWriter.estimateArrayOfBufferLength(values);
-        this.allocSafe(totalLength);
-        this.writeU16(values.length, be);
-        for (let i = 0; i < values.length; i++) {
-            this.writeU32(values[i].length, be);
-            this.writeBytes(values[i]);
-        }
-    }
-    writeU32Array(value, be = true) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length, be);
-        for (let i = 0; i < value.length; i++) {
-            this.writeU32(value[i], be);
-        }
-    }
-    writeU256Array(value, be = true) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length, be);
-        for (let i = 0; i < value.length; i++) {
-            this.writeU256(value[i], be);
-        }
-    }
-    writeU128Array(value, be = true) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length, be);
-        for (let i = 0; i < value.length; i++) {
-            this.writeU128(value[i], be);
-        }
-    }
-    writeStringArray(value) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length);
-        for (let i = 0; i < value.length; i++) {
-            this.writeStringWithLength(value[i]);
-        }
-    }
-    writeU16Array(value, be = true) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length, be);
-        for (let i = 0; i < value.length; i++) {
-            this.writeU16(value[i], be);
-        }
-    }
-    writeU8Array(value) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length);
-        for (let i = 0; i < value.length; i++) {
-            this.writeU8(value[i]);
-        }
-    }
-    writeU64Array(value, be = true) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length, be);
-        for (let i = 0; i < value.length; i++) {
-            this.writeU64(value[i], be);
-        }
-    }
-    writeBytesArray(value) {
-        if (value.length > 65535)
-            throw new Error('Array size is too large');
-        this.writeU16(value.length);
-        for (let i = 0; i < value.length; i++) {
-            this.writeBytesWithLength(value[i]);
-        }
-    }
-    resize(size) {
-        const buf = new Uint8Array(this.buffer.byteLength + size);
-        for (let i = 0; i < this.buffer.byteLength; i++) {
-            buf[i] = this.buffer.getUint8(i);
-        }
-        this.buffer = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    }
-    getDefaultBuffer(length = 0) {
-        return new DataView(new ArrayBuffer(length));
-    }
-}

package/build/server/release.wat

@@ -1,9 +0,0 @@
-(module
- (type $0 (func (result i32)))
- (memory $0 1)
- (export "memory" (memory $0))
- (export "main" (func $src/server/main/run))
- (func $src/server/main/run (result i32)
-  i32.const 42
- )
-)