goscript 0.2.4 → 0.2.5

package/dist/gs/golang.org/x/crypto/cryptobyte/index.js

@@ -0,0 +1,1107 @@
+import * as $ from '@goscript/builtin/index.js';
+import * as asn1 from '@goscript/golang.org/x/crypto/cryptobyte/asn1/index.js';
+import * as time from '@goscript/time/index.js';
+const maxUint64 = (1n << 64n) - 1n;
+const maxInt64 = (1n << 63n) - 1n;
+const minInt64 = -(1n << 63n);
+function byte(value) {
+    if (typeof value === 'bigint') {
+        return Number(BigInt.asUintN(8, value));
+    }
+    return Number(value) & 0xff;
+}
+function bytesArray(bytes) {
+    if (bytes == null) {
+        return [];
+    }
+    if (typeof bytes === 'string') {
+        return Array.from(bytes, (ch) => ch.charCodeAt(0) & 0xff);
+    }
+    return Array.from($.bytesToUint8Array(bytes));
+}
+function bytesFromArray(bytes) {
+    return new Uint8Array(bytes.map(byte));
+}
+function bytesFromString(value) {
+    return new Uint8Array(Array.from(value, (ch) => ch.charCodeAt(0) & 0xff));
+}
+function bytesToAscii(bytes) {
+    return globalThis.String.fromCharCode(...bytesArray(bytes));
+}
+function stringValue(s) {
+    if (s == null) {
+        throw new Error('runtime error: invalid memory address or nil pointer dereference');
+    }
+    return s.value;
+}
+function read(s, n) {
+    const data = stringValue(s);
+    if ($.len(data) < n) {
+        return null;
+    }
+    const out = $.goSlice(data, 0, n);
+    s.value = $.goSlice(data, n);
+    return out;
+}
+function readUint(bytes) {
+    let out = 0;
+    for (const b of bytesArray(bytes)) {
+        out = out * 256 + b;
+    }
+    return out;
+}
+function readUint64Value(bytes) {
+    let out = 0n;
+    for (const b of bytesArray(bytes)) {
+        out = (out << 8n) | BigInt(b);
+    }
+    return $.uint(out, 64);
+}
+function writeRef(out, value) {
+    if (out == null) {
+        throw new Error('runtime error: invalid memory address or nil pointer dereference');
+    }
+    out.value = value;
+}
+export function String_Skip(s, n) {
+    return read(s, n) !== null;
+}
+export function String_ReadUint8(s, out) {
+    const v = read(s, 1);
+    if (v == null) {
+        return false;
+    }
+    writeRef(out, bytesArray(v)[0]);
+    return true;
+}
+export function String_ReadUint16(s, out) {
+    const v = read(s, 2);
+    if (v == null) {
+        return false;
+    }
+    writeRef(out, readUint(v));
+    return true;
+}
+export function String_ReadUint24(s, out) {
+    const v = read(s, 3);
+    if (v == null) {
+        return false;
+    }
+    writeRef(out, readUint(v));
+    return true;
+}
+export function String_ReadUint32(s, out) {
+    const v = read(s, 4);
+    if (v == null) {
+        return false;
+    }
+    writeRef(out, $.uint(readUint(v), 32));
+    return true;
+}
+export function String_ReadUint48(s, out) {
+    const v = read(s, 6);
+    if (v == null) {
+        return false;
+    }
+    writeRef(out, readUint(v));
+    return true;
+}
+export function String_ReadUint64(s, out) {
+    const v = read(s, 8);
+    if (v == null) {
+        return false;
+    }
+    writeRef(out, readUint64Value(v));
+    return true;
+}
+function readLengthPrefixed(s, lenLen, out) {
+    const data = stringValue(s);
+    if ($.len(data) < lenLen) {
+        return false;
+    }
+    const length = readUint($.goSlice(data, 0, lenLen));
+    if ($.len(data) < lenLen + length) {
+        return false;
+    }
+    writeRef(out, $.goSlice(data, lenLen, lenLen + length));
+    s.value = $.goSlice(data, lenLen + length);
+    return true;
+}
+export function String_ReadUint8LengthPrefixed(s, out) {
+    return readLengthPrefixed(s, 1, out);
+}
+export function String_ReadUint16LengthPrefixed(s, out) {
+    return readLengthPrefixed(s, 2, out);
+}
+export function String_ReadUint24LengthPrefixed(s, out) {
+    return readLengthPrefixed(s, 3, out);
+}
+export function String_ReadBytes(s, out, n) {
+    const v = read(s, n);
+    if (v == null) {
+        return false;
+    }
+    writeRef(out, v);
+    return true;
+}
+export function String_CopyBytes(s, out) {
+    if ($.len(out) > $.len(stringValue(s))) {
+        return false;
+    }
+    const v = read(s, $.len(out));
+    if (v == null) {
+        return false;
+    }
+    $.copy(out, v);
+    return true;
+}
+export function String_Empty(s) {
+    return $.len(s) === 0;
+}
+export class BuildError {
+    Err;
+    constructor(init) {
+        this.Err = init?.Err ?? null;
+    }
+    Error() {
+        return this.Err == null ? '' : this.Err.Error();
+    }
+}
+export class Builder {
+    err;
+    result;
+    fixedSize;
+    capacityLimit;
+    child;
+    offset;
+    pendingLenLen;
+    pendingIsASN1;
+    constructor(init) {
+        this.err = init?.err ?? null;
+        this.result = init?.resultArray ?? bytesArray(init?.result);
+        this.fixedSize = init?.fixedSize ?? false;
+        this.capacityLimit =
+            init?.capacityLimit ?? (init?.result == null ? this.result.length : $.cap(init.result));
+        this.child = null;
+        this.offset = 0;
+        this.pendingLenLen = 0;
+        this.pendingIsASN1 = false;
+    }
+    SetError(err) {
+        if (this.err == null) {
+            this.err = err;
+        }
+    }
+    Bytes() {
+        this.flushChild();
+        if (this.err != null) {
+            return [null, this.err];
+        }
+        if (this.fixedSize && this.result.length !== this.capacityLimit) {
+            return [null, $.newError('cryptobyte: Builder is not full')];
+        }
+        return [bytesFromArray(this.result), null];
+    }
+    BytesOrPanic() {
+        const [bytes, err] = this.Bytes();
+        if (err != null) {
+            $.panic(new BuildError({ Err: err }));
+        }
+        return bytes;
+    }
+    AddUint8(v) {
+        this.add(byte(v));
+    }
+    AddUint16(v) {
+        this.add(byte(v >> 8), byte(v));
+    }
+    AddUint24(v) {
+        this.add(byte(v >> 16), byte(v >> 8), byte(v));
+    }
+    AddUint32(v) {
+        this.add(byte(v / 0x1000000), byte(v >> 16), byte(v >> 8), byte(v));
+    }
+    AddUint48(v) {
+        this.add(byte(Math.floor(v / 0x10000000000)), byte(Math.floor(v / 0x100000000)), byte(v >> 24), byte(v >> 16), byte(v >> 8), byte(v));
+    }
+    AddUint64(v) {
+        let value = toUint64BigInt(v);
+        const out = new Array(8);
+        for (let i = 7; i >= 0; i--) {
+            out[i] = byte(value);
+            value >>= 8n;
+        }
+        this.add(...out);
+    }
+    AddBytes(v) {
+        this.add(...bytesArray(v));
+    }
+    AddUint8LengthPrefixed(f) {
+        this.addLengthPrefixed(1, false, f);
+    }
+    AddUint16LengthPrefixed(f) {
+        this.addLengthPrefixed(2, false, f);
+    }
+    AddUint24LengthPrefixed(f) {
+        this.addLengthPrefixed(3, false, f);
+    }
+    AddUint32LengthPrefixed(f) {
+        this.addLengthPrefixed(4, false, f);
+    }
+    AddValue(v) {
+        if (v == null) {
+            this.SetError($.newError('cryptobyte: nil MarshalingValue'));
+            return;
+        }
+        this.SetError(v.Marshal(this));
+    }
+    Unwrite(n) {
+        this.flushChild();
+        if (this.err != null) {
+            return;
+        }
+        if (n < 0 || n > this.result.length) {
+            this.SetError($.newError('cryptobyte: invalid Unwrite'));
+            return;
+        }
+        this.result.length -= n;
+    }
+    AddASN1Int64(v) {
+        this.AddASN1Int64WithTag(v, asn1.INTEGER);
+    }
+    AddASN1Int64WithTag(v, tag) {
+        this.addASN1Signed(BigInt(Math.trunc(v)), tag);
+    }
+    AddASN1Enum(v) {
+        this.addASN1Signed(BigInt(Math.trunc(v)), asn1.ENUM);
+    }
+    AddASN1Uint64(v) {
+        this.AddASN1(asn1.INTEGER, (child) => {
+            child.add(...encodeASN1Unsigned(toUint64BigInt(v)));
+        });
+    }
+    AddASN1BigInt(n) {
+        const value = bigIntValue(n);
+        this.AddASN1(asn1.INTEGER, (child) => {
+            child.add(...encodeASN1Signed(value));
+        });
+    }
+    AddASN1OctetString(bytes) {
+        this.AddASN1(asn1.OCTET_STRING, (child) => {
+            child.AddBytes(bytes);
+        });
+    }
+    AddASN1GeneralizedTime(t) {
+        const value = $.pointerValue(t);
+        this.AddASN1(asn1.GeneralizedTime, (child) => {
+            child.AddBytes(bytesFromString(value.Format('20060102150405Z0700')));
+        });
+    }
+    AddASN1UTCTime(t) {
+        const value = $.pointerValue(t);
+        this.AddASN1(asn1.UTCTime, (child) => {
+            child.AddBytes(bytesFromString(value.Format('060102150405Z0700')));
+        });
+    }
+    AddASN1BitString(bitString) {
+        const value = pointerValueOrBox(bitString);
+        if (value == null) {
+            this.SetError($.newError('cryptobyte: nil BitString'));
+            return;
+        }
+        const bytes = value.Bytes ?? null;
+        const bitLength = Math.trunc(value.BitLength ?? 0);
+        const paddingBits = (8 - (bitLength % 8)) % 8;
+        if ((bytes == null && bitLength !== 0) ||
+            $.len(bytes) * 8 - paddingBits !== bitLength) {
+            this.SetError($.newError('cryptobyte: invalid BitString'));
+            return;
+        }
+        this.AddASN1(asn1.BIT_STRING, (child) => {
+            child.AddUint8(paddingBits);
+            child.AddBytes(bytes ?? new Uint8Array(0));
+        });
+    }
+    AddASN1ObjectIdentifier(oid) {
+        if (oid == null || $.len(oid) < 2) {
+            this.SetError($.newError('cryptobyte: invalid OID'));
+            return;
+        }
+        const first = Number(oid[0]);
+        const second = Number(oid[1]);
+        if (first > 2 || second >= 40 && first < 2) {
+            this.SetError($.newError('cryptobyte: invalid OID'));
+            return;
+        }
+        this.AddASN1(asn1.OBJECT_IDENTIFIER, (child) => {
+            child.addBase128Int(first * 40 + second);
+            for (let i = 2; i < $.len(oid); i++) {
+                child.addBase128Int(Number(oid[i]));
+            }
+        });
+    }
+    AddASN1Boolean(v) {
+        this.AddASN1(asn1.BOOLEAN, (child) => {
+            child.AddUint8(v ? 0xff : 0);
+        });
+    }
+    AddASN1NULL() {
+        this.add(asn1.NULL, 0);
+    }
+    MarshalASN1(_v) {
+        this.SetError($.newError('cryptobyte: MarshalASN1 is not supported in the js build'));
+    }
+    AddASN1(tag, f) {
+        this.add(byte(tag));
+        this.addLengthPrefixed(1, true, f);
+    }
+    addASN1Signed(v, tag) {
+        this.AddASN1(tag, (child) => {
+            child.add(...encodeASN1Signed(v));
+        });
+    }
+    addBase128Int(v) {
+        if (v < 0) {
+            this.SetError($.newError('cryptobyte: negative OID component'));
+            return;
+        }
+        const out = [byte(v)];
+        v = Math.floor(v / 128);
+        while (v > 0) {
+            out.unshift(byte(v) | 0x80);
+            v = Math.floor(v / 128);
+        }
+        this.add(...out);
+    }
+    addLengthPrefixed(lenLen, isASN1, f) {
+        this.flushChild();
+        if (this.err != null) {
+            return;
+        }
+        this.offset = this.result.length;
+        this.pendingLenLen = lenLen;
+        this.pendingIsASN1 = isASN1;
+        this.add(...new Array(lenLen).fill(0));
+        const child = new Builder({
+            err: this.err,
+            resultArray: this.result,
+            fixedSize: this.fixedSize,
+            capacityLimit: this.capacityLimit,
+        });
+        this.child = child;
+        try {
+            f?.(child);
+        }
+        catch (err) {
+            const value = $.panicValue(err);
+            if (value instanceof BuildError) {
+                this.SetError(value.Err);
+            }
+            else {
+                throw err;
+            }
+        }
+        if (this.child === child) {
+            this.flushChild();
+        }
+    }
+    flushChild() {
+        if (this.child == null) {
+            return;
+        }
+        if (this.err == null && this.child.err != null) {
+            this.err = this.child.err;
+        }
+        const offset = this.offset;
+        const lenLen = this.pendingLenLen;
+        const childStart = offset + lenLen;
+        const length = this.result.length - childStart;
+        if (this.err == null) {
+            if (this.pendingIsASN1) {
+                this.flushASN1Length(offset, length);
+            }
+            else {
+                const max = 1n << BigInt(lenLen * 8);
+                if (BigInt(length) >= max) {
+                    this.SetError($.newError('cryptobyte: length prefix overflow'));
+                }
+                else {
+                    for (let i = lenLen - 1, value = length; i >= 0; i--) {
+                        this.result[offset + i] = byte(value);
+                        value = Math.floor(value / 256);
+                    }
+                }
+            }
+        }
+        this.child = null;
+    }
+    flushASN1Length(offset, length) {
+        if (length <= 127) {
+            this.result[offset] = length;
+            return;
+        }
+        const encoded = encodeASN1Length(length);
+        const extra = encoded.length - 1;
+        this.result.push(...new Array(extra).fill(0));
+        for (let i = this.result.length - extra - 1; i > offset; i--) {
+            this.result[i + extra] = this.result[i];
+        }
+        for (let i = 0; i < encoded.length; i++) {
+            this.result[offset + i] = encoded[i];
+        }
+    }
+    add(...bytes) {
+        this.flushChild();
+        if (this.err != null) {
+            return;
+        }
+        if (this.fixedSize && this.result.length + bytes.length > this.capacityLimit) {
+            this.SetError($.newError('cryptobyte: Builder is exceeding its fixed-size buffer'));
+            return;
+        }
+        this.result.push(...bytes.map(byte));
+    }
+}
+export function NewBuilder(buffer) {
+    return new Builder({ result: buffer ?? new Uint8Array(0), fixedSize: false });
+}
+export function NewFixedBuilder(buffer) {
+    return new Builder({
+        result: new Uint8Array(0),
+        fixedSize: true,
+        capacityLimit: $.cap(buffer),
+    });
+}
+function encodeASN1Length(length) {
+    if (length <= 127) {
+        return [length];
+    }
+    const out = [];
+    let value = length;
+    while (value > 0) {
+        out.unshift(byte(value));
+        value = Math.floor(value / 256);
+    }
+    return [0x80 | out.length, ...out];
+}
+function encodeASN1Unsigned(value) {
+    if (value < 0n || value > maxUint64) {
+        return [];
+    }
+    const out = unsignedBytes(value);
+    if (out.length === 0) {
+        return [0];
+    }
+    if ((out[0] & 0x80) !== 0) {
+        out.unshift(0);
+    }
+    return out;
+}
+function encodeASN1Signed(value) {
+    if (value >= 0n) {
+        const out = unsignedBytes(value);
+        if (out.length === 0) {
+            return [0];
+        }
+        if ((out[0] & 0x80) !== 0) {
+            out.unshift(0);
+        }
+        return out;
+    }
+    let byteLen = 1;
+    while (value < -(1n << BigInt(byteLen * 8 - 1))) {
+        byteLen++;
+    }
+    const mod = 1n << BigInt(byteLen * 8);
+    return fixedUnsignedBytes(mod + value, byteLen);
+}
+function unsignedBytes(value) {
+    if (value === 0n) {
+        return [];
+    }
+    const out = [];
+    while (value > 0n) {
+        out.unshift(byte(value));
+        value >>= 8n;
+    }
+    return out;
+}
+function fixedUnsignedBytes(value, byteLen) {
+    const out = new Array(byteLen);
+    for (let i = byteLen - 1; i >= 0; i--) {
+        out[i] = byte(value);
+        value >>= 8n;
+    }
+    return out;
+}
+function toUint64BigInt(value) {
+    if (typeof value === 'bigint') {
+        return BigInt.asUintN(64, value);
+    }
+    if (Number.isSafeInteger(value) && value >= 0) {
+        return BigInt(value);
+    }
+    return BigInt.asUintN(64, BigInt(Math.trunc(value)));
+}
+function signedBigInt(bytes) {
+    const arr = bytesArray(bytes);
+    let value = 0n;
+    for (const b of arr) {
+        value = (value << 8n) | BigInt(b);
+    }
+    if (arr.length > 0 && (arr[0] & 0x80) !== 0) {
+        value -= 1n << BigInt(arr.length * 8);
+    }
+    return value;
+}
+function unsignedBigInt(bytes) {
+    let value = 0n;
+    for (const b of bytesArray(bytes)) {
+        value = (value << 8n) | BigInt(b);
+    }
+    return value;
+}
+function checkASN1Integer(bytes) {
+    const arr = bytesArray(bytes);
+    if (arr.length === 0) {
+        return false;
+    }
+    if (arr.length === 1) {
+        return true;
+    }
+    if (arr[0] === 0 && (arr[1] & 0x80) === 0) {
+        return false;
+    }
+    if (arr[0] === 0xff && (arr[1] & 0x80) === 0x80) {
+        return false;
+    }
+    return true;
+}
+function boxedTypeName(value) {
+    if (value !== null && typeof value === 'object' && '__goType' in value) {
+        return globalThis.String(value.__goType ?? '');
+    }
+    return '';
+}
+function boxedValue(value) {
+    if (value !== null && typeof value === 'object' && '__goValue' in value) {
+        return value.__goValue;
+    }
+    return value;
+}
+function writeTarget(out) {
+    const typeName = boxedTypeName(out);
+    const value = boxedValue(out);
+    if ($.isVarRef(value)) {
+        return { typeName, ref: value, value: value.value };
+    }
+    if ($.isVarRef(out)) {
+        return { typeName, ref: out, value: out.value };
+    }
+    return { typeName, ref: null, value };
+}
+function pointerValueOrBox(value) {
+    const raw = boxedValue(value);
+    if ($.isVarRef(raw)) {
+        return raw.value;
+    }
+    return raw;
+}
+function isBigIntType(target) {
+    const typeName = target.typeName.replace(/^\*/, '');
+    const value = pointerValueOrBox(target.value);
+    return (typeName === 'big.Int' ||
+        typeName === 'math/big.Int' ||
+        (value !== null &&
+            typeof value === 'object' &&
+            typeof value.SetBytes === 'function' &&
+            typeof value.Sign === 'function'));
+}
+function integerKind(typeName) {
+    return typeName.replace(/^\*/, '');
+}
+function writeInteger(target, value) {
+    const kind = integerKind(target.typeName);
+    if (isBigIntType(target)) {
+        setBigIntObject(pointerValueOrBox(target.value), value);
+        return;
+    }
+    if (target.ref == null) {
+        $.panic('out does not point to an integer type');
+    }
+    switch (kind) {
+        case '':
+        case 'int':
+        case 'int64':
+            if (value < minInt64 || value > maxInt64) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.int(value, 64);
+            return;
+        case 'int8':
+            if (value < -128n || value > 127n) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.int(value, 8);
+            return;
+        case 'int16':
+            if (value < -32768n || value > 32767n) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.int(value, 16);
+            return;
+        case 'int32':
+            if (value < -2147483648n || value > 2147483647n) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.int(value, 32);
+            return;
+        case 'uint':
+        case 'uint64':
+        case 'uintptr':
+            if (value < 0n || value > maxUint64) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.uint(value, 64);
+            return;
+        case 'uint8':
+        case 'byte':
+            if (value < 0n || value > 255n) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.uint(value, 8);
+            return;
+        case 'uint16':
+            if (value < 0n || value > 65535n) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.uint(value, 16);
+            return;
+        case 'uint32':
+            if (value < 0n || value > 4294967295n) {
+                throw $.newError('cryptobyte: integer overflow');
+            }
+            target.ref.value = $.uint(value, 32);
+            return;
+        default:
+            throw $.newError('cryptobyte: ReadASN1Integer of a named integer type is not supported in the js build');
+    }
+}
+function integerDefaultValue(defaultValue) {
+    const raw = boxedValue(defaultValue);
+    if (typeof raw === 'bigint') {
+        return raw;
+    }
+    if (typeof raw === 'number' && Number.isFinite(raw)) {
+        return BigInt(Math.trunc(raw));
+    }
+    if (raw !== null && typeof raw === 'object') {
+        return bigIntValue(raw);
+    }
+    throw $.newError('cryptobyte: ReadOptionalASN1Integer default of a named integer type is not supported in the js build');
+}
+function setBigIntObject(target, value) {
+    if (target == null || typeof target !== 'object') {
+        $.panic('out does not point to an integer type');
+    }
+    const big = target;
+    if ('value' in big) {
+        big.value = value;
+        return;
+    }
+    const magnitude = bytesFromArray(unsignedBytes(value < 0n ? -value : value));
+    if (typeof big.SetBytes === 'function') {
+        big.SetBytes(magnitude);
+        if (value < 0n) {
+            if (typeof big.Neg !== 'function') {
+                throw $.newError('cryptobyte: big.Int negative assignment is not supported in the js build');
+            }
+            big.Neg(big);
+        }
+        return;
+    }
+    if (typeof big.SetInt64 === 'function') {
+        big.SetInt64(Number(value));
+        return;
+    }
+    throw $.newError('cryptobyte: unsupported big.Int representation');
+}
+function bigIntValue(value) {
+    const raw = pointerValueOrBox(value);
+    if (typeof raw === 'bigint') {
+        return raw;
+    }
+    if (typeof raw === 'number') {
+        return BigInt(Math.trunc(raw));
+    }
+    if (raw !== null && typeof raw === 'object') {
+        const big = raw;
+        if (typeof big.value === 'bigint') {
+            return big.value;
+        }
+        if (typeof big.value === 'number') {
+            return BigInt(Math.trunc(big.value));
+        }
+        if (typeof big.Sign === 'function' && typeof big.Bytes === 'function') {
+            const sign = big.Sign();
+            const mag = unsignedBigInt(big.Bytes());
+            return sign < 0 ? -mag : mag;
+        }
+        if (typeof big.String === 'function') {
+            return BigInt(big.String());
+        }
+    }
+    throw $.newError('cryptobyte: unsupported big.Int representation');
+}
+function readASN1Bytes(s, tag) {
+    const bytes = $.varRef(new Uint8Array(0));
+    if (!String_ReadASN1(s, bytes, tag)) {
+        return null;
+    }
+    return bytes.value;
+}
+function readASN1SignedInteger(s, tag) {
+    const bytes = readASN1Bytes(s, tag);
+    if (bytes == null || !checkASN1Integer(bytes)) {
+        return null;
+    }
+    return signedBigInt(bytes);
+}
+export function String_ReadASN1Boolean(s, out) {
+    const bytes = readASN1Bytes(s, asn1.BOOLEAN);
+    const arr = bytesArray(bytes);
+    if (bytes == null || arr.length !== 1 || (arr[0] !== 0 && arr[0] !== 0xff)) {
+        return false;
+    }
+    writeRef(out, arr[0] === 0xff);
+    return true;
+}
+export function String_ReadASN1Integer(s, out) {
+    const target = writeTarget(out);
+    const bytes = readASN1Bytes(s, asn1.INTEGER);
+    if (bytes == null || !checkASN1Integer(bytes)) {
+        return false;
+    }
+    const value = signedBigInt(bytes);
+    writeInteger(target, value);
+    return true;
+}
+export function String_ReadASN1Int64WithTag(s, out, tag) {
+    const value = readASN1SignedInteger(s, tag);
+    if (value == null || value < minInt64 || value > maxInt64) {
+        return false;
+    }
+    writeRef(out, $.int(value, 64));
+    return true;
+}
+export function String_ReadASN1Enum(s, out) {
+    const value = readASN1SignedInteger(s, asn1.ENUM);
+    if (value == null || value < minInt64 || value > maxInt64) {
+        return false;
+    }
+    writeRef(out, $.int(value, 64));
+    return true;
+}
+export function String_ReadASN1ObjectIdentifier(s, out) {
+    const bytes = readASN1Bytes(s, asn1.OBJECT_IDENTIFIER);
+    const arr = bytesArray(bytes);
+    if (bytes == null || arr.length === 0) {
+        return false;
+    }
+    const oid = [];
+    let offset = 0;
+    const firstRead = readBase128Int(arr, offset);
+    if (firstRead == null) {
+        return false;
+    }
+    offset = firstRead.next;
+    if (firstRead.value < 80) {
+        oid.push(Math.floor(firstRead.value / 40), firstRead.value % 40);
+    }
+    else {
+        oid.push(2, firstRead.value - 80);
+    }
+    while (offset < arr.length) {
+        const part = readBase128Int(arr, offset);
+        if (part == null) {
+            return false;
+        }
+        offset = part.next;
+        oid.push(part.value);
+    }
+    writeRef(out, $.arrayToSlice(oid));
+    return true;
+}
+export function String_ReadASN1GeneralizedTime(s, out) {
+    const bytes = readASN1Bytes(s, asn1.GeneralizedTime);
+    if (bytes == null) {
+        return false;
+    }
+    const parsed = parseGeneralizedTime(bytesToAscii(bytes));
+    if (parsed == null) {
+        return false;
+    }
+    writeRef(out, parsed);
+    return true;
+}
+export function String_ReadASN1UTCTime(s, out) {
+    const bytes = readASN1Bytes(s, asn1.UTCTime);
+    if (bytes == null) {
+        return false;
+    }
+    const parsed = parseUTCTime(bytesToAscii(bytes));
+    if (parsed == null) {
+        return false;
+    }
+    writeRef(out, parsed);
+    return true;
+}
+export function String_ReadASN1BitString(s, out) {
+    const bytes = readASN1Bytes(s, asn1.BIT_STRING);
+    const parsed = parseBitString(bytes);
+    if (parsed == null) {
+        return false;
+    }
+    const target = pointerValueOrBox(out);
+    if (target == null) {
+        throw new Error('runtime error: invalid memory address or nil pointer dereference');
+    }
+    target.Bytes = parsed.bytes;
+    target.BitLength = parsed.bitLength;
+    return true;
+}
+export function String_ReadASN1BitStringAsBytes(s, out, paddingBits) {
+    const bytes = readASN1Bytes(s, asn1.BIT_STRING);
+    const parsed = parseBitString(bytes);
+    if (parsed == null) {
+        return false;
+    }
+    writeRef(out, parsed.bytes);
+    writeRef(paddingBits, parsed.paddingBits);
+    return true;
+}
+export function String_ReadASN1Bytes(s, out, tag) {
+    return String_ReadASN1(s, out, tag);
+}
+export function String_ReadASN1(s, out, tag) {
+    return readASN1(s, out, null, tag, true);
+}
+export function String_ReadASN1Element(s, out, tag) {
+    return readASN1(s, out, null, tag, false);
+}
+export function String_ReadAnyASN1(s, out, outTag) {
+    return readASN1(s, out, outTag, null, true);
+}
+export function String_ReadAnyASN1Element(s, out, outTag) {
+    return readASN1(s, out, outTag, null, false);
+}
+export function String_PeekASN1Tag(s, tag) {
+    const parsed = parseASN1(s);
+    return parsed !== null && parsed.tag === tag;
+}
+export function String_SkipASN1(s, tag) {
+    const out = $.varRef(new Uint8Array(0));
+    return String_ReadASN1Element(s, out, tag);
+}
+export function String_ReadOptionalASN1(s, out, tag, defaultValue) {
+    if (!String_PeekASN1Tag(stringValue(s), tag)) {
+        writeRef(out, defaultValue);
+        return true;
+    }
+    return String_ReadASN1(s, out, tag);
+}
+export function String_SkipOptionalASN1(s, tag) {
+    if (!String_PeekASN1Tag(stringValue(s), tag)) {
+        return true;
+    }
+    return String_SkipASN1(s, tag);
+}
+export function String_ReadOptionalASN1Integer(s, out, tag, defaultValue) {
+    if (!String_PeekASN1Tag(stringValue(s), tag)) {
+        writeInteger(writeTarget(out), integerDefaultValue(defaultValue));
+        return true;
+    }
+    return String_ReadASN1Integer(s, out);
+}
+export function String_ReadOptionalASN1OctetString(s, out, tag, defaultValue) {
+    if (!String_PeekASN1Tag(stringValue(s), tag)) {
+        writeRef(out, defaultValue);
+        return true;
+    }
+    return String_ReadASN1Bytes(s, out, tag);
+}
+export function String_ReadOptionalASN1Boolean(s, out, tag, defaultValue) {
+    if (!String_PeekASN1Tag(stringValue(s), tag)) {
+        writeRef(out, defaultValue);
+        return true;
+    }
+    return String_ReadASN1Boolean(s, out);
+}
+function parseASN1(data) {
+    const arr = bytesArray(data);
+    if (arr.length < 2 || (arr[0] & 0x1f) === 0x1f) {
+        return null;
+    }
+    const tag = arr[0];
+    let headerLen = 2;
+    let length = arr[1];
+    if ((length & 0x80) !== 0) {
+        const lenLen = length & 0x7f;
+        if (lenLen === 0 || lenLen > 4 || arr.length < 2 + lenLen) {
+            return null;
+        }
+        if (arr[2] === 0) {
+            return null;
+        }
+        length = 0;
+        for (let i = 0; i < lenLen; i++) {
+            length = length * 256 + arr[2 + i];
+        }
+        if (length < 128) {
+            return null;
+        }
+        headerLen += lenLen;
+    }
+    const totalLen = headerLen + length;
+    if (arr.length < totalLen) {
+        return null;
+    }
+    return { tag, headerLen, length, totalLen };
+}
+function readASN1(s, out, outTag, expectedTag, skipHeader) {
+    const data = stringValue(s);
+    const parsed = parseASN1(data);
+    if (parsed == null || (expectedTag !== null && parsed.tag !== expectedTag)) {
+        return false;
+    }
+    if (outTag != null) {
+        outTag.value = parsed.tag;
+    }
+    if (out != null) {
+        out.value = skipHeader
+            ? $.goSlice(data, parsed.headerLen, parsed.totalLen)
+            : $.goSlice(data, 0, parsed.totalLen);
+    }
+    s.value = $.goSlice(data, parsed.totalLen);
+    return true;
+}
+function parseBitString(bytes) {
+    const arr = bytesArray(bytes);
+    if (bytes == null || arr.length === 0) {
+        return null;
+    }
+    const paddingBits = arr[0];
+    if (paddingBits > 7 || (arr.length === 1 && paddingBits !== 0)) {
+        return null;
+    }
+    if (arr.length > 1 &&
+        paddingBits > 0 &&
+        (arr[arr.length - 1] & ((1 << paddingBits) - 1)) !== 0) {
+        return null;
+    }
+    const content = bytesFromArray(arr.slice(1));
+    return {
+        bytes: content,
+        paddingBits,
+        bitLength: $.len(content) * 8 - paddingBits,
+    };
+}
+function readBase128Int(bytes, offset) {
+    let ret = 0;
+    for (let i = offset; i < bytes.length; i++) {
+        const b = bytes[i];
+        if (ret === 0 && b === 0x80) {
+            return null;
+        }
+        ret = ret * 128 + (b & 0x7f);
+        if (ret > Number.MAX_SAFE_INTEGER) {
+            return null;
+        }
+        if ((b & 0x80) === 0) {
+            return { value: ret, next: i + 1 };
+        }
+    }
+    return null;
+}
+function parseFixedDigits(value, offset, width) {
+    const text = value.slice(offset, offset + width);
+    if (!new RegExp(`^[0-9]{${width}}$`).test(text)) {
+        return null;
+    }
+    return Number(text);
+}
+function parseZone(value, offset) {
+    if (value[offset] === 'Z' && offset + 1 === value.length) {
+        return { offsetMinutes: 0 };
+    }
+    const sign = value[offset];
+    if ((sign !== '+' && sign !== '-') || offset + 5 !== value.length) {
+        return null;
+    }
+    const hour = parseFixedDigits(value, offset + 1, 2);
+    const minute = parseFixedDigits(value, offset + 3, 2);
+    if (hour == null || minute == null || hour > 23 || minute > 59) {
+        return null;
+    }
+    const offsetMinutes = hour * 60 + minute;
+    return { offsetMinutes: sign === '+' ? offsetMinutes : -offsetMinutes };
+}
+function makeTime(year, month, day, hour, minute, second, offsetMinutes) {
+    const millis = globalThis.Date.UTC(year, month - 1, day, hour, minute, second) -
+        offsetMinutes * 60 * 1000;
+    return time.Unix(Math.floor(millis / 1000), 0);
+}
+function parseGeneralizedTime(value) {
+    if (value.length < 15) {
+        return null;
+    }
+    const year = parseFixedDigits(value, 0, 4);
+    const month = parseFixedDigits(value, 4, 2);
+    const day = parseFixedDigits(value, 6, 2);
+    const hour = parseFixedDigits(value, 8, 2);
+    const minute = parseFixedDigits(value, 10, 2);
+    const second = parseFixedDigits(value, 12, 2);
+    const zone = parseZone(value, 14);
+    if (year == null ||
+        month == null ||
+        day == null ||
+        hour == null ||
+        minute == null ||
+        second == null ||
+        zone == null) {
+        return null;
+    }
+    return makeTime(year, month, day, hour, minute, second, zone.offsetMinutes);
+}
+function parseUTCTime(value) {
+    if (value.length !== 11 && value.length !== 13 && value.length !== 15 && value.length !== 17) {
+        return null;
+    }
+    const yearPart = parseFixedDigits(value, 0, 2);
+    const month = parseFixedDigits(value, 2, 2);
+    const day = parseFixedDigits(value, 4, 2);
+    const hour = parseFixedDigits(value, 6, 2);
+    const minute = parseFixedDigits(value, 8, 2);
+    let second = 0;
+    let zoneOffset = 10;
+    if (value.length === 13 || value.length === 17) {
+        const parsedSecond = parseFixedDigits(value, 10, 2);
+        if (parsedSecond == null) {
+            return null;
+        }
+        second = parsedSecond;
+        zoneOffset = 12;
+    }
+    const zone = parseZone(value, zoneOffset);
+    if (yearPart == null ||
+        month == null ||
+        day == null ||
+        hour == null ||
+        minute == null ||
+        zone == null) {
+        return null;
+    }
+    const year = yearPart >= 50 ? 1900 + yearPart : 2000 + yearPart;
+    return makeTime(year, month, day, hour, minute, second, zone.offsetMinutes);
+}
+//# sourceMappingURL=index.js.map