goscript 0.1.4 → 0.2.1

package/dist/gs/github.com/aperturerobotics/protobuf-go-lite/index.js

@@ -21,6 +21,67 @@ $.registerInterfaceType('protobuf_go_lite.CloneMessage', null, [
     { name: 'Reset', args: [], returns: [] },
     { name: 'CloneMessageVT', args: [], returns: [] },
 ]);
+export function ClonePtr(v) {
+    const value = $.pointerValueOrNil(v);
+    return value == null ? null : $.varRef(value);
+}
+export function CloneBytes(v) {
+    if (v == null) {
+        return null;
+    }
+    if (v instanceof Uint8Array) {
+        return new Uint8Array(v);
+    }
+    return $.asArray(v).slice();
+}
+export function CloneSlice(s) {
+    if (s == null) {
+        return null;
+    }
+    if (s instanceof Uint8Array) {
+        return new Uint8Array(s);
+    }
+    return $.asArray(s).slice();
+}
+export function CloneMap(m) {
+    return m == null ? null : new Map(m);
+}
+export function CloneBytesSlice(s) {
+    if (s == null) {
+        return null;
+    }
+    return $.asArray(s).map((v) => CloneBytes(v));
+}
+export function CloneBytesMap(m) {
+    if (m == null) {
+        return null;
+    }
+    const out = new Map();
+    for (const [k, v] of m.entries()) {
+        out.set(k, CloneBytes(v));
+    }
+    return out;
+}
+export function CloneVTValue(v) {
+    const value = $.pointerValueOrNil(v);
+    return value == null ? null : value.CloneVT();
+}
+export function CloneVTSlice(s) {
+    if (s == null) {
+        return null;
+    }
+    return $.asArray(s).map((v) => CloneVTValue(v));
+}
+export function CloneVTMap(m) {
+    if (m == null) {
+        return null;
+    }
+    const out = new Map();
+    for (const [k, v] of m.entries()) {
+        out.set(k, CloneVTValue(v));
+    }
+    return out;
+}
 export function CompareComparable() {
     return (t1, t2) => t1 === t2;
 }
@@ -46,6 +107,387 @@ export function IsEqualVTSlice(s1, s2) {
     }
     return true;
 }
+export function EqualPtr(a, b) {
+    const av = $.pointerValueOrNil(a);
+    const bv = $.pointerValueOrNil(b);
+    return ((av == null && bv == null) ||
+        (av != null && bv != null && $.comparableEqual(av, bv)));
+}
+export function EqualBytes(a, b) {
+    if ($.len(a) !== $.len(b)) {
+        return false;
+    }
+    const aa = $.asArray(a);
+    const bb = $.asArray(b);
+    for (let i = 0; i < aa.length; i++) {
+        if (aa[i] !== bb[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function EqualBytesPresent(a, b) {
+    return ((a == null && b == null) || (a != null && b != null && EqualBytes(a, b)));
+}
+export function EqualSlice(a, b) {
+    if ($.len(a) !== $.len(b)) {
+        return false;
+    }
+    const aa = $.asArray(a);
+    const bb = $.asArray(b);
+    for (let i = 0; i < aa.length; i++) {
+        if (!$.comparableEqual(aa[i], bb[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function EqualMap(a, b) {
+    if ($.len(a) !== $.len(b)) {
+        return false;
+    }
+    for (const [k, av] of (a ?? new Map()).entries()) {
+        const [bv, ok] = $.mapGet(b, k, undefined);
+        if (!ok || !$.comparableEqual(av, bv)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function EqualBytesSlice(a, b) {
+    if ($.len(a) !== $.len(b)) {
+        return false;
+    }
+    const aa = $.asArray(a);
+    const bb = $.asArray(b);
+    for (let i = 0; i < aa.length; i++) {
+        if (!EqualBytes(aa[i], bb[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function EqualBytesMap(a, b) {
+    if ($.len(a) !== $.len(b)) {
+        return false;
+    }
+    for (const [k, av] of (a ?? new Map()).entries()) {
+        const [bv, ok] = $.mapGet(b, k, null);
+        if (!ok || !EqualBytes(av, bv)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function EqualVTImplicit(a, b, empty) {
+    let av = $.pointerValueOrNil(a);
+    let bv = $.pointerValueOrNil(b);
+    if (av === bv) {
+        return true;
+    }
+    if (av == null) {
+        av = empty();
+    }
+    if (bv == null) {
+        bv = empty();
+    }
+    return av.EqualVT(bv);
+}
+export function EqualVTSliceImplicit(a, b, empty) {
+    if ($.len(a) !== $.len(b)) {
+        return false;
+    }
+    const aa = $.asArray(a);
+    const bb = $.asArray(b);
+    for (let i = 0; i < aa.length; i++) {
+        if (!EqualVTImplicit(aa[i], bb[i], empty)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function EqualVTMapImplicit(a, b, empty) {
+    if ($.len(a) !== $.len(b)) {
+        return false;
+    }
+    for (const [k, av] of (a ?? new Map()).entries()) {
+        const [bv, ok] = $.mapGet(b, k, null);
+        if (!ok || !EqualVTImplicit(av, bv, empty)) {
+            return false;
+        }
+    }
+    return true;
+}
+const protobufScalarTypeBytes = 12;
+function boundMessageType(ctor) {
+    const messageType = ctor.__protobufTypeScriptMessage;
+    if (messageType == null) {
+        throw new Error('protobuf TypeScript binding is missing message type');
+    }
+    return messageType;
+}
+function resolveBoundMessageType(value) {
+    return typeof value === 'function' ? value() : value;
+}
+function boundFieldGoName(field) {
+    if (field.localName.length === 0) {
+        return field.localName;
+    }
+    return field.localName[0].toUpperCase() + field.localName.slice(1);
+}
+function boundFieldValue(source, field) {
+    if (source == null) {
+        return undefined;
+    }
+    const local = source[field.localName];
+    if (local !== undefined) {
+        return local;
+    }
+    return source[boundFieldGoName(field)];
+}
+function toTypeScriptScalarValue(value, field) {
+    const unwrapped = $.pointerValueOrNil(value);
+    if (field?.kind === 'scalar' &&
+        field.T === protobufScalarTypeBytes &&
+        unwrapped != null &&
+        !(unwrapped instanceof Uint8Array)) {
+        return Uint8Array.from($.asArray(unwrapped));
+    }
+    if (unwrapped instanceof Uint8Array) {
+        return unwrapped;
+    }
+    return unwrapped;
+}
+function toTypeScriptFieldValue(field, value, ctor) {
+    value = $.pointerValueOrNil(value);
+    if (value == null) {
+        return undefined;
+    }
+    if (field.repeated) {
+        return $.asArray(value).map((item) => toTypeScriptFieldValue({ ...field, repeated: false }, item, ctor));
+    }
+    if (field.kind === 'map') {
+        const out = {};
+        const valueInfo = field.V;
+        const entries = value instanceof Map ? Array.from(value.entries()) : Object.entries(value);
+        for (const [key, item] of entries) {
+            out[String(key)] =
+                valueInfo != null ?
+                    toTypeScriptFieldValue(valueInfo, item, ctor)
+                    : toTypeScriptScalarValue(item);
+        }
+        return out;
+    }
+    if (field.kind === 'message') {
+        const messageType = resolveBoundMessageType(field.T);
+        return toTypeScriptMessage(value, messageType, ctor);
+    }
+    return toTypeScriptScalarValue(value, field);
+}
+function toTypeScriptMessage(value, messageType, ctor) {
+    value = $.pointerValueOrNil(value);
+    if (value == null) {
+        return undefined;
+    }
+    const fields = messageType.fields?.list();
+    if (fields == null) {
+        return value;
+    }
+    const fieldCtors = ctor?.__protobufTypeScriptFields ?? {};
+    const out = {};
+    for (const field of fields) {
+        if (field.oneof != null) {
+            continue;
+        }
+        const raw = boundFieldValue(value, field);
+        if (raw === undefined || raw === null) {
+            continue;
+        }
+        out[field.localName] = toTypeScriptFieldValue(field, raw, fieldCtors[field.localName]);
+    }
+    return out;
+}
+function fromTypeScriptScalarValue(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    return value;
+}
+function fromTypeScriptFieldValue(field, value, ctor) {
+    if (value == null) {
+        return null;
+    }
+    if (field.repeated) {
+        return $.arrayToSlice(value.map((item) => fromTypeScriptFieldValue({ ...field, repeated: false }, item, ctor)));
+    }
+    if (field.kind === 'map') {
+        const valueInfo = field.V;
+        const out = new Map();
+        for (const [key, item] of Object.entries(value)) {
+            out.set(key, valueInfo != null ?
+                fromTypeScriptFieldValue(valueInfo, item, ctor)
+                : fromTypeScriptScalarValue(item));
+        }
+        return out;
+    }
+    if (field.kind === 'message') {
+        const messageType = resolveBoundMessageType(field.T);
+        if (ctor == null) {
+            return value;
+        }
+        return fromTypeScriptMessage(value, ctor, messageType);
+    }
+    return fromTypeScriptScalarValue(value);
+}
+function fromTypeScriptWellKnownMessage(value, ctor, messageType) {
+    if (messageType?.typeName === 'google.protobuf.Timestamp' &&
+        value instanceof Date) {
+        const ms = value.getTime();
+        const seconds = Math.floor(ms / 1000);
+        const nanos = Math.trunc((ms - seconds * 1000) * 1000000);
+        return new ctor({ Seconds: seconds, Nanos: nanos });
+    }
+    return undefined;
+}
+function fromTypeScriptMessage(value, ctor, messageType) {
+    if (value == null) {
+        return null;
+    }
+    const wellKnown = fromTypeScriptWellKnownMessage(value, ctor, messageType);
+    if (wellKnown !== undefined) {
+        return wellKnown;
+    }
+    const out = new ctor();
+    const fields = (messageType ?? boundMessageType(ctor)).fields?.list();
+    if (fields == null) {
+        return Object.assign(out, value);
+    }
+    const fieldCtors = ctor.__protobufTypeScriptFields ?? {};
+    for (const field of fields) {
+        if (field.oneof != null) {
+            continue;
+        }
+        const raw = value[field.localName];
+        if (raw === undefined || raw === null) {
+            continue;
+        }
+        out[boundFieldGoName(field)] = fromTypeScriptFieldValue(field, raw, fieldCtors[field.localName]);
+    }
+    return out;
+}
+export function CloneBoundMessage(ctor, value) {
+    const messageType = boundMessageType(ctor);
+    const encoded = toTypeScriptMessage(value, messageType, ctor);
+    const cloned = messageType.clone?.(encoded) ?? structuredClone(encoded);
+    return fromTypeScriptMessage(cloned, ctor, messageType);
+}
+export function EqualBoundMessage(ctor, a, b) {
+    const messageType = boundMessageType(ctor);
+    const left = toTypeScriptMessage(a, messageType, ctor);
+    const right = toTypeScriptMessage(b, messageType, ctor);
+    return (messageType.equals?.(left, right) ??
+        JSON.stringify(left) === JSON.stringify(right));
+}
+export function MarshalBoundMessageVT(ctor, value) {
+    let typeName = ctor.name;
+    try {
+        const messageType = boundMessageType(ctor);
+        typeName = messageType.typeName ?? typeName;
+        return [
+            messageType.toBinary(toTypeScriptMessage(value, messageType, ctor)),
+            null,
+        ];
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return [null, $.toGoError(new Error(`marshal ${typeName}: ${msg}`))];
+    }
+}
+export function MarshalBoundMessageToSizedBufferVT(ctor, value, dAtA) {
+    const [bytes, err] = MarshalBoundMessageVT(ctor, value);
+    if (err != null) {
+        return [0, err];
+    }
+    const byteCount = $.len(bytes);
+    const offset = $.len(dAtA) - byteCount;
+    const src = $.asArray(bytes);
+    for (let i = 0; i < src.length; i++) {
+        ;
+        dAtA[offset + i] = src[i];
+    }
+    return [byteCount, null];
+}
+export function SizeBoundMessageVT(ctor, value) {
+    const [bytes, err] = MarshalBoundMessageVT(ctor, value);
+    return err == null ? $.len(bytes) : 0;
+}
+export function UnmarshalBoundMessageVT(ctor, target, data) {
+    try {
+        const messageType = boundMessageType(ctor);
+        const decoded = messageType.fromBinary(Uint8Array.from($.asArray(data)));
+        const next = fromTypeScriptMessage(decoded, ctor, messageType);
+        $.assignStruct($.pointerValue(target), $.markAsStructValue(next));
+        return null;
+    }
+    catch (err) {
+        return $.toGoError(err);
+    }
+}
+export function MarshalBoundMessageJSON(ctor, value) {
+    try {
+        const messageType = boundMessageType(ctor);
+        const encoded = toTypeScriptMessage(value, messageType, ctor);
+        const json = messageType.toJsonString?.(encoded) ??
+            JSON.stringify(messageType.toJson?.(encoded) ?? encoded);
+        return [$.stringToBytes(json), null];
+    }
+    catch (err) {
+        return [null, $.toGoError(err)];
+    }
+}
+export function UnmarshalBoundMessageJSON(ctor, target, data) {
+    try {
+        const messageType = boundMessageType(ctor);
+        const text = $.bytesToString(data);
+        const decoded = messageType.fromJsonString?.(text) ??
+            messageType.fromJson?.(JSON.parse(text));
+        const next = fromTypeScriptMessage(decoded, ctor, messageType);
+        $.assignStruct($.pointerValue(target), $.markAsStructValue(next));
+        return null;
+    }
+    catch (err) {
+        return $.toGoError(err);
+    }
+}
+export function MarshalBoundMessageProtoJSON(ctor, value, state) {
+    if (state == null) {
+        return;
+    }
+    const [data, err] = MarshalBoundMessageJSON(ctor, value);
+    if (err != null) {
+        state.SetError(err);
+        return;
+    }
+    state.Write(data);
+}
+export function UnmarshalBoundMessageProtoJSON(ctor, target, state) {
+    if (state == null) {
+        return;
+    }
+    try {
+        const messageType = boundMessageType(ctor);
+        const decoded = messageType.fromJson?.(state.value);
+        const next = fromTypeScriptMessage(decoded, ctor, messageType);
+        $.assignStruct($.pointerValue(target), $.markAsStructValue(next));
+    }
+    catch (err) {
+        state.SetError($.toGoError(err));
+    }
+}
+export function MarshalBoundMessageProtoText(ctor, value) {
+    const [data, err] = MarshalBoundMessageJSON(ctor, value);
+    return err == null ? $.bytesToString(data) : err.Error();
+}
 export function EncodeVarint(dAtA, offset, v) {
     offset -= SizeOfVarint(v);
     const base = offset;
@@ -96,6 +538,153 @@ export function SizeOfVarint(x) {
     }
     return n;
 }
+export function SizeOfZigzag(x) {
+    const value = typeof x === 'bigint' ?
+        BigInt.asIntN(64, x)
+        : BigInt.asIntN(64, BigInt(Math.trunc(x)));
+    return SizeOfVarint(BigInt.asUintN(64, (value << 1n) ^ (value >> 63n)));
+}
+export function SizeVarintValue(keySize, v) {
+    return keySize + SizeOfVarint(v);
+}
+export function SizeVarintNonZero(keySize, v) {
+    return normalizedVarint(v) === 0n ? 0 : SizeVarintValue(keySize, v);
+}
+export function SizeVarintPtr(keySize, v) {
+    const value = $.pointerValueOrNil(v);
+    return value == null ? 0 : SizeVarintValue(keySize, value);
+}
+export function SizeVarintSlice(keySize, vals) {
+    let n = 0;
+    for (const v of vals ?? []) {
+        n += SizeVarintValue(keySize, v);
+    }
+    return n;
+}
+export function SizeVarintPacked(keySize, vals) {
+    if ($.len(vals) === 0) {
+        return 0;
+    }
+    let l = 0;
+    for (const v of vals ?? []) {
+        l += SizeOfVarint(v);
+    }
+    return SizeBytesValue(keySize, l);
+}
+export function SizeZigzagValue(keySize, v) {
+    return keySize + SizeOfZigzag(v);
+}
+export function SizeZigzagNonZero(keySize, v) {
+    return BigInt.asIntN(64, normalizedVarint(v)) === 0n ?
+        0
+        : SizeZigzagValue(keySize, v);
+}
+export function SizeZigzagPtr(keySize, v) {
+    const value = $.pointerValueOrNil(v);
+    return value == null ? 0 : SizeZigzagValue(keySize, value);
+}
+export function SizeZigzagSlice(keySize, vals) {
+    let n = 0;
+    for (const v of vals ?? []) {
+        n += SizeZigzagValue(keySize, v);
+    }
+    return n;
+}
+export function SizeZigzagPacked(keySize, vals) {
+    if ($.len(vals) === 0) {
+        return 0;
+    }
+    let l = 0;
+    for (const v of vals ?? []) {
+        l += SizeOfZigzag(v);
+    }
+    return SizeBytesValue(keySize, l);
+}
+export function SizeFixed32Value(keySize) {
+    return keySize + 4;
+}
+export function SizeFixed32NonZero(keySize, v) {
+    return v === 0 ? 0 : SizeFixed32Value(keySize);
+}
+export function SizeFixed32Ptr(keySize, v) {
+    return $.pointerValueOrNil(v) == null ? 0 : SizeFixed32Value(keySize);
+}
+export function SizeFixed32Slice(keySize, vals) {
+    return $.len(vals) * SizeFixed32Value(keySize);
+}
+export function SizeFixed32Packed(keySize, vals) {
+    return $.len(vals) === 0 ? 0 : SizeBytesValue(keySize, $.len(vals) * 4);
+}
+export function SizeFixed64Value(keySize) {
+    return keySize + 8;
+}
+export function SizeFixed64NonZero(keySize, v) {
+    return v === 0 || v === 0n ? 0 : SizeFixed64Value(keySize);
+}
+export function SizeFixed64Ptr(keySize, v) {
+    return $.pointerValueOrNil(v) == null ? 0 : SizeFixed64Value(keySize);
+}
+export function SizeFixed64Slice(keySize, vals) {
+    return $.len(vals) * SizeFixed64Value(keySize);
+}
+export function SizeFixed64Packed(keySize, vals) {
+    return $.len(vals) === 0 ? 0 : SizeBytesValue(keySize, $.len(vals) * 8);
+}
+export function SizeBoolValue(keySize) {
+    return keySize + 1;
+}
+export function SizeBoolNonZero(keySize, v) {
+    return v ? SizeBoolValue(keySize) : 0;
+}
+export function SizeBoolPtr(keySize, v) {
+    return $.pointerValueOrNil(v) == null ? 0 : SizeBoolValue(keySize);
+}
+export function SizeBoolSlice(keySize, vals) {
+    return $.len(vals) * SizeBoolValue(keySize);
+}
+export function SizeBoolPacked(keySize, vals) {
+    return $.len(vals) === 0 ? 0 : SizeBytesValue(keySize, $.len(vals));
+}
+export function SizeStringValue(keySize, v) {
+    const l = $.len(v);
+    return keySize + l + SizeOfVarint(l);
+}
+export function SizeStringNonEmpty(keySize, v) {
+    return $.len(v) === 0 ? 0 : SizeStringValue(keySize, v);
+}
+export function SizeStringPtr(keySize, v) {
+    const value = $.pointerValueOrNil(v);
+    return value == null ? 0 : SizeStringValue(keySize, value);
+}
+export function SizeStringSlice(keySize, vals) {
+    let n = 0;
+    for (const v of vals ?? []) {
+        n += SizeStringValue(keySize, v);
+    }
+    return n;
+}
+export function SizeBytesValue(keySize, l) {
+    return keySize + l + SizeOfVarint(l);
+}
+export function SizeBytesNonEmpty(keySize, v) {
+    return $.len(v) === 0 ? 0 : SizeBytesValue(keySize, $.len(v));
+}
+export function SizeBytesPresent(keySize, v) {
+    return v == null ? 0 : SizeBytesValue(keySize, $.len(v));
+}
+export function SizeBytesSlice(keySize, vals) {
+    let n = 0;
+    for (const v of vals ?? []) {
+        n += SizeBytesValue(keySize, $.len(v));
+    }
+    return n;
+}
+export function SizeMessage(keySize, msgSize) {
+    return SizeBytesValue(keySize, msgSize);
+}
+export function SizeGroup(keySize, msgSize) {
+    return msgSize + 2 * keySize;
+}
 function normalizedVarint(value) {
     if (typeof value === 'bigint') {
         return BigInt.asUintN(64, value);