goscript 0.2.3 → 0.2.5

package/dist/gs/encoding/binary/index.js

@@ -0,0 +1,778 @@
+import * as $ from '@goscript/builtin/index.js';
+import * as io from '@goscript/io/index.js';
+const errBufferTooSmall = $.newError('buffer too small');
+const errOverflow = $.newError('binary: varint overflows a 64-bit integer');
+export const MaxVarintLen16 = 3;
+export const MaxVarintLen32 = 5;
+export const MaxVarintLen64 = 10;
+class littleEndian {
+    Uint(b) {
+        return this.Uint64(b);
+    }
+    Uint16(b) {
+        requireLen(b, 2);
+        return byteAt(b, 0) | (byteAt(b, 1) << 8);
+    }
+    Uint32(b) {
+        requireLen(b, 4);
+        return ((byteAt(b, 0) |
+            (byteAt(b, 1) << 8) |
+            (byteAt(b, 2) << 16) |
+            (byteAt(b, 3) << 24)) >>>
+            0);
+    }
+    Uint64(b) {
+        requireLen(b, 8);
+        let value = 0n;
+        for (let i = 0; i < 8; i++) {
+            value |= BigInt(byteAt(b, i)) << BigInt(8 * i);
+        }
+        return uint64Result(value);
+    }
+    PutUint16(b, v) {
+        requireLen(b, 2);
+        setByte(b, 0, v);
+        setByte(b, 1, v >> 8);
+    }
+    PutUint32(b, v) {
+        requireLen(b, 4);
+        const value = Number($.uint(v, 32));
+        setByte(b, 0, value);
+        setByte(b, 1, value >>> 8);
+        setByte(b, 2, value >>> 16);
+        setByte(b, 3, value >>> 24);
+    }
+    PutUint64(b, v) {
+        requireLen(b, 8);
+        const value = toUint64(v);
+        for (let i = 0; i < 8; i++) {
+            setByte(b, i, Number((value >> BigInt(8 * i)) & 0xffn));
+        }
+    }
+    AppendUint16(b, v) {
+        return $.append(b, v, v >> 8);
+    }
+    AppendUint32(b, v) {
+        const value = Number($.uint(v, 32));
+        return $.append(b, value, value >>> 8, value >>> 16, value >>> 24);
+    }
+    AppendUint64(b, v) {
+        let out = b;
+        const value = toUint64(v);
+        for (let i = 0; i < 8; i++) {
+            out = $.append(out, Number((value >> BigInt(8 * i)) & 0xffn));
+        }
+        return out;
+    }
+    String() {
+        return 'LittleEndian';
+    }
+    GoString() {
+        return 'binary.LittleEndian';
+    }
+    clone() {
+        return $.markAsStructValue(new littleEndian());
+    }
+}
+class bigEndian {
+    Uint(b) {
+        return this.Uint64(b);
+    }
+    Uint16(b) {
+        requireLen(b, 2);
+        return byteAt(b, 1) | (byteAt(b, 0) << 8);
+    }
+    Uint32(b) {
+        requireLen(b, 4);
+        return ((byteAt(b, 3) |
+            (byteAt(b, 2) << 8) |
+            (byteAt(b, 1) << 16) |
+            (byteAt(b, 0) << 24)) >>>
+            0);
+    }
+    Uint64(b) {
+        requireLen(b, 8);
+        let value = 0n;
+        for (let i = 0; i < 8; i++) {
+            value = (value << 8n) | BigInt(byteAt(b, i));
+        }
+        return uint64Result(value);
+    }
+    PutUint16(b, v) {
+        requireLen(b, 2);
+        setByte(b, 0, v >> 8);
+        setByte(b, 1, v);
+    }
+    PutUint32(b, v) {
+        requireLen(b, 4);
+        const value = Number($.uint(v, 32));
+        setByte(b, 0, value >>> 24);
+        setByte(b, 1, value >>> 16);
+        setByte(b, 2, value >>> 8);
+        setByte(b, 3, value);
+    }
+    PutUint64(b, v) {
+        requireLen(b, 8);
+        const value = toUint64(v);
+        for (let i = 0; i < 8; i++) {
+            setByte(b, i, Number((value >> BigInt(56 - 8 * i)) & 0xffn));
+        }
+    }
+    AppendUint16(b, v) {
+        return $.append(b, v >> 8, v);
+    }
+    AppendUint32(b, v) {
+        const value = Number($.uint(v, 32));
+        return $.append(b, value >>> 24, value >>> 16, value >>> 8, value);
+    }
+    AppendUint64(b, v) {
+        let out = b;
+        const value = toUint64(v);
+        for (let i = 0; i < 8; i++) {
+            out = $.append(out, Number((value >> BigInt(56 - 8 * i)) & 0xffn));
+        }
+        return out;
+    }
+    String() {
+        return 'BigEndian';
+    }
+    GoString() {
+        return 'binary.BigEndian';
+    }
+    clone() {
+        return $.markAsStructValue(new bigEndian());
+    }
+}
+export const LittleEndian = new littleEndian();
+export const BigEndian = new bigEndian();
+export const NativeEndian = LittleEndian;
+$.registerInterfaceType('binary.ByteOrder', null, [
+    {
+        name: 'Uint16',
+        args: [byteSliceArg('b')],
+        returns: [numberReturn()],
+    },
+    {
+        name: 'Uint32',
+        args: [byteSliceArg('b')],
+        returns: [numberReturn()],
+    },
+    {
+        name: 'Uint64',
+        args: [byteSliceArg('b')],
+        returns: [numberReturn()],
+    },
+    {
+        name: 'PutUint16',
+        args: [byteSliceArg('b'), numberArg('v')],
+        returns: [],
+    },
+    {
+        name: 'PutUint32',
+        args: [byteSliceArg('b'), numberArg('v')],
+        returns: [],
+    },
+    {
+        name: 'PutUint64',
+        args: [byteSliceArg('b'), numberArg('v')],
+        returns: [],
+    },
+    {
+        name: 'String',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    },
+]);
+$.registerInterfaceType('binary.AppendByteOrder', null, [
+    {
+        name: 'AppendUint16',
+        args: [byteSliceArg('b'), numberArg('v')],
+        returns: [{ type: byteSliceType() }],
+    },
+    {
+        name: 'AppendUint32',
+        args: [byteSliceArg('b'), numberArg('v')],
+        returns: [{ type: byteSliceType() }],
+    },
+    {
+        name: 'AppendUint64',
+        args: [byteSliceArg('b'), numberArg('v')],
+        returns: [{ type: byteSliceType() }],
+    },
+    {
+        name: 'String',
+        args: [],
+        returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    },
+]);
+export function AppendUvarint(buf, x) {
+    let out = buf;
+    let value = toUint64(x);
+    while (value >= 0x80n) {
+        out = $.append(out, Number(value & 0x7fn) | 0x80);
+        value >>= 7n;
+    }
+    return $.append(out, Number(value));
+}
+export function PutUvarint(buf, x) {
+    let value = toUint64(x);
+    let i = 0;
+    while (value >= 0x80n) {
+        setByte(buf, i, Number(value & 0x7fn) | 0x80);
+        value >>= 7n;
+        i++;
+    }
+    setByte(buf, i, Number(value));
+    return i + 1;
+}
+export function Uvarint(buf) {
+    let x = 0n;
+    let s = 0n;
+    for (let i = 0; i < $.len(buf); i++) {
+        const b = byteAt(buf, i);
+        if (i === MaxVarintLen64) {
+            return [0, -(i + 1)];
+        }
+        if (b < 0x80) {
+            if (i === MaxVarintLen64 - 1 && b > 1) {
+                return [0, -(i + 1)];
+            }
+            return [uint64Result(x | (BigInt(b) << s)), i + 1];
+        }
+        x |= BigInt(b & 0x7f) << s;
+        s += 7n;
+    }
+    return [0, 0];
+}
+export function AppendVarint(buf, x) {
+    return AppendUvarint(buf, encodeSignedVarint(x));
+}
+export function PutVarint(buf, x) {
+    return PutUvarint(buf, encodeSignedVarint(x));
+}
+export function Varint(buf) {
+    const [ux, n] = Uvarint(buf);
+    return [decodeSignedVarint(ux), n];
+}
+export async function ReadUvarint(r) {
+    let x = 0n;
+    let s = 0n;
+    for (let i = 0; i < MaxVarintLen64; i++) {
+        const [b, err] = await r.ReadByte();
+        if (err !== null) {
+            return [uint64Result(x), i > 0 && isEOF(err) ? io.ErrUnexpectedEOF : err];
+        }
+        if (b < 0x80) {
+            if (i === MaxVarintLen64 - 1 && b > 1) {
+                return [uint64Result(x), errOverflow];
+            }
+            return [uint64Result(x | (BigInt(b) << s)), null];
+        }
+        x |= BigInt(b & 0x7f) << s;
+        s += 7n;
+    }
+    return [uint64Result(x), errOverflow];
+}
+export async function ReadVarint(r) {
+    const [ux, err] = await ReadUvarint(r);
+    return [decodeSignedVarint(ux), err];
+}
+export async function Read(r, order, data) {
+    const byteOrder = requireByteOrder(order);
+    const target = decodeTarget(data);
+    if (target === null) {
+        return unsupportedError('Read', data);
+    }
+    const size = fixedSize(target.kind, target.value);
+    if (size < 0) {
+        return unsupportedError('Read', data);
+    }
+    const buf = $.makeSlice(size, undefined, 'byte');
+    const [, err] = await readFull(r, buf);
+    if (err !== null) {
+        return err;
+    }
+    decodeFixed(buf, byteOrder, target);
+    return null;
+}
+export function Decode(buf, order, data) {
+    const byteOrder = requireByteOrder(order);
+    const target = decodeTarget(data);
+    if (target === null) {
+        return [0, unsupportedError('Decode', data)];
+    }
+    const size = fixedSize(target.kind, target.value);
+    if (size < 0) {
+        return [0, unsupportedError('Decode', data)];
+    }
+    if ($.len(buf) < size) {
+        return [0, errBufferTooSmall];
+    }
+    decodeFixed($.goSlice(buf, 0, size), byteOrder, target);
+    return [size, null];
+}
+export async function Write(w, order, data) {
+    const encoded = encodeData(requireByteOrder(order), data);
+    if (encoded === null) {
+        return unsupportedError('Write', data);
+    }
+    const [, err] = await w.Write(encoded);
+    return err;
+}
+export function Encode(buf, order, data) {
+    const encoded = encodeData(requireByteOrder(order), data);
+    if (encoded === null) {
+        return [0, unsupportedError('Encode', data)];
+    }
+    if ($.len(buf) < $.len(encoded)) {
+        return [0, errBufferTooSmall];
+    }
+    $.copy(buf, encoded);
+    return [$.len(encoded), null];
+}
+export function Append(buf, order, data) {
+    const encoded = encodeData(requireByteOrder(order), data);
+    if (encoded === null) {
+        return [null, unsupportedError('Append', data)];
+    }
+    return [$.appendSlice(buf, encoded), null];
+}
+export function Size(v) {
+    const target = decodeTarget(v);
+    if (target === null) {
+        return -1;
+    }
+    return fixedSize(target.kind, target.value);
+}
+function requireByteOrder(order) {
+    if (order === null) {
+        throw new Error('runtime error: invalid memory address or nil pointer dereference');
+    }
+    return order;
+}
+function decodeFixed(buf, order, target) {
+    if (target.kind.startsWith('[]')) {
+        decodeFixedSlice(buf, order, target.kind, target.value);
+        return;
+    }
+    if (target.settable === null) {
+        return;
+    }
+    target.settable(decodeScalar(buf, order, target.kind));
+}
+function decodeFixedSlice(buf, order, kind, target) {
+    const elemKind = kind.slice(2);
+    const width = fixedSize(elemKind, 0);
+    const count = $.len(target);
+    for (let i = 0; i < count; i++) {
+        ;
+        target[i] = decodeScalar($.goSlice(buf, i * width, i * width + width), order, elemKind);
+    }
+}
+function encodeData(order, data) {
+    const target = decodeTarget(data);
+    if (target === null) {
+        return null;
+    }
+    const size = fixedSize(target.kind, target.value);
+    if (size < 0) {
+        return null;
+    }
+    const out = $.makeSlice(size, undefined, 'byte');
+    encodeFixed(out, order, target.kind, target.value);
+    return out;
+}
+function encodeFixed(buf, order, kind, value) {
+    if (kind.startsWith('[]')) {
+        const elemKind = kind.slice(2);
+        const width = fixedSize(elemKind, 0);
+        const count = $.len(value);
+        for (let i = 0; i < count; i++) {
+            encodeScalar($.goSlice(buf, i * width, i * width + width), order, elemKind, value[i]);
+        }
+        return;
+    }
+    encodeScalar(buf, order, kind, value);
+}
+function decodeScalar(buf, order, kind) {
+    switch (kind) {
+        case 'bool':
+            return byteAt(buf, 0) !== 0;
+        case 'int8':
+            return intN(byteAt(buf, 0), 8);
+        case 'uint8':
+            return byteAt(buf, 0);
+        case 'int16':
+            return intN(order.Uint16(buf), 16);
+        case 'uint16':
+            return order.Uint16(buf);
+        case 'int32':
+            return intN(order.Uint32(buf), 32);
+        case 'uint32':
+            return order.Uint32(buf);
+        case 'int64':
+            return int64Result(toUint64(order.Uint64(buf)));
+        case 'uint64':
+            return order.Uint64(buf);
+        case 'float32':
+            return float32FromBits(order.Uint32(buf));
+        case 'float64':
+            return float64FromBits(order.Uint64(buf));
+        default:
+            return 0;
+    }
+}
+function encodeScalar(buf, order, kind, value) {
+    switch (kind) {
+        case 'bool':
+            setByte(buf, 0, value ? 1 : 0);
+            return;
+        case 'int8':
+        case 'uint8':
+            setByte(buf, 0, Number(value));
+            return;
+        case 'int16':
+        case 'uint16':
+            order.PutUint16(buf, Number(value));
+            return;
+        case 'int32':
+        case 'uint32':
+            order.PutUint32(buf, Number(value));
+            return;
+        case 'int64':
+        case 'uint64':
+            order.PutUint64(buf, value);
+            return;
+        case 'float32':
+            order.PutUint32(buf, float32Bits(Number(value)));
+            return;
+        case 'float64':
+            order.PutUint64(buf, float64Bits(Number(value)));
+            return;
+    }
+}
+function decodeTarget(data) {
+    const typeName = goTypeName(data);
+    const value = goValue(data);
+    if (typeName !== '') {
+        const kind = fixedKindFromType(typeName) ?? fixedKindFromTypeInfo(goTypeInfo(data));
+        if (kind !== null) {
+            return {
+                kind,
+                value: pointerValueForKind(typeName, value),
+                settable: setterFor(typeName, value),
+            };
+        }
+        return null;
+    }
+    if (value instanceof Uint8Array) {
+        return { kind: '[]uint8', value, settable: null };
+    }
+    if (Array.isArray(value)) {
+        if (value.every((item) => typeof item === 'boolean')) {
+            return { kind: '[]bool', value, settable: null };
+        }
+        if (value.every((item) => typeof item === 'number')) {
+            return { kind: '[]uint8', value, settable: null };
+        }
+    }
+    return null;
+}
+function pointerValueForKind(typeName, value) {
+    if (typeName.startsWith('*')) {
+        return $.pointerValue(value);
+    }
+    return value;
+}
+function setterFor(typeName, value) {
+    if (!typeName.startsWith('*')) {
+        return null;
+    }
+    if ($.isVarRef(value)) {
+        return (next) => {
+            value.value = next;
+        };
+    }
+    if (isBoxedValue(value) && $.isVarRef(value.__goValue)) {
+        const ref = value.__goValue;
+        return (next) => {
+            ref.value = next;
+        };
+    }
+    return null;
+}
+function goTypeName(value) {
+    if (isBoxedValue(value) && typeof value.__goType === 'string') {
+        return value.__goType;
+    }
+    if (value !== null &&
+        typeof value === 'object' &&
+        typeof value.__goType === 'string') {
+        return value.__goType;
+    }
+    return '';
+}
+function goTypeInfo(value) {
+    if (isBoxedValue(value)) {
+        return value.__goTypeInfo;
+    }
+    if (value !== null && typeof value === 'object') {
+        return value.__goTypeInfo;
+    }
+    return undefined;
+}
+function goValue(value) {
+    if (isBoxedValue(value) && '__goValue' in value) {
+        return value.__goValue;
+    }
+    return value;
+}
+function isBoxedValue(value) {
+    return value !== null && typeof value === 'object' && '__goValue' in value;
+}
+function fixedKindFromType(typeName) {
+    let name = typeName;
+    while (name.startsWith('*')) {
+        name = name.slice(1);
+    }
+    if (name === 'byte') {
+        return 'uint8';
+    }
+    if (name === '[]byte') {
+        return '[]uint8';
+    }
+    if (fixedKinds.has(name)) {
+        return name;
+    }
+    return null;
+}
+function fixedKindFromTypeInfo(info) {
+    if (info === undefined) {
+        return null;
+    }
+    if (typeof info === 'string') {
+        return fixedKindFromType(info);
+    }
+    switch (info.kind) {
+        case $.TypeKind.Pointer:
+            return fixedKindFromTypeInfo(info.elemType);
+        case $.TypeKind.Basic:
+            return fixedKindFromBasicName(info.name);
+        case $.TypeKind.Slice: {
+            const elemKind = fixedKindFromTypeInfo(info.elemType);
+            return elemKind === null ? null : fixedSliceKind(elemKind);
+        }
+        case $.TypeKind.Array: {
+            const elemKind = fixedKindFromTypeInfo(info.elemType);
+            return elemKind === null ? null : fixedSliceKind(elemKind);
+        }
+        default:
+            return null;
+    }
+}
+function fixedKindFromBasicName(name) {
+    if (name === undefined) {
+        return null;
+    }
+    if (name === 'byte') {
+        return 'uint8';
+    }
+    if (name === 'rune') {
+        return 'int32';
+    }
+    return fixedKinds.has(name) && !name.startsWith('[]') ?
+        name
+        : null;
+}
+function fixedSliceKind(elemKind) {
+    return elemKind.startsWith('[]') ? null : `[]${elemKind}`;
+}
+function fixedSize(kind, value) {
+    if (kind.startsWith('[]')) {
+        const elemKind = kind.slice(2);
+        const elemSize = fixedSize(elemKind, 0);
+        return elemSize < 0 ? -1 : elemSize * $.len(value);
+    }
+    switch (kind) {
+        case 'bool':
+        case 'int8':
+        case 'uint8':
+            return 1;
+        case 'int16':
+        case 'uint16':
+            return 2;
+        case 'int32':
+        case 'uint32':
+        case 'float32':
+            return 4;
+        case 'int64':
+        case 'uint64':
+        case 'float64':
+            return 8;
+    }
+    return -1;
+}
+function unsupportedError(fn, data) {
+    return $.newError(`encoding/binary: ${fn} of ${unsupportedKind(data)} is not supported in the GoScript browser build`);
+}
+function unsupportedKind(data) {
+    const typeName = goTypeName(data);
+    if (typeName !== '') {
+        return typeName;
+    }
+    if ($.isVarRef(data)) {
+        return 'untyped pointer';
+    }
+    if (Array.isArray(data)) {
+        return 'array';
+    }
+    if (data === null || data === undefined) {
+        return '<nil>';
+    }
+    return typeof data;
+}
+async function readFull(r, buf) {
+    let offset = 0;
+    while (offset < $.len(buf)) {
+        const [n, err] = await r.Read($.goSlice(buf, offset));
+        offset += n;
+        if (err !== null) {
+            return [offset, offset > 0 && isEOF(err) ? io.ErrUnexpectedEOF : err];
+        }
+        if (n === 0) {
+            return [offset, io.ErrUnexpectedEOF];
+        }
+    }
+    return [offset, null];
+}
+function requireLen(b, n) {
+    const length = $.len(b);
+    if (length < n) {
+        $.panic(`runtime error: index out of range [${n - 1}] with length ${length}`);
+    }
+}
+function byteAt(b, i) {
+    return Number(b[i]) & 0xff;
+}
+function setByte(b, i, v) {
+    requireLen(b, i + 1);
+    b[i] = Number(v) & 0xff;
+}
+function encodeSignedVarint(x) {
+    let ux = BigInt.asUintN(64, BigInt.asIntN(64, toBigInt(x)) << 1n);
+    if (isNegativeInt64(x)) {
+        ux = BigInt.asUintN(64, ~ux);
+    }
+    return uint64Result(ux);
+}
+function decodeSignedVarint(uxValue) {
+    const ux = toUint64(uxValue);
+    let x = ux >> 1n;
+    if ((ux & 1n) !== 0n) {
+        x = BigInt.asIntN(64, ~x);
+    }
+    return int64Result(x);
+}
+function toUint64(value) {
+    if (typeof value === 'bigint') {
+        return BigInt.asUintN(64, value);
+    }
+    return BigInt.asUintN(64, BigInt(Math.trunc(value)));
+}
+function toBigInt(value) {
+    if (typeof value === 'bigint') {
+        return value;
+    }
+    return BigInt(Math.trunc(value));
+}
+function isNegativeInt64(value) {
+    return typeof value === 'bigint' ? value < 0n : value < 0;
+}
+function uint64Result(value) {
+    const normalized = BigInt.asUintN(64, value);
+    if (normalized <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Number(normalized);
+    }
+    return normalized;
+}
+function int64Result(value) {
+    const normalized = BigInt.asIntN(64, value);
+    if (normalized >= BigInt(Number.MIN_SAFE_INTEGER) &&
+        normalized <= BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Number(normalized);
+    }
+    return normalized;
+}
+function intN(value, bits) {
+    const sign = 1 << (bits - 1);
+    const mask = bits === 32 ? 0xffffffff : (1 << bits) - 1;
+    const normalized = value & mask;
+    return (normalized & sign) !== 0 ? normalized - (1 << bits) : normalized;
+}
+function float32Bits(value) {
+    const bytes = new ArrayBuffer(4);
+    const view = new DataView(bytes);
+    view.setFloat32(0, value, true);
+    return view.getUint32(0, true);
+}
+function float32FromBits(value) {
+    const bytes = new ArrayBuffer(4);
+    const view = new DataView(bytes);
+    view.setUint32(0, Number($.uint(value, 32)), true);
+    return view.getFloat32(0, true);
+}
+function float64Bits(value) {
+    const bytes = new ArrayBuffer(8);
+    const view = new DataView(bytes);
+    view.setFloat64(0, value, true);
+    return view.getBigUint64(0, true);
+}
+function float64FromBits(value) {
+    const bytes = new ArrayBuffer(8);
+    const view = new DataView(bytes);
+    view.setBigUint64(0, toUint64(value), true);
+    return view.getFloat64(0, true);
+}
+function isEOF(err) {
+    return err === io.EOF || err?.Error?.() === 'EOF';
+}
+function byteSliceArg(name) {
+    return { name, type: byteSliceType() };
+}
+function numberArg(name) {
+    return { name, type: { kind: $.TypeKind.Basic, name: 'number' } };
+}
+function numberReturn() {
+    return { type: { kind: $.TypeKind.Basic, name: 'number' } };
+}
+function byteSliceType() {
+    return {
+        kind: $.TypeKind.Slice,
+        elemType: { kind: $.TypeKind.Basic, name: 'uint8' },
+    };
+}
+const fixedKinds = new Set([
+    'bool',
+    'int8',
+    'uint8',
+    'int16',
+    'uint16',
+    'int32',
+    'uint32',
+    'int64',
+    'uint64',
+    'float32',
+    'float64',
+    '[]bool',
+    '[]int8',
+    '[]uint8',
+    '[]int16',
+    '[]uint16',
+    '[]int32',
+    '[]uint32',
+    '[]int64',
+    '[]uint64',
+    '[]float32',
+    '[]float64',
+]);
+//# sourceMappingURL=index.js.map