goscript 0.0.84 → 0.1.1

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

@@ -0,0 +1,825 @@
+import * as $ from '../../../../builtin/index.js';
+import * as time from '../../../../time/index.js';
+export class JsonStream {
+    chunks = [];
+    err = null;
+    constructor(_writer) { }
+    Error() {
+        return this.err;
+    }
+    Write(p) {
+        this.chunks.push(bytesToString(p));
+        return [$.len(p), null];
+    }
+    WriteArrayEnd() {
+        this.chunks.push(']');
+    }
+    WriteArrayStart() {
+        this.chunks.push('[');
+    }
+    WriteBool(b) {
+        this.chunks.push(JSON.stringify(b));
+    }
+    WriteFloat32(f) {
+        this.WriteFloat64(f);
+    }
+    WriteFloat64(f) {
+        if (Number.isNaN(f)) {
+            this.WriteString('NaN');
+            return;
+        }
+        if (f === Infinity) {
+            this.WriteString('Infinity');
+            return;
+        }
+        if (f === -Infinity) {
+            this.WriteString('-Infinity');
+            return;
+        }
+        this.chunks.push(JSON.stringify(f));
+    }
+    WriteInt32(i) {
+        this.chunks.push(JSON.stringify(i));
+    }
+    WriteMore() {
+        this.chunks.push(',');
+    }
+    WriteNil() {
+        this.chunks.push('null');
+    }
+    WriteObjectEnd() {
+        this.chunks.push('}');
+    }
+    WriteObjectField(field) {
+        this.WriteString(field);
+        this.chunks.push(':');
+    }
+    WriteObjectStart() {
+        this.chunks.push('{');
+    }
+    WriteString(str) {
+        this.chunks.push(JSON.stringify(str));
+    }
+    WriteUint32(u) {
+        this.chunks.push(JSON.stringify(u));
+    }
+    String() {
+        return this.chunks.join('');
+    }
+}
+export class MarshalerConfig {
+    EnumsAsInts = true;
+    AnyTypeResolver = null;
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    clone() {
+        return new MarshalerConfig({
+            EnumsAsInts: this.EnumsAsInts,
+            AnyTypeResolver: this.AnyTypeResolver,
+        });
+    }
+    Marshal(m) {
+        const stream = new JsonStream();
+        const state = new MarshalState({ config: this, stream });
+        if (m == null) {
+            state.WriteNil();
+        }
+        else {
+            m.MarshalProtoJSON(state);
+        }
+        if (state.Err() != null) {
+            return [null, state.Err()];
+        }
+        return [stringToBytes(stream.String()), null];
+    }
+}
+export class UnmarshalerConfig {
+    AnyTypeResolver = null;
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    clone() {
+        return new UnmarshalerConfig({ AnyTypeResolver: this.AnyTypeResolver });
+    }
+    Unmarshal(data, m) {
+        const state = NewUnmarshalState(data, this);
+        if (state == null) {
+            return $.newError('json: failed to allocate unmarshal state');
+        }
+        m?.UnmarshalProtoJSON(state);
+        return state.Err();
+    }
+}
+export const DefaultMarshalerConfig = new MarshalerConfig();
+export const DefaultUnmarshalerConfig = new UnmarshalerConfig();
+export class MarshalState {
+    configValue;
+    stream;
+    err = null;
+    fields = new Set();
+    constructor(init) {
+        this.configValue = init?.config?.clone() ?? DefaultMarshalerConfig.clone();
+        this.stream = init?.stream ?? new JsonStream();
+    }
+    AnyTypeResolver() {
+        return this.configValue.AnyTypeResolver;
+    }
+    Config() {
+        return this.configValue.clone();
+    }
+    Err() {
+        return this.err ?? this.stream.Error();
+    }
+    HasField(field) {
+        return this.fields.has(field);
+    }
+    SetError(err) {
+        this.err = err;
+    }
+    SetErrorf(format, ...args) {
+        this.err = $.newError(formatError(format, args));
+    }
+    Sub(js) {
+        return new MarshalState({ config: this.configValue, stream: js ?? new JsonStream() });
+    }
+    WithField(field) {
+        const next = new MarshalState({ config: this.configValue, stream: this.stream });
+        next.fields = new Set(this.fields);
+        next.fields.add(field);
+        return next;
+    }
+    WithFieldMask(...paths) {
+        const next = new MarshalState({ config: this.configValue, stream: this.stream });
+        next.fields = new Set([...this.fields, ...paths]);
+        return next;
+    }
+    Write(v) {
+        return this.stream.Write(v);
+    }
+    WriteArrayEnd() {
+        this.stream.WriteArrayEnd();
+    }
+    WriteArrayStart() {
+        this.stream.WriteArrayStart();
+    }
+    WriteBool(v) {
+        this.stream.WriteBool(v);
+    }
+    WriteBoolArray(vs) {
+        this.writeArray(vs, (v) => this.WriteBool(v));
+    }
+    WriteBytes(v) {
+        this.WriteString(base64Encode(v));
+    }
+    WriteBytesArray(vs) {
+        this.writeArray(vs, (v) => this.WriteBytes(v));
+    }
+    WriteDuration(x) {
+        this.WriteString(`${x}s`);
+    }
+    WriteEnum(x, ...valueMaps) {
+        if (this.configValue.EnumsAsInts) {
+            this.WriteEnumNumber(x);
+            return;
+        }
+        this.WriteEnumString(x, ...valueMaps);
+    }
+    WriteEnumNumber(x) {
+        this.WriteInt32(x);
+    }
+    WriteEnumString(x, ...valueMaps) {
+        const value = enumStringValue(x, valueMaps);
+        if (value == null) {
+            this.WriteEnumNumber(x);
+            return;
+        }
+        this.WriteString(value);
+    }
+    WriteFieldMask(x) {
+        this.WriteString(sliceValues(x?.GetPaths()).join(','));
+    }
+    WriteFloat32(v) {
+        this.stream.WriteFloat32(v);
+    }
+    WriteFloat32Array(vs) {
+        this.writeArray(vs, (v) => this.WriteFloat32(v));
+    }
+    WriteFloat64(v) {
+        this.stream.WriteFloat64(v);
+    }
+    WriteFloat64Array(vs) {
+        this.writeArray(vs, (v) => this.WriteFloat64(v));
+    }
+    WriteInt32(v) {
+        this.stream.WriteInt32(v);
+    }
+    WriteInt32Array(vs) {
+        this.writeArray(vs, (v) => this.WriteInt32(v));
+    }
+    WriteInt64(v) {
+        this.WriteString(String(Math.trunc(v)));
+    }
+    WriteInt64Array(vs) {
+        this.writeArray(vs, (v) => this.WriteInt64(v));
+    }
+    WriteLegacyFieldMask(x) {
+        this.WriteFieldMask(x);
+    }
+    WriteMore() {
+        this.stream.WriteMore();
+    }
+    WriteMoreIf(b) {
+        const value = typeof b === 'boolean' ? b : b.value;
+        if (value) {
+            this.WriteMore();
+            return;
+        }
+        if (typeof b !== 'boolean') {
+            b.value = true;
+        }
+    }
+    WriteNil() {
+        this.stream.WriteNil();
+    }
+    WriteObjectBoolField(field) {
+        this.WriteObjectField(String(field));
+    }
+    WriteObjectEnd() {
+        this.stream.WriteObjectEnd();
+    }
+    WriteObjectField(field) {
+        this.stream.WriteObjectField(field);
+    }
+    WriteObjectInt32Field(field) {
+        this.WriteObjectField(String(Math.trunc(field)));
+    }
+    WriteObjectInt64Field(field) {
+        this.WriteObjectField(String(Math.trunc(field)));
+    }
+    WriteObjectStart() {
+        this.stream.WriteObjectStart();
+    }
+    WriteObjectStringField(field) {
+        this.WriteObjectField(field);
+    }
+    WriteObjectUint32Field(field) {
+        this.WriteObjectField(String(Math.trunc(field)));
+    }
+    WriteObjectUint64Field(field) {
+        this.WriteObjectField(String(Math.trunc(field)));
+    }
+    WriteString(v) {
+        this.stream.WriteString(v);
+    }
+    WriteStringArray(vs) {
+        this.writeArray(vs, (v) => this.WriteString(v));
+    }
+    WriteTime(x) {
+        this.WriteString($.pointerValue(x).Format(time.RFC3339Nano));
+    }
+    WriteUint32(v) {
+        this.stream.WriteUint32(v);
+    }
+    WriteUint32Array(vs) {
+        this.writeArray(vs, (v) => this.WriteUint32(v));
+    }
+    WriteUint64(v) {
+        this.WriteString(String(Math.trunc(v)));
+    }
+    WriteUint64Array(vs) {
+        this.writeArray(vs, (v) => this.WriteUint64(v));
+    }
+    writeArray(values, writeValue) {
+        this.WriteArrayStart();
+        let wrote = false;
+        for (const value of sliceValues(values)) {
+            if (wrote) {
+                this.WriteMore();
+            }
+            wrote = true;
+            writeValue(value);
+        }
+        this.WriteArrayEnd();
+    }
+}
+export class UnmarshalState {
+    configValue;
+    value;
+    root;
+    err = null;
+    fieldMaskPaths;
+    path;
+    objectEntries = null;
+    objectIndex = 0;
+    constructor(init) {
+        this.configValue = init?.config?.clone() ?? DefaultUnmarshalerConfig.clone();
+        this.value = init?.value ?? null;
+        this.root = init?.root ?? this;
+        this.fieldMaskPaths = init?.fieldMaskPaths ?? new Set();
+        this.path = init?.path ?? [];
+    }
+    AddField(field) {
+        this.fieldMaskPaths.add([...this.path, field].join('.'));
+    }
+    AnyTypeResolver() {
+        return this.configValue.AnyTypeResolver;
+    }
+    Config() {
+        return this.configValue.clone();
+    }
+    Err() {
+        return this.root.err;
+    }
+    FieldMask() {
+        const paths = Array.from(this.fieldMaskPaths);
+        return { GetPaths: () => $.arrayToSlice(paths) };
+    }
+    ReadArray(cb) {
+        if (!Array.isArray(this.value)) {
+            this.SetErrorf('expected JSON array');
+            return;
+        }
+        const original = this.value;
+        for (const item of this.value) {
+            this.value = item;
+            cb?.();
+            if (this.Err() != null) {
+                break;
+            }
+        }
+        this.value = original;
+    }
+    ReadBool() {
+        return this.value === true;
+    }
+    ReadBoolArray() {
+        return this.readArrayValues(() => this.ReadBool());
+    }
+    ReadBoolMap(cb) {
+        this.readMapKeys((key) => {
+            const parsed = parseBoolMapKey(key);
+            if (parsed == null) {
+                this.SetErrorf('invalid map key %q for bool map', key);
+                return;
+            }
+            cb?.(parsed);
+        });
+    }
+    ReadBytes() {
+        return base64Decode(this.ReadString());
+    }
+    ReadBytesArray() {
+        return this.readArrayValues(() => this.ReadBytes());
+    }
+    ReadDuration() {
+        return $.varRef(numberFromJSON(this.value));
+    }
+    ReadEnum(...valueMaps) {
+        if (typeof this.value === 'number') {
+            return Math.trunc(this.value);
+        }
+        if (typeof this.value === 'string') {
+            for (const valueMap of valueMaps) {
+                const mapped = lookupStringMap(valueMap, this.value);
+                if (mapped !== undefined) {
+                    return mapped;
+                }
+            }
+            return Math.trunc(Number(this.value) || 0);
+        }
+        return 0;
+    }
+    ReadFieldMask() {
+        const paths = typeof this.value === 'string'
+            ? this.value.split(',').filter((part) => part !== '')
+            : Array.isArray(recordValue(this.value)?.paths)
+                ? sliceValues(recordValue(this.value)?.paths)
+                : [];
+        return { GetPaths: () => $.arrayToSlice(paths) };
+    }
+    ReadFloat32() {
+        return numberFromJSON(this.value);
+    }
+    ReadFloat32Array() {
+        return this.readArrayValues(() => this.ReadFloat32());
+    }
+    ReadFloat64() {
+        return numberFromJSON(this.value);
+    }
+    ReadFloat64Array() {
+        return this.readArrayValues(() => this.ReadFloat64());
+    }
+    ReadInt32() {
+        return Math.trunc(numberFromJSON(this.value));
+    }
+    ReadInt32Array() {
+        return this.readArrayValues(() => this.ReadInt32());
+    }
+    ReadInt32Map(cb) {
+        this.readMapKeys((key) => {
+            const parsed = parseSignedMapKey(key, 32);
+            if (parsed == null) {
+                this.SetErrorf('invalid map key %q for int32 map', key);
+                return;
+            }
+            cb?.(parsed);
+        });
+    }
+    ReadInt64() {
+        return Math.trunc(numberFromJSON(this.value));
+    }
+    ReadInt64Array() {
+        return this.readArrayValues(() => this.ReadInt64());
+    }
+    ReadInt64Map(cb) {
+        this.readMapKeys((key) => {
+            const parsed = parseSignedMapKey(key, 64);
+            if (parsed == null) {
+                this.SetErrorf('invalid map key %q for int64 map', key);
+                return;
+            }
+            cb?.(parsed);
+        });
+    }
+    ReadNil() {
+        return this.value === null;
+    }
+    ReadObject(cb) {
+        const record = recordValue(this.value);
+        if (record == null) {
+            this.SetErrorf('expected JSON object');
+            return;
+        }
+        const original = this.value;
+        for (const key of Object.keys(record)) {
+            this.value = record[key];
+            cb?.(key);
+            if (this.Err() != null) {
+                break;
+            }
+        }
+        this.value = original;
+    }
+    ReadObjectField() {
+        const record = recordValue(this.value);
+        if (record == null) {
+            this.SetErrorf('expected JSON object');
+            return '';
+        }
+        if (this.objectEntries == null) {
+            this.objectEntries = Object.entries(record);
+            this.objectIndex = 0;
+        }
+        if (this.objectIndex >= this.objectEntries.length) {
+            return '';
+        }
+        const [key, value] = this.objectEntries[this.objectIndex];
+        this.objectIndex++;
+        this.value = value;
+        return key;
+    }
+    ReadString() {
+        if (typeof this.value === 'string') {
+            return this.value;
+        }
+        if (this.value == null) {
+            return '';
+        }
+        return String(this.value);
+    }
+    ReadStringArray() {
+        return this.readArrayValues(() => this.ReadString());
+    }
+    ReadStringMap(cb) {
+        this.readMapKeys((key) => cb?.(key));
+    }
+    ReadTime() {
+        const [parsed, err] = time.Parse(time.RFC3339, this.ReadString());
+        if (err != null) {
+            this.SetError(err);
+        }
+        return $.varRef($.markAsStructValue($.cloneStructValue(parsed)));
+    }
+    ReadUint32() {
+        return Math.trunc(Math.max(0, numberFromJSON(this.value)));
+    }
+    ReadUint32Array() {
+        return this.readArrayValues(() => this.ReadUint32());
+    }
+    ReadUint32Map(cb) {
+        this.readMapKeys((key) => {
+            const parsed = parseUnsignedMapKey(key, 32);
+            if (parsed == null) {
+                this.SetErrorf('invalid map key %q for uint32 map', key);
+                return;
+            }
+            cb?.(parsed);
+        });
+    }
+    ReadUint64() {
+        return this.ReadUint32();
+    }
+    ReadUint64Array() {
+        return this.readArrayValues(() => this.ReadUint64());
+    }
+    ReadUint64Map(cb) {
+        this.readMapKeys((key) => {
+            const parsed = parseUnsignedMapKey(key, 64);
+            if (parsed == null) {
+                this.SetErrorf('invalid map key %q for uint64 map', key);
+                return;
+            }
+            cb?.(parsed);
+        });
+    }
+    ReadWrappedBool() { return this.readWrapped(() => this.ReadBool()); }
+    ReadWrappedBytes() { return this.readWrapped(() => this.ReadBytes()); }
+    ReadWrappedFloat32() { return this.readWrapped(() => this.ReadFloat32()); }
+    ReadWrappedFloat64() { return this.readWrapped(() => this.ReadFloat64()); }
+    ReadWrappedInt32() { return this.readWrapped(() => this.ReadInt32()); }
+    ReadWrappedInt64() { return this.readWrapped(() => this.ReadInt64()); }
+    ReadWrappedString() { return this.readWrapped(() => this.ReadString()); }
+    ReadWrappedUint32() { return this.readWrapped(() => this.ReadUint32()); }
+    ReadWrappedUint64() { return this.readWrapped(() => this.ReadUint64()); }
+    SetError(err) {
+        this.root.err = err;
+    }
+    SetErrorf(format, ...args) {
+        this.SetError($.newError(formatError(format, args)));
+    }
+    Skip() { }
+    SkipAndAppendBytes(p) {
+        const encoded = new TextEncoder().encode(JSON.stringify(this.value));
+        return $.append(p, encoded);
+    }
+    SkipAndReturnBytes() {
+        return stringToBytes(JSON.stringify(this.value));
+    }
+    Sub(data) {
+        return NewUnmarshalState(data, this.configValue);
+    }
+    WhatIsNext() {
+        if (this.value === null) {
+            return 0;
+        }
+        if (Array.isArray(this.value)) {
+            return 1;
+        }
+        if (typeof this.value === 'object') {
+            return 2;
+        }
+        if (typeof this.value === 'string') {
+            return 3;
+        }
+        if (typeof this.value === 'number') {
+            return 4;
+        }
+        if (typeof this.value === 'boolean') {
+            return 5;
+        }
+        return 0;
+    }
+    WithField(_field, _mask = true) {
+        return new UnmarshalState({
+            config: this.configValue,
+            value: this.value,
+            root: this.root,
+            fieldMaskPaths: _mask ? this.fieldMaskPaths : new Set(),
+            path: [...this.path, _field],
+        });
+    }
+    readArrayValues(read) {
+        const values = [];
+        this.ReadArray(() => {
+            values.push(read());
+        });
+        return $.arrayToSlice(values);
+    }
+    readMapKeys(cb) {
+        const record = recordValue(this.value);
+        if (record == null) {
+            this.SetErrorf('expected JSON object');
+            return;
+        }
+        const original = this.value;
+        for (const key of Object.keys(record)) {
+            this.value = record[key];
+            cb(key);
+            if (this.Err() != null) {
+                break;
+            }
+        }
+        this.value = original;
+    }
+    readWrapped(read) {
+        const record = recordValue(this.value);
+        if (record == null) {
+            return read();
+        }
+        if (!Object.hasOwn(record, 'value')) {
+            this.SetErrorf('first field in wrapped value is not value');
+            return read();
+        }
+        const keys = Object.keys(record);
+        if (keys.length !== 1) {
+            this.SetErrorf('unexpected %q field in wrapped value', keys.find((key) => key !== 'value') ?? '');
+            return read();
+        }
+        const original = this.value;
+        this.value = record.value;
+        const value = read();
+        this.value = original;
+        return value;
+    }
+}
+export function NewJsonStream(wr) {
+    return new JsonStream(wr);
+}
+export function NewMarshalState(config, stream) {
+    return new MarshalState({ config, stream: stream ?? new JsonStream() });
+}
+export function NewUnmarshalState(data, config) {
+    try {
+        return new UnmarshalState({ config, value: JSON.parse(bytesToString(data)) });
+    }
+    catch (err) {
+        const state = new UnmarshalState({ config });
+        state.SetError($.newError(err instanceof Error ? err.message : String(err)));
+        return state;
+    }
+}
+export function Marshal(c, m) {
+    return c.Marshal(m);
+}
+export function MarshalMap(_typeArgs, c, mm) {
+    const stream = new JsonStream();
+    const state = new MarshalState({ config: c, stream });
+    state.WriteObjectStart();
+    const keys = mm instanceof Map ? Array.from(mm.keys()) : Object.keys(mm);
+    keys.sort();
+    keys.forEach((key, idx) => {
+        if (idx !== 0) {
+            state.WriteMore();
+        }
+        state.WriteObjectField(key);
+        const value = mm instanceof Map ? mm.get(key) : mm[key];
+        value?.MarshalProtoJSON(state);
+    });
+    state.WriteObjectEnd();
+    return state.Err() == null ? [stringToBytes(stream.String()), null] : [null, state.Err()];
+}
+export function MarshalSlice(_typeArgs, c, ms) {
+    const stream = new JsonStream();
+    const state = new MarshalState({ config: c, stream });
+    state.WriteArrayStart();
+    sliceValues(ms).forEach((value, idx) => {
+        if (idx !== 0) {
+            state.WriteMore();
+        }
+        value?.MarshalProtoJSON(state);
+    });
+    state.WriteArrayEnd();
+    return state.Err() == null ? [stringToBytes(stream.String()), null] : [null, state.Err()];
+}
+export function GetEnumString(x, ...valueMaps) {
+    return enumStringValue(x, valueMaps) ?? String(x);
+}
+export function ParseEnumString(v, ...valueMaps) {
+    for (const valueMap of valueMaps) {
+        const value = lookupStringMap(valueMap, v);
+        if (value !== undefined) {
+            return [value, null];
+        }
+    }
+    const parsed = Number(v);
+    return Number.isFinite(parsed) ? [parsed, null] : [0, $.newError(`invalid enum ${v}`)];
+}
+function sliceValues(values) {
+    return Array.from((values ?? []));
+}
+function bytesToString(bytes) {
+    return new TextDecoder().decode(new Uint8Array(sliceValues(bytes)));
+}
+function stringToBytes(value) {
+    return $.arrayToSlice(Array.from(new TextEncoder().encode(value)));
+}
+function recordValue(value) {
+    if (value == null || Array.isArray(value) || typeof value !== 'object') {
+        return null;
+    }
+    return value;
+}
+function numberFromJSON(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        switch (value) {
+            case 'NaN':
+                return NaN;
+            case 'Infinity':
+                return Infinity;
+            case '-Infinity':
+                return -Infinity;
+            default:
+                return Number(value) || 0;
+        }
+    }
+    return 0;
+}
+function parseBoolMapKey(key) {
+    switch (key) {
+        case 'true':
+            return true;
+        case 'false':
+            return false;
+        default:
+            return null;
+    }
+}
+function parseSignedMapKey(key, bits) {
+    if (!/^-?(0|[1-9]\d*)$/.test(key)) {
+        return null;
+    }
+    const parsed = Number(key);
+    if (!Number.isSafeInteger(parsed)) {
+        return null;
+    }
+    if (bits === 32 && (parsed < -2147483648 || parsed > 2147483647)) {
+        return null;
+    }
+    return parsed;
+}
+function parseUnsignedMapKey(key, bits) {
+    if (!/^(0|[1-9]\d*)$/.test(key)) {
+        return null;
+    }
+    const parsed = Number(key);
+    if (!Number.isSafeInteger(parsed)) {
+        return null;
+    }
+    if (bits === 32 && parsed > 4294967295) {
+        return null;
+    }
+    return parsed;
+}
+function enumStringValue(x, valueMaps) {
+    for (const valueMap of valueMaps) {
+        if (valueMap == null) {
+            continue;
+        }
+        const value = valueMap instanceof Map ? valueMap.get(x) : valueMap[x];
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return null;
+}
+function lookupStringMap(valueMap, key) {
+    if (valueMap == null) {
+        return undefined;
+    }
+    return valueMap instanceof Map ? valueMap.get(key) : valueMap[key];
+}
+function formatError(format, args) {
+    return format.replace(/%[vqsd]/g, () => String(args.shift()));
+}
+const base64Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+function base64Encode(bytes) {
+    const data = sliceValues(bytes);
+    let out = '';
+    for (let idx = 0; idx < data.length; idx += 3) {
+        const a = data[idx] ?? 0;
+        const b = data[idx + 1] ?? 0;
+        const c = data[idx + 2] ?? 0;
+        const triple = (a << 16) | (b << 8) | c;
+        out += base64Alphabet[(triple >> 18) & 0x3f];
+        out += base64Alphabet[(triple >> 12) & 0x3f];
+        out += idx + 1 < data.length ? base64Alphabet[(triple >> 6) & 0x3f] : '=';
+        out += idx + 2 < data.length ? base64Alphabet[triple & 0x3f] : '=';
+    }
+    return out;
+}
+function base64Decode(value) {
+    const normalized = value.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized + '='.repeat((4 - (normalized.length % 4)) % 4);
+    const bytes = [];
+    for (let idx = 0; idx < padded.length; idx += 4) {
+        const chars = padded.slice(idx, idx + 4);
+        const a = base64Alphabet.indexOf(chars[0]);
+        const b = base64Alphabet.indexOf(chars[1]);
+        const c = chars[2] === '=' ? 0 : base64Alphabet.indexOf(chars[2]);
+        const d = chars[3] === '=' ? 0 : base64Alphabet.indexOf(chars[3]);
+        const triple = (a << 18) | (b << 12) | (c << 6) | d;
+        bytes.push((triple >> 16) & 0xff);
+        if (chars[2] !== '=') {
+            bytes.push((triple >> 8) & 0xff);
+        }
+        if (chars[3] !== '=') {
+            bytes.push(triple & 0xff);
+        }
+    }
+    return $.arrayToSlice(bytes);
+}
+//# sourceMappingURL=index.js.map