@weavecode/weave 0.1.0 → 0.1.1

package/node_modules/selfsigned/node_modules/@peculiar/x509/node_modules/@peculiar/asn1-cms/node_modules/asn1js/build/index.js

@@ -72,7 +72,7 @@ function concat(buffers) {
     const retView = new Uint8Array(outputLength);
     for (let i = 0; i < buffers.length; i++) {
         const buffer = buffers[i];
-        retView.set(new Uint8Array(buffer), prevLength);
+        retView.set(buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer), prevLength);
         prevLength += buffer.byteLength;
     }
     return retView.buffer;
@@ -94,7 +94,7 @@ function checkBufferParams(baseBlock, inputBuffer, inputOffset, inputLength) {
         baseBlock.error = "Wrong parameter: inputLength less than zero";
         return false;
     }
-    if ((inputBuffer.byteLength - inputOffset - inputLength) < 0) {
+    if (inputBuffer.byteLength - inputOffset - inputLength < 0) {
         baseBlock.error = "End of input reached before message was fully decoded (inconsistent offset and length values)";
         return false;
     }
@@ -106,15 +106,15 @@ class ViewWriter {
         this.items = [];
     }
     write(buf) {
-        this.items.push(buf);
+        this.items.push(buf instanceof ArrayBuffer ? buf : concat([buf]));
     }
     final() {
         return concat(this.items);
     }
 }
+const ORIGINAL_VIEW_WRITER_WRITE = ViewWriter.prototype.write;
+const ORIGINAL_VIEW_WRITER_FINAL = ViewWriter.prototype.final;
 
-const powers2 = [new Uint8Array([1])];
-const digitsString = "0123456789";
 const NAME = "name";
 const VALUE_HEX_VIEW = "valueHexView";
 const IS_HEX_ONLY = "isHexOnly";
@@ -170,15 +170,17 @@ function HexBlock(BaseClass) {
                 if (sizeOnly) {
                     return new ArrayBuffer(this.valueHexView.byteLength);
                 }
-                return (this.valueHexView.byteLength === this.valueHexView.buffer.byteLength)
-                    ? this.valueHexView.buffer
-                    : this.valueHexView.slice().buffer;
+                if (this.valueHexView.buffer instanceof ArrayBuffer &&
+                    this.valueHexView.byteLength === this.valueHexView.buffer.byteLength) {
+                    return this.valueHexView.buffer;
+                }
+                return pvtsutils__namespace.BufferSourceConverter.toArrayBuffer(this.valueHexView);
             }
             toJSON() {
                 return {
                     ...super.toJSON(),
                     isHexOnly: this.isHexOnly,
-                    valueHex: pvtsutils__namespace.Convert.ToHex(this.valueHexView),
+                    valueHex: pvtsutils__namespace.Convert.ToHex(this.valueHexView)
                 };
             }
         },
@@ -196,7 +198,7 @@ class LocalBaseBlock {
     set valueBeforeDecode(value) {
         this.valueBeforeDecodeView = new Uint8Array(value);
     }
-    constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW, } = {}) {
+    constructor({ blockLength = 0, error = EMPTY_STRING, warnings = [], valueBeforeDecode = EMPTY_VIEW } = {}) {
         this.blockLength = blockLength;
         this.error = error;
         this.warnings = warnings;
@@ -208,7 +210,7 @@ class LocalBaseBlock {
             blockLength: this.blockLength,
             error: this.error,
             warnings: this.warnings,
-            valueBeforeDecode: pvtsutils__namespace.Convert.ToHex(this.valueBeforeDecodeView),
+            valueBeforeDecode: pvtsutils__namespace.Convert.ToHex(this.valueBeforeDecodeView)
         };
     }
 }
@@ -256,7 +258,7 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
                 firstOctet |= 0x80;
                 break;
             case 4:
-                firstOctet |= 0xC0;
+                firstOctet |= 0xc0;
                 break;
             default:
                 this.error = "Unknown tag class";
@@ -268,7 +270,7 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
             const retView = new Uint8Array(1);
             if (!sizeOnly) {
                 let number = this.tagNumber;
-                number &= 0x1F;
+                number &= 0x1f;
                 firstOctet |= number;
                 retView[0] = firstOctet;
             }
@@ -279,19 +281,19 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
             const encodedView = new Uint8Array(encodedBuf);
             const size = encodedBuf.byteLength;
             const retView = new Uint8Array(size + 1);
-            retView[0] = (firstOctet | 0x1F);
+            retView[0] = firstOctet | 0x1f;
             if (!sizeOnly) {
-                for (let i = 0; i < (size - 1); i++)
+                for (let i = 0; i < size - 1; i++)
                     retView[i + 1] = encodedView[i] | 0x80;
                 retView[size] = encodedView[size - 1];
             }
             return retView.buffer;
         }
         const retView = new Uint8Array(this.valueHexView.byteLength + 1);
-        retView[0] = (firstOctet | 0x1F);
+        retView[0] = firstOctet | 0x1f;
         if (!sizeOnly) {
             const curView = this.valueHexView;
-            for (let i = 0; i < (curView.length - 1); i++)
+            for (let i = 0; i < curView.length - 1; i++)
                 retView[i + 1] = curView[i] | 0x80;
             retView[this.valueHexView.byteLength] = curView[curView.length - 1];
         }
@@ -302,52 +304,55 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
         if (!checkBufferParams(this, inputView, inputOffset, inputLength)) {
             return -1;
         }
-        const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
-        if (intBuffer.length === 0) {
+        const fastArgs = Number.isInteger(inputOffset) && Number.isInteger(inputLength);
+        const intBuffer = fastArgs ? inputView : inputView.subarray(inputOffset, inputOffset + inputLength);
+        const baseIndex = fastArgs ? inputOffset : 0;
+        const bufferLength = fastArgs ? inputLength : intBuffer.length;
+        if (bufferLength === 0) {
             this.error = "Zero buffer length";
             return -1;
         }
-        const tagClassMask = intBuffer[0] & 0xC0;
+        const tagClassMask = intBuffer[baseIndex] & 0xc0;
         switch (tagClassMask) {
             case 0x00:
-                this.tagClass = (1);
+                this.tagClass = 1;
                 break;
             case 0x40:
-                this.tagClass = (2);
+                this.tagClass = 2;
                 break;
             case 0x80:
-                this.tagClass = (3);
+                this.tagClass = 3;
                 break;
-            case 0xC0:
-                this.tagClass = (4);
+            case 0xc0:
+                this.tagClass = 4;
                 break;
             default:
                 this.error = "Unknown tag class";
                 return -1;
         }
-        this.isConstructed = (intBuffer[0] & 0x20) === 0x20;
+        this.isConstructed = (intBuffer[baseIndex] & 0x20) === 0x20;
         this.isHexOnly = false;
-        const tagNumberMask = intBuffer[0] & 0x1F;
-        if (tagNumberMask !== 0x1F) {
-            this.tagNumber = (tagNumberMask);
+        const tagNumberMask = intBuffer[baseIndex] & 0x1f;
+        if (tagNumberMask !== 0x1f) {
+            this.tagNumber = tagNumberMask;
             this.blockLength = 1;
         }
         else {
             let count = 0;
             while (true) {
                 const tagByteIndex = count + 1;
-                if (tagByteIndex >= intBuffer.length) {
+                if (tagByteIndex >= bufferLength) {
                     this.error = "End of input reached before message was fully decoded";
                     return -1;
                 }
                 count++;
-                if ((intBuffer[tagByteIndex] & 0x80) === 0x00)
+                if ((intBuffer[baseIndex + tagByteIndex] & 0x80) === 0x00)
                     break;
             }
-            this.blockLength = (count + 1);
-            const intTagNumberBuffer = this.valueHexView = new Uint8Array(count);
+            this.blockLength = count + 1;
+            const intTagNumberBuffer = (this.valueHexView = new Uint8Array(count));
             for (let i = 0; i < count; i++)
-                intTagNumberBuffer[i] = intBuffer[i + 1] & 0x7F;
+                intTagNumberBuffer[i] = intBuffer[baseIndex + i + 1] & 0x7f;
             if (this.blockLength <= 9)
                 this.tagNumber = pvutils__namespace.utilFromBase(intTagNumberBuffer, 7);
             else {
@@ -355,8 +360,7 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
                 this.warnings.push("Tag too long, represented as hex-coded");
             }
         }
-        if (((this.tagClass === 1))
-            && (this.isConstructed)) {
+        if (this.tagClass === 1 && this.isConstructed) {
             switch (this.tagNumber) {
                 case 1:
                 case 2:
@@ -375,18 +379,20 @@ class LocalIdentificationBlock extends HexBlock(LocalBaseBlock) {
                     return -1;
             }
         }
-        return (inputOffset + this.blockLength);
+        return inputOffset + this.blockLength;
     }
     toJSON() {
         return {
             ...super.toJSON(),
             tagClass: this.tagClass,
             tagNumber: this.tagNumber,
-            isConstructed: this.isConstructed,
+            isConstructed: this.isConstructed
         };
     }
 }
 LocalIdentificationBlock.NAME = "identificationBlock";
+const ORIGINAL_LOCAL_IDENTIFICATION_TO_BER = LocalIdentificationBlock.prototype.toBER;
+const ORIGINAL_LOCAL_IDENTIFICATION_FROM_BER = LocalIdentificationBlock.prototype.fromBER;
 
 class LocalLengthBlock extends LocalBaseBlock {
     constructor({ lenBlock = {} } = {}) {
@@ -401,32 +407,35 @@ class LocalLengthBlock extends LocalBaseBlock {
         if (!checkBufferParams(this, view, inputOffset, inputLength)) {
             return -1;
         }
-        const intBuffer = view.subarray(inputOffset, inputOffset + inputLength);
-        if (intBuffer.length === 0) {
+        const fastArgs = Number.isInteger(inputOffset) && Number.isInteger(inputLength);
+        const intBuffer = fastArgs ? view : view.subarray(inputOffset, inputOffset + inputLength);
+        const baseIndex = fastArgs ? inputOffset : 0;
+        const bufferLength = fastArgs ? inputLength : intBuffer.length;
+        if (bufferLength === 0) {
             this.error = "Zero buffer length";
             return -1;
         }
-        if (intBuffer[0] === 0xFF) {
+        if (intBuffer[baseIndex] === 0xff) {
             this.error = "Length block 0xFF is reserved by standard";
             return -1;
         }
-        this.isIndefiniteForm = intBuffer[0] === 0x80;
+        this.isIndefiniteForm = intBuffer[baseIndex] === 0x80;
         if (this.isIndefiniteForm) {
             this.blockLength = 1;
-            return (inputOffset + this.blockLength);
+            return inputOffset + this.blockLength;
         }
-        this.longFormUsed = !!(intBuffer[0] & 0x80);
+        this.longFormUsed = !!(intBuffer[baseIndex] & 0x80);
         if (this.longFormUsed === false) {
-            this.length = (intBuffer[0]);
+            this.length = intBuffer[baseIndex];
             this.blockLength = 1;
-            return (inputOffset + this.blockLength);
+            return inputOffset + this.blockLength;
         }
-        const count = intBuffer[0] & 0x7F;
+        const count = intBuffer[baseIndex] & 0x7f;
         if (count > 8) {
             this.error = "Too big integer";
             return -1;
         }
-        if ((count + 1) > intBuffer.length) {
+        if (count + 1 > bufferLength) {
             this.error = "End of input reached before message was fully decoded";
             return -1;
         }
@@ -435,10 +444,10 @@ class LocalLengthBlock extends LocalBaseBlock {
         if (lengthBufferView[count - 1] === 0x00)
             this.warnings.push("Needlessly long encoded length");
         this.length = pvutils__namespace.utilFromBase(lengthBufferView, 8);
-        if (this.longFormUsed && (this.length <= 127))
+        if (this.longFormUsed && this.length <= 127)
             this.warnings.push("Unnecessary usage of long length form");
         this.blockLength = count + 1;
-        return (inputOffset + this.blockLength);
+        return inputOffset + this.blockLength;
     }
     toBER(sizeOnly = false) {
         let retBuf;
@@ -457,7 +466,7 @@ class LocalLengthBlock extends LocalBaseBlock {
             const encodedBuf = pvutils__namespace.utilToBase(this.length, 8);
             if (encodedBuf.byteLength > 127) {
                 this.error = "Too big length";
-                return (EMPTY_BUFFER);
+                return EMPTY_BUFFER;
             }
             retBuf = new ArrayBuffer(encodedBuf.byteLength + 1);
             if (sizeOnly)
@@ -481,14 +490,427 @@ class LocalLengthBlock extends LocalBaseBlock {
             ...super.toJSON(),
             isIndefiniteForm: this.isIndefiniteForm,
             longFormUsed: this.longFormUsed,
-            length: this.length,
+            length: this.length
         };
     }
 }
 LocalLengthBlock.NAME = "lengthBlock";
+const ORIGINAL_LOCAL_LENGTH_TO_BER = LocalLengthBlock.prototype.toBER;
+const ORIGINAL_LOCAL_LENGTH_FROM_BER = LocalLengthBlock.prototype.fromBER;
 
 const typeStore = {};
 
+var _a$y, _b, _c;
+const originalUint8ArraySliceInfo = findMethod(Uint8Array.prototype, "slice");
+const originalUint8ArrayConstructor = (_a$y = Object.getOwnPropertyDescriptor(Uint8Array.prototype, "constructor")) === null || _a$y === void 0 ? void 0 : _a$y.value;
+const originalArrayIterator = (_b = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator)) === null || _b === void 0 ? void 0 : _b.value;
+const intrinsicTypedArrayByteLength = (_c = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "byteLength")) === null || _c === void 0 ? void 0 : _c.get;
+const BUILTIN_DISPATCH_PAYLOAD_THRESHOLD = 16384;
+const BUILTIN_DISPATCH_MAX_DEPTH = 64;
+let builtinRegistry;
+function registerBuiltinEncoder(builtinConstructors, internals) {
+    const current = builtinRegistry;
+    const nextInternals = internals || current;
+    if (!nextInternals) {
+        builtinRegistry = undefined;
+        return;
+    }
+    builtinRegistry = { ...nextInternals, ...builtinConstructors };
+}
+function dataProperty(object, name) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, name);
+    if (!descriptor || !("value" in descriptor))
+        return undefined;
+    return descriptor.value;
+}
+function intrinsicPayloadByteLength(value) {
+    if (!intrinsicTypedArrayByteLength || !value || typeof value !== "object")
+        return undefined;
+    try {
+        const byteLength = intrinsicTypedArrayByteLength.call(value);
+        return typeof byteLength === "number" ? byteLength : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function largePayloadOrChain(block, depth) {
+    if (depth > BUILTIN_DISPATCH_MAX_DEPTH || !block || typeof block !== "object")
+        return false;
+    const valueBlockDescriptor = Object.getOwnPropertyDescriptor(block, "valueBlock");
+    if (!valueBlockDescriptor || !("value" in valueBlockDescriptor))
+        return false;
+    const valueBlock = valueBlockDescriptor.value;
+    if (!valueBlock || typeof valueBlock !== "object")
+        return false;
+    const payloadDescriptor = Object.getOwnPropertyDescriptor(valueBlock, "valueHexView");
+    if (payloadDescriptor) {
+        if (!("value" in payloadDescriptor))
+            return false;
+        const byteLength = intrinsicPayloadByteLength(payloadDescriptor.value);
+        return byteLength !== undefined && byteLength >= BUILTIN_DISPATCH_PAYLOAD_THRESHOLD;
+    }
+    const valuesDescriptor = Object.getOwnPropertyDescriptor(valueBlock, "value");
+    if (!valuesDescriptor || !("value" in valuesDescriptor) || !Array.isArray(valuesDescriptor.value))
+        return false;
+    const values = valuesDescriptor.value;
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(values, "length");
+    if (!lengthDescriptor || !("value" in lengthDescriptor) || lengthDescriptor.value !== 1)
+        return false;
+    const indexDescriptor = Object.getOwnPropertyDescriptor(values, "0");
+    if (!indexDescriptor || !("value" in indexDescriptor))
+        return false;
+    return largePayloadOrChain(indexDescriptor.value, depth + 1);
+}
+function shouldUseBuiltinEncoder(block) {
+    try {
+        return largePayloadOrChain(block, 0);
+    }
+    catch {
+        return false;
+    }
+}
+function sameDataMethod(current, original) {
+    return (!!current &&
+        "value" in current &&
+        current.value === original &&
+        current.writable === true &&
+        current.enumerable === false &&
+        current.configurable === true);
+}
+function writerMethodsStable(registry) {
+    return (sameDataMethod(Object.getOwnPropertyDescriptor(registry.ViewWriter.prototype, "write"), registry.originalWriterWrite) &&
+        sameDataMethod(Object.getOwnPropertyDescriptor(registry.ViewWriter.prototype, "final"), registry.originalWriterFinal));
+}
+function findMethod(prototype, name) {
+    let current = prototype;
+    while (current) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, name);
+        if (descriptor) {
+            if ("value" in descriptor && typeof descriptor.value === "function") {
+                return { declaringPrototype: current, method: descriptor.value };
+            }
+            return undefined;
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return undefined;
+}
+function stableInheritedMethod(prototype, name, original) {
+    if (!original)
+        return false;
+    let current = prototype;
+    while (current) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, name);
+        if (current === original.declaringPrototype) {
+            return !!descriptor && "value" in descriptor && descriptor.value === original.method;
+        }
+        if (descriptor)
+            return false;
+        current = Object.getPrototypeOf(current);
+    }
+    return false;
+}
+function prototypeMethod(object, prototype, name, expected) {
+    if (Object.prototype.hasOwnProperty.call(object, name))
+        return false;
+    if (Object.getPrototypeOf(object) !== prototype)
+        return false;
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, name);
+    return !!descriptor && "value" in descriptor && descriptor.value === expected;
+}
+function inheritedMethod(object, name, expected, primitiveConstructor) {
+    if (Object.prototype.hasOwnProperty.call(object, name))
+        return false;
+    const prototype = Object.getPrototypeOf(object);
+    const originalPrimitiveValuePrototype = Object.getPrototypeOf(primitiveConstructor.prototype);
+    if (prototype !== primitiveConstructor.prototype ||
+        Object.getPrototypeOf(prototype) !== originalPrimitiveValuePrototype) {
+        return false;
+    }
+    const descriptor = prototype && Object.getOwnPropertyDescriptor(prototype, name);
+    if (descriptor)
+        return false;
+    const parentDescriptor = Object.getOwnPropertyDescriptor(originalPrimitiveValuePrototype, name);
+    return !!parentDescriptor && "value" in parentDescriptor && parentDescriptor.value === expected;
+}
+function plainPayload(value, allowEmpty = false) {
+    if (!(value instanceof Uint8Array) || Object.getPrototypeOf(value) !== Uint8Array.prototype)
+        return undefined;
+    for (const name of ["buffer", "byteOffset", "byteLength", "length", "slice", "constructor"]) {
+        if (Object.prototype.hasOwnProperty.call(value, name))
+            return undefined;
+    }
+    const constructorDescriptor = Object.getOwnPropertyDescriptor(Uint8Array.prototype, "constructor");
+    if (!constructorDescriptor ||
+        !("value" in constructorDescriptor) ||
+        constructorDescriptor.value !== originalUint8ArrayConstructor)
+        return undefined;
+    if (!stableInheritedMethod(Uint8Array.prototype, "slice", originalUint8ArraySliceInfo))
+        return undefined;
+    try {
+        const buffer = value.buffer;
+        if (!(buffer instanceof ArrayBuffer) || Object.getPrototypeOf(buffer) !== ArrayBuffer.prototype)
+            return undefined;
+        if (Object.prototype.hasOwnProperty.call(buffer, "byteLength"))
+            return undefined;
+        if (value.byteLength !== value.length || (!allowEmpty && value.byteLength === 0))
+            return undefined;
+        if (value.byteOffset < 0 || value.byteOffset + value.byteLength > buffer.byteLength)
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return value;
+}
+function validIdBlock(block, constructed, registry) {
+    if (Object.getPrototypeOf(block) !== registry.LocalIdentificationBlock.prototype)
+        return false;
+    if (!prototypeMethod(block, registry.LocalIdentificationBlock.prototype, "toBER", registry.originalIdentificationToBER))
+        return false;
+    const tagClass = dataProperty(block, "tagClass");
+    const tagNumber = dataProperty(block, "tagNumber");
+    const isConstructed = dataProperty(block, "isConstructed");
+    const isHexOnly = dataProperty(block, "isHexOnly");
+    const valueHexView = dataProperty(block, "valueHexView");
+    if (typeof tagClass !== "number" || !Number.isInteger(tagClass) || tagClass < 1 || tagClass > 4)
+        return false;
+    if (typeof tagNumber !== "number" || !Number.isInteger(tagNumber) || tagNumber < 0)
+        return false;
+    if (isConstructed !== constructed || typeof isHexOnly !== "boolean")
+        return false;
+    if (isHexOnly)
+        return !!plainPayload(valueHexView);
+    return Number.isSafeInteger(tagNumber);
+}
+function validLengthBlock(block, allowIndefinite, registry) {
+    if (Object.getPrototypeOf(block) !== registry.LocalLengthBlock.prototype)
+        return false;
+    if (!prototypeMethod(block, registry.LocalLengthBlock.prototype, "toBER", registry.originalLengthToBER))
+        return false;
+    const indefinite = dataProperty(block, "isIndefiniteForm");
+    const longForm = dataProperty(block, "longFormUsed");
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(block, "length");
+    const length = lengthDescriptor && "value" in lengthDescriptor ? lengthDescriptor.value : undefined;
+    const longFormDescriptor = Object.getOwnPropertyDescriptor(block, "longFormUsed");
+    return (typeof indefinite === "boolean" &&
+        (indefinite === false || allowIndefinite) &&
+        typeof longForm === "boolean" &&
+        !!longFormDescriptor &&
+        "value" in longFormDescriptor &&
+        longFormDescriptor.writable === true &&
+        !!lengthDescriptor &&
+        "value" in lengthDescriptor &&
+        lengthDescriptor.writable === true &&
+        typeof length === "number" &&
+        Number.isSafeInteger(length) &&
+        length >= 0);
+}
+function validBaseBlock(block, isConstructed, registry) {
+    const idBlock = dataProperty(block, "idBlock");
+    const lenBlock = dataProperty(block, "lenBlock");
+    return (!!idBlock &&
+        !!lenBlock &&
+        validIdBlock(idBlock, isConstructed, registry) &&
+        validLengthBlock(lenBlock, isConstructed, registry));
+}
+function constructedChild(block, registry) {
+    const valueBlock = dataProperty(block, "valueBlock");
+    if (!valueBlock || Object.getPrototypeOf(valueBlock) !== registry.LocalConstructedValueBlock.prototype)
+        return undefined;
+    if (!prototypeMethod(valueBlock, registry.LocalConstructedValueBlock.prototype, "toBER", registry.originalConstructedToBER))
+        return undefined;
+    const values = dataProperty(valueBlock, "value");
+    if (!Array.isArray(values) || Object.getPrototypeOf(values) !== Array.prototype)
+        return undefined;
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(values, "length");
+    if (!lengthDescriptor || !("value" in lengthDescriptor) || lengthDescriptor.value !== 1)
+        return undefined;
+    if (Object.prototype.hasOwnProperty.call(values, Symbol.iterator))
+        return undefined;
+    const iteratorDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, Symbol.iterator);
+    if (!iteratorDescriptor || !("value" in iteratorDescriptor) || iteratorDescriptor.value !== originalArrayIterator)
+        return undefined;
+    const indexDescriptor = Object.getOwnPropertyDescriptor(values, "0");
+    if (!indexDescriptor || !("value" in indexDescriptor))
+        return undefined;
+    if (Object.getOwnPropertyNames(values).length !== 2)
+        return undefined;
+    return indexDescriptor.value;
+}
+function bitPayload(block, registry) {
+    const valueBlock = dataProperty(block, "valueBlock");
+    if (!valueBlock || Object.getPrototypeOf(valueBlock) !== registry.LocalBitStringValueBlock.prototype)
+        return undefined;
+    if (!prototypeMethod(valueBlock, registry.LocalBitStringValueBlock.prototype, "toBER", registry.originalBitStringToBER))
+        return undefined;
+    if (dataProperty(valueBlock, "isConstructed") !== false)
+        return undefined;
+    const unusedBits = dataProperty(valueBlock, "unusedBits");
+    if (typeof unusedBits !== "number" || !Number.isInteger(unusedBits) || unusedBits < 0 || unusedBits > 7)
+        return undefined;
+    const payload = plainPayload(dataProperty(valueBlock, "valueHexView"), true);
+    if (!payload)
+        return undefined;
+    return { payload, prefix: Uint8Array.of(payload.byteLength ? unusedBits : 0) };
+}
+function primitivePayload(block, kind, registry) {
+    const valueBlock = dataProperty(block, "valueBlock");
+    if (!valueBlock)
+        return undefined;
+    if (kind === "integer") {
+        if (Object.getPrototypeOf(valueBlock) !== registry.LocalIntegerValueBlock.prototype)
+            return undefined;
+        if (!prototypeMethod(valueBlock, registry.LocalIntegerValueBlock.prototype, "toBER", registry.originalIntegerToBER))
+            return undefined;
+    }
+    else if (kind === "octet") {
+        if (Object.getPrototypeOf(valueBlock) !== registry.LocalOctetStringValueBlock.prototype)
+            return undefined;
+        if (!prototypeMethod(valueBlock, registry.LocalOctetStringValueBlock.prototype, "toBER", registry.originalOctetStringToBER))
+            return undefined;
+        if (dataProperty(valueBlock, "isConstructed") !== false)
+            return undefined;
+    }
+    else {
+        if (Object.getPrototypeOf(valueBlock) !== registry.LocalPrimitiveValueBlock.prototype)
+            return undefined;
+        if (!inheritedMethod(valueBlock, "toBER", registry.originalPrimitiveToBER, registry.LocalPrimitiveValueBlock))
+            return undefined;
+    }
+    if (kind === "primitive" && dataProperty(valueBlock, "isHexOnly") !== true)
+        return undefined;
+    if (typeof dataProperty(valueBlock, "isHexOnly") !== "boolean")
+        return undefined;
+    return plainPayload(dataProperty(valueBlock, "valueHexView"));
+}
+function validOuterMethod(block, registry) {
+    if (Object.prototype.hasOwnProperty.call(block, "toBER"))
+        return false;
+    let prototype = block;
+    while (prototype) {
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, "toBER");
+        if (descriptor)
+            return "value" in descriptor && descriptor.value === registry.originalBaseBlockToBER;
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return false;
+}
+function isPrimitive(block, type, registry) {
+    const constructor = registry[type];
+    return !!constructor && Object.getPrototypeOf(block) === constructor.prototype;
+}
+function isConstructed(block, registry) {
+    return (Object.getPrototypeOf(block) === registry.Sequence.prototype ||
+        Object.getPrototypeOf(block) === registry.Set.prototype ||
+        Object.getPrototypeOf(block) === registry.Constructed.prototype);
+}
+function inspectNode(block, depth, registry) {
+    if (depth > BUILTIN_DISPATCH_MAX_DEPTH || !block || typeof block !== "object")
+        return undefined;
+    try {
+        if (!validOuterMethod(block, registry))
+            return undefined;
+        const primitiveKind = isPrimitive(block, "BitString", registry)
+            ? "bit"
+            : isPrimitive(block, "Integer", registry)
+                ? "integer"
+                : isPrimitive(block, "OctetString", registry)
+                    ? "octet"
+                    : isPrimitive(block, "Primitive", registry)
+                        ? "primitive"
+                        : undefined;
+        const constructed = primitiveKind === undefined && isConstructed(block, registry);
+        if (!primitiveKind && !constructed)
+            return undefined;
+        if (!validBaseBlock(block, constructed, registry))
+            return undefined;
+        const idBlock = dataProperty(block, "idBlock");
+        const lenBlock = dataProperty(block, "lenBlock");
+        if (!idBlock || !lenBlock)
+            return undefined;
+        if (primitiveKind) {
+            const bit = primitiveKind === "bit" ? bitPayload(block, registry) : undefined;
+            const payload = primitiveKind === "bit" ? bit === null || bit === void 0 ? void 0 : bit.payload : primitivePayload(block, primitiveKind, registry);
+            return payload
+                ? { block, kind: primitiveKind, idBlock, lenBlock, indefinite: false, payload, prefix: bit === null || bit === void 0 ? void 0 : bit.prefix }
+                : undefined;
+        }
+        const child = constructedChild(block, registry);
+        const validatedChild = child && inspectNode(child, depth + 1, registry);
+        const indefinite = dataProperty(lenBlock, "isIndefiniteForm");
+        return validatedChild
+            ? { block, kind: "constructed", idBlock, lenBlock, indefinite: indefinite === true, child: validatedChild }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildNode(node, sizeOnly, registry) {
+    var _a, _b;
+    const id = Reflect.apply(registry.originalIdentificationToBER, node.idBlock, [sizeOnly]);
+    if (!(id instanceof ArrayBuffer) || id.byteLength === 0)
+        throw TypeError("Built-in identifier encoding failed");
+    let payload;
+    if (node.kind === "constructed") {
+        payload = buildNode(node.child, sizeOnly, registry);
+    }
+    else {
+        payload = node.payload;
+    }
+    const length = (payload instanceof Uint8Array ? payload.byteLength : payload.total) + ((_b = (_a = node.prefix) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0);
+    let len;
+    if (node.indefinite) {
+        len = Uint8Array.of(0x80).buffer;
+    }
+    else {
+        node.lenBlock.length = length;
+        len = Reflect.apply(registry.originalLengthToBER, node.lenBlock, [sizeOnly]);
+        if (!(len instanceof ArrayBuffer) || len.byteLength === 0)
+            throw TypeError("Built-in length encoding failed");
+    }
+    const total = id.byteLength + len.byteLength + length + (node.indefinite ? 2 : 0);
+    if (!Number.isSafeInteger(total))
+        throw RangeError("Built-in encoding is too large");
+    return { id, len, payload, length, total, indefinite: node.indefinite, prefix: node.prefix };
+}
+function flatten(node, output, offset, sizeOnly) {
+    output.set(new Uint8Array(node.id), offset);
+    offset += node.id.byteLength;
+    output.set(new Uint8Array(node.len), offset);
+    offset += node.len.byteLength;
+    if (node.prefix) {
+        if (!sizeOnly)
+            output.set(node.prefix, offset);
+        offset += node.prefix.byteLength;
+    }
+    if (node.payload instanceof Uint8Array) {
+        if (!sizeOnly)
+            output.set(node.payload, offset);
+        offset += node.payload.byteLength;
+    }
+    else {
+        offset = flatten(node.payload, output, offset, sizeOnly);
+    }
+    if (node.indefinite)
+        offset += 2;
+    return offset;
+}
+function tryEncodeBuiltin(block, sizeOnly = false) {
+    const registry = builtinRegistry;
+    if (!registry || !writerMethodsStable(registry))
+        return undefined;
+    const validated = inspectNode(block, 0, registry);
+    if (!validated)
+        return undefined;
+    const node = buildNode(validated, sizeOnly, registry);
+    const output = new Uint8Array(node.total);
+    flatten(node, output, 0, sizeOnly);
+    return output.buffer;
+}
+
 class BaseBlock extends LocalBaseBlock {
     constructor({ name = EMPTY_STRING, optional = false, primitiveSchema, ...parameters } = {}, valueBlockType) {
         super(parameters);
@@ -502,9 +924,7 @@ class BaseBlock extends LocalBaseBlock {
         this.valueBlock = valueBlockType ? new valueBlockType(parameters) : new ValueBlock(parameters);
     }
     fromBER(inputBuffer, inputOffset, inputLength, context) {
-        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm)
-            ? inputLength
-            : this.lenBlock.length, context);
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length, context);
         if (resultOffset === -1) {
             this.error = this.valueBlock.error;
             return resultOffset;
@@ -521,6 +941,13 @@ class BaseBlock extends LocalBaseBlock {
         const _writer = writer || new ViewWriter();
         if (!writer) {
             prepareIndefiniteForm(this);
+            if (sizeOnly === true || sizeOnly === false || sizeOnly === undefined) {
+                if (shouldUseBuiltinEncoder(this)) {
+                    const encoded = tryEncodeBuiltin(this, sizeOnly === true);
+                    if (encoded)
+                        return encoded;
+                }
+            }
         }
         const idBlockBuf = this.idBlock.toBER(sizeOnly);
         _writer.write(idBlockBuf);
@@ -548,7 +975,7 @@ class BaseBlock extends LocalBaseBlock {
             lenBlock: this.lenBlock.toJSON(),
             valueBlock: this.valueBlock.toJSON(),
             name: this.name,
-            optional: this.optional,
+            optional: this.optional
         };
         if (this.primitiveSchema)
             object.primitiveSchema = this.primitiveSchema.toJSON();
@@ -578,6 +1005,7 @@ class BaseBlock extends LocalBaseBlock {
     }
 }
 BaseBlock.NAME = "BaseBlock";
+const ORIGINAL_BASE_BLOCK_TO_BER = BaseBlock.prototype.toBER;
 function prepareIndefiniteForm(baseBlock) {
     var _a;
     if (baseBlock instanceof typeStore.Constructed) {
@@ -604,9 +1032,7 @@ class BaseStringBlock extends BaseBlock {
         }
     }
     fromBER(inputBuffer, inputOffset, inputLength) {
-        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm)
-            ? inputLength
-            : this.lenBlock.length);
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length);
         if (resultOffset === -1) {
             this.error = this.valueBlock.error;
             return resultOffset;
@@ -626,6 +1052,7 @@ class BaseStringBlock extends BaseBlock {
 }
 BaseStringBlock.NAME = "BaseStringBlock";
 
+var _a$x;
 class LocalPrimitiveValueBlock extends HexBlock(ValueBlock) {
     constructor({ isHexOnly = true, ...parameters } = {}) {
         super(parameters);
@@ -633,6 +1060,7 @@ class LocalPrimitiveValueBlock extends HexBlock(ValueBlock) {
     }
 }
 LocalPrimitiveValueBlock.NAME = "PrimitiveValueBlock";
+const ORIGINAL_LOCAL_PRIMITIVE_TO_BER = (_a$x = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(LocalPrimitiveValueBlock.prototype), "toBER")) === null || _a$x === void 0 ? void 0 : _a$x.value;
 
 var _a$w;
 class Primitive extends BaseBlock {
@@ -647,6 +1075,101 @@ _a$w = Primitive;
 })();
 Primitive.NAME = "PRIMITIVE";
 
+let fastParserRegistry;
+function registerFastParser(constructors) {
+    fastParserRegistry = {
+        Integer: constructors.Integer,
+        Null: constructors.Null,
+        Sequence: constructors.Sequence
+    };
+}
+function fastParserContext(context) {
+    const nodes = Object.getOwnPropertyDescriptor(context, "nodesCount");
+    const maxNodes = Object.getOwnPropertyDescriptor(context, "maxNodes");
+    const maxContentLength = Object.getOwnPropertyDescriptor(context, "maxContentLength");
+    if (!nodes || !("value" in nodes) || nodes.writable !== true)
+        return false;
+    if (!maxNodes || !("value" in maxNodes) || !maxContentLength || !("value" in maxContentLength))
+        return false;
+    return (typeof nodes.value === "number" &&
+        Number.isSafeInteger(nodes.value) &&
+        nodes.value >= 0 &&
+        typeof maxNodes.value === "number" &&
+        Number.isSafeInteger(maxNodes.value) &&
+        maxNodes.value >= 0 &&
+        typeof maxContentLength.value === "number" &&
+        Number.isSafeInteger(maxContentLength.value) &&
+        maxContentLength.value >= 0 &&
+        nodes.value < maxNodes.value);
+}
+function fastParserType(store, name, value) {
+    const descriptor = Object.getOwnPropertyDescriptor(store, name);
+    return !!descriptor && "value" in descriptor && descriptor.value === value;
+}
+function tryFastFromBER(inputBuffer, inputOffset, inputLength, context) {
+    const registry = fastParserRegistry;
+    if (!registry)
+        return undefined;
+    let Constructor;
+    let length = 0;
+    try {
+        if (Object.getPrototypeOf(inputBuffer) !== Uint8Array.prototype)
+            return undefined;
+        if (!Number.isSafeInteger(inputOffset) ||
+            inputOffset < 0 ||
+            !Number.isSafeInteger(inputLength) ||
+            inputLength < 2) {
+            return undefined;
+        }
+        if (inputOffset > inputBuffer.byteLength || inputLength > inputBuffer.byteLength - inputOffset)
+            return undefined;
+        const tag = inputBuffer[inputOffset];
+        if (tag !== 0x02 && tag !== 0x05 && tag !== 0x30)
+            return undefined;
+        length = inputBuffer[inputOffset + 1];
+        if (length >= 0x80 || length > inputLength - 2)
+            return undefined;
+        if (tag === 0x05 && length !== 0)
+            return undefined;
+        if (!fastParserContext(context))
+            return undefined;
+        if (length > Object.getOwnPropertyDescriptor(context, "maxContentLength").value) {
+            return undefined;
+        }
+        const constructorName = tag === 0x02 ? "Integer" : tag === 0x05 ? "Null" : "Sequence";
+        Constructor = registry[constructorName];
+        if (!fastParserType(typeStore, constructorName, Constructor))
+            return undefined;
+        const identificationFromBER = Object.getOwnPropertyDescriptor(LocalIdentificationBlock.prototype, "fromBER");
+        const lengthFromBER = Object.getOwnPropertyDescriptor(LocalLengthBlock.prototype, "fromBER");
+        if (!identificationFromBER ||
+            !("value" in identificationFromBER) ||
+            identificationFromBER.value !== ORIGINAL_LOCAL_IDENTIFICATION_FROM_BER ||
+            !lengthFromBER ||
+            !("value" in lengthFromBER) ||
+            lengthFromBER.value !== ORIGINAL_LOCAL_LENGTH_FROM_BER)
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    if (!Constructor)
+        return undefined;
+    const result = new Constructor();
+    result.idBlock.tagClass = 1;
+    result.idBlock.tagNumber = inputBuffer[inputOffset] & 0x1f;
+    result.idBlock.isConstructed = inputBuffer[inputOffset] === 0x30;
+    result.idBlock.isHexOnly = false;
+    result.idBlock.blockLength = 1;
+    result.lenBlock.isIndefiniteForm = false;
+    result.lenBlock.longFormUsed = false;
+    result.lenBlock.length = length;
+    result.lenBlock.blockLength = 1;
+    context.nodesCount += 1;
+    const resultOffset = result.fromBER(inputBuffer, inputOffset + 2, length, context);
+    result.valueBeforeDecodeView = inputBuffer.subarray(inputOffset, inputOffset + result.blockLength);
+    return { offset: resultOffset, result };
+}
 const DEFAULT_MAX_DEPTH = 100;
 const DEFAULT_MAX_NODES = 10000;
 const DEFAULT_MAX_CONTENT_LENGTH = 16 * 1024 * 1024;
@@ -654,13 +1177,14 @@ const MAX_DEPTH_EXCEEDED_ERROR = "Maximum ASN.1 nesting depth exceeded";
 const MAX_NODES_EXCEEDED_ERROR = "Maximum ASN.1 node count exceeded";
 const MAX_CONTENT_LENGTH_EXCEEDED_ERROR = "Maximum ASN.1 content length exceeded";
 function createFromBerContext(options = {}) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     return {
         depth: 0,
         maxDepth: (_a = options.maxDepth) !== null && _a !== void 0 ? _a : DEFAULT_MAX_DEPTH,
         nodesCount: 0,
         maxNodes: (_b = options.maxNodes) !== null && _b !== void 0 ? _b : DEFAULT_MAX_NODES,
         maxContentLength: (_c = options.maxContentLength) !== null && _c !== void 0 ? _c : DEFAULT_MAX_CONTENT_LENGTH,
+        parseEmbedded: (_d = options.parseEmbedded) !== null && _d !== void 0 ? _d : true
     };
 }
 function createErrorResult(error) {
@@ -668,7 +1192,7 @@ function createErrorResult(error) {
     result.error = error;
     return {
         offset: -1,
-        result,
+        result
     };
 }
 function checkNodesLimit(context) {
@@ -709,22 +1233,23 @@ function localChangeType(inputObject, newType) {
     return newObject;
 }
 function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.length, context = createFromBerContext()) {
+    const fastResult = tryFastFromBER(inputBuffer, inputOffset, inputLength, context);
+    if (fastResult)
+        return fastResult;
     const incomingOffset = inputOffset;
     let returnObject = new BaseBlock({}, ValueBlock);
-    const baseBlock = new LocalBaseBlock();
-    if (!checkBufferParams(baseBlock, inputBuffer, inputOffset, inputLength)) {
-        returnObject.error = baseBlock.error;
+    if (!checkBufferParams(returnObject, inputBuffer, inputOffset, inputLength)) {
         return {
             offset: -1,
-            result: returnObject,
+            result: returnObject
         };
     }
-    const intBuffer = inputBuffer.subarray(inputOffset, inputOffset + inputLength);
-    if (!intBuffer.length) {
+    const fastArgs = Number.isInteger(inputOffset) && Number.isInteger(inputLength);
+    if (fastArgs ? inputLength === 0 : inputBuffer.subarray(inputOffset, inputOffset + inputLength).length === 0) {
         returnObject.error = "Zero buffer length";
         return {
             offset: -1,
-            result: returnObject,
+            result: returnObject
         };
     }
     const nodesLimitError = checkNodesLimit(context);
@@ -732,7 +1257,7 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
         returnObject.error = nodesLimitError;
         return {
             offset: -1,
-            result: returnObject,
+            result: returnObject
         };
     }
     let resultOffset = returnObject.idBlock.fromBER(inputBuffer, inputOffset, inputLength);
@@ -743,7 +1268,7 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
         returnObject.error = returnObject.idBlock.error;
         return {
             offset: -1,
-            result: returnObject,
+            result: returnObject
         };
     }
     inputOffset = resultOffset;
@@ -756,7 +1281,7 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
         returnObject.error = returnObject.lenBlock.error;
         return {
             offset: -1,
-            result: returnObject,
+            result: returnObject
         };
     }
     inputOffset = resultOffset;
@@ -767,36 +1292,33 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
         returnObject.error = contentLengthError;
         return {
             offset: -1,
-            result: returnObject,
+            result: returnObject
         };
     }
-    if (!returnObject.idBlock.isConstructed
-        && returnObject.lenBlock.isIndefiniteForm) {
+    if (!returnObject.idBlock.isConstructed && returnObject.lenBlock.isIndefiniteForm) {
         returnObject.error = "Indefinite length form used for primitive encoding form";
         return {
             offset: -1,
-            result: returnObject,
+            result: returnObject
         };
     }
     let newASN1Type = BaseBlock;
     switch (returnObject.idBlock.tagClass) {
         case 1:
-            if ((returnObject.idBlock.tagNumber >= 37)
-                && (returnObject.idBlock.isHexOnly === false)) {
+            if (returnObject.idBlock.tagNumber >= 37 && returnObject.idBlock.isHexOnly === false) {
                 returnObject.error = "UNIVERSAL 37 and upper tags are reserved by ASN.1 standard";
                 return {
                     offset: -1,
-                    result: returnObject,
+                    result: returnObject
                 };
             }
             switch (returnObject.idBlock.tagNumber) {
                 case 0:
-                    if ((returnObject.idBlock.isConstructed)
-                        && (returnObject.lenBlock.length > 0)) {
+                    if (returnObject.idBlock.isConstructed && returnObject.lenBlock.length > 0) {
                         returnObject.error = "Type [UNIVERSAL 0] is reserved";
                         return {
                             offset: -1,
-                            result: returnObject,
+                            result: returnObject
                         };
                     }
                     newASN1Type = typeStore.EndOfContent;
@@ -835,7 +1357,7 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
                     returnObject.error = "[UNIVERSAL 15] is reserved by ASN.1 standard";
                     return {
                         offset: -1,
-                        result: returnObject,
+                        result: returnObject
                     };
                 case 16:
                     newASN1Type = typeStore.Sequence;
@@ -909,9 +1431,7 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
         case 3:
         case 4:
         default: {
-            newASN1Type = returnObject.idBlock.isConstructed
-                ? typeStore.Constructed
-                : typeStore.Primitive;
+            newASN1Type = returnObject.idBlock.isConstructed ? typeStore.Constructed : typeStore.Primitive;
         }
     }
     returnObject = localChangeType(returnObject, newASN1Type);
@@ -919,7 +1439,7 @@ function localFromBER(inputBuffer, inputOffset = 0, inputLength = inputBuffer.le
     returnObject.valueBeforeDecodeView = inputBuffer.subarray(incomingOffset, incomingOffset + returnObject.blockLength);
     return {
         offset: resultOffset,
-        result: returnObject,
+        result: returnObject
     };
 }
 function fromBER(inputBuffer, options = {}) {
@@ -928,10 +1448,12 @@ function fromBER(inputBuffer, options = {}) {
         result.error = "Input buffer has zero length";
         return {
             offset: -1,
-            result,
+            result
         };
     }
-    return localFromBER(pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer).slice(), 0, inputBuffer.byteLength, createFromBerContext(options));
+    const inputView = pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer);
+    const normalizedInput = options.copyInput === false ? inputView : inputView.slice();
+    return localFromBER(normalizedInput, 0, inputBuffer.byteLength, createFromBerContext(options));
 }
 
 function checkLen(indefiniteLength, length) {
@@ -997,7 +1519,7 @@ class LocalConstructedValueBlock extends ValueBlock {
         const object = {
             ...super.toJSON(),
             isIndefiniteForm: this.isIndefiniteForm,
-            value: [],
+            value: []
         };
         for (const value of this.value) {
             object.value.push(value.toJSON());
@@ -1006,6 +1528,7 @@ class LocalConstructedValueBlock extends ValueBlock {
     }
 }
 LocalConstructedValueBlock.NAME = "ConstructedValueBlock";
+const ORIGINAL_LOCAL_CONSTRUCTED_TO_BER = LocalConstructedValueBlock.prototype.toBER;
 
 var _a$v;
 class Constructed extends BaseBlock {
@@ -1015,7 +1538,7 @@ class Constructed extends BaseBlock {
     }
     fromBER(inputBuffer, inputOffset, inputLength, context) {
         this.valueBlock.isIndefiniteForm = this.lenBlock.isIndefiniteForm;
-        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, (this.lenBlock.isIndefiniteForm) ? inputLength : this.lenBlock.length, context);
+        const resultOffset = this.valueBlock.fromBER(inputBuffer, inputOffset, this.lenBlock.isIndefiniteForm ? inputLength : this.lenBlock.length, context);
         if (resultOffset === -1) {
             this.error = this.valueBlock.error;
             return resultOffset;
@@ -1031,11 +1554,13 @@ class Constructed extends BaseBlock {
     onAsciiEncoding() {
         const values = [];
         for (const value of this.valueBlock.value) {
-            values.push(value.toString("ascii").split("\n").map((o) => `  ${o}`).join("\n"));
+            values.push(value
+                .toString("ascii")
+                .split("\n")
+                .map(o => `  ${o}`)
+                .join("\n"));
         }
-        const blockName = this.idBlock.tagClass === 3
-            ? `[${this.idBlock.tagNumber}]`
-            : this.constructor.NAME;
+        const blockName = this.idBlock.tagClass === 3 ? `[${this.idBlock.tagNumber}]` : this.constructor.NAME;
         return values.length
             ? `${blockName} :\n${values.join("\n")}`
             : `${blockName} :`;
@@ -1086,11 +1611,11 @@ class Null extends BaseBlock {
         if (!this.lenBlock.error.length)
             this.blockLength += this.lenBlock.blockLength;
         this.blockLength += inputLength;
-        if ((inputOffset + inputLength) > inputBuffer.byteLength) {
+        if (inputOffset + inputLength > inputBuffer.byteLength) {
             this.error = "End of input reached before message was fully decoded (inconsistent offset and length values)";
             return -1;
         }
-        return (inputOffset + inputLength);
+        return inputOffset + inputLength;
     }
     toBER(sizeOnly, writer) {
         const retBuf = new ArrayBuffer(2);
@@ -1124,7 +1649,7 @@ class LocalBooleanValueBlock extends HexBlock(ValueBlock) {
         return false;
     }
     set value(value) {
-        this.valueHexView[0] = value ? 0xFF : 0x00;
+        this.valueHexView[0] = value ? 0xff : 0x00;
     }
     constructor({ value, ...parameters } = {}) {
         super(parameters);
@@ -1149,15 +1674,15 @@ class LocalBooleanValueBlock extends HexBlock(ValueBlock) {
         this.isHexOnly = true;
         pvutils__namespace.utilDecodeTC.call(this);
         this.blockLength = inputLength;
-        return (inputOffset + inputLength);
+        return inputOffset + inputLength;
     }
     toBER() {
-        return this.valueHexView.slice();
+        return this.valueHexView.slice().buffer;
     }
     toJSON() {
         return {
             ...super.toJSON(),
-            value: this.value,
+            value: this.value
         };
     }
 }
@@ -1224,18 +1749,17 @@ class LocalOctetStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
     toBER(sizeOnly, writer) {
         if (this.isConstructed)
             return LocalConstructedValueBlock.prototype.toBER.call(this, sizeOnly, writer);
-        return sizeOnly
-            ? new ArrayBuffer(this.valueHexView.byteLength)
-            : this.valueHexView.slice().buffer;
+        return sizeOnly ? new ArrayBuffer(this.valueHexView.byteLength) : this.valueHexView.slice().buffer;
     }
     toJSON() {
         return {
             ...super.toJSON(),
-            isConstructed: this.isConstructed,
+            isConstructed: this.isConstructed
         };
     }
 }
 LocalOctetStringValueBlock.NAME = "OctetStringValueBlock";
+const ORIGINAL_LOCAL_OCTET_STRING_TO_BER = LocalOctetStringValueBlock.prototype.toBER;
 
 var _a$r;
 class OctetString extends BaseBlock {
@@ -1245,13 +1769,13 @@ class OctetString extends BaseBlock {
         super({
             idBlock: {
                 isConstructed: parameters.isConstructed,
-                ...idBlock,
+                ...idBlock
             },
             lenBlock: {
                 ...lenBlock,
-                isIndefiniteForm: !!parameters.isIndefiniteForm,
+                isIndefiniteForm: !!parameters.isIndefiniteForm
             },
-            ...parameters,
+            ...parameters
         }, LocalOctetStringValueBlock);
         this.idBlock.tagClass = 1;
         this.idBlock.tagNumber = 4;
@@ -1266,7 +1790,7 @@ class OctetString extends BaseBlock {
                 this.blockLength += this.lenBlock.blockLength;
             return inputOffset;
         }
-        if (!this.valueBlock.isConstructed) {
+        if (!this.valueBlock.isConstructed && (context === null || context === void 0 ? void 0 : context.parseEmbedded) !== false) {
             const view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
             const buf = view.subarray(inputOffset, inputOffset + inputLength);
             try {
@@ -1341,8 +1865,8 @@ class LocalBitStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
                     return -1;
                 }
                 const valueBlock = value.valueBlock;
-                if ((this.unusedBits > 0) && (valueBlock.unusedBits > 0)) {
-                    this.error = "Using of \"unused bits\" inside constructive BIT STRING allowed for least one only";
+                if (this.unusedBits > 0 && valueBlock.unusedBits > 0) {
+                    this.error = 'Using of "unused bits" inside constructive BIT STRING allowed for least one only';
                     return -1;
                 }
                 this.unusedBits = valueBlock.unusedBits;
@@ -1359,13 +1883,13 @@ class LocalBitStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
             this.error = "Unused bits for BitString must be in range 0-7";
             return -1;
         }
-        if (!this.unusedBits) {
+        if (!this.unusedBits && (context === null || context === void 0 ? void 0 : context.parseEmbedded) !== false) {
             const buf = intBuffer.subarray(1);
             try {
                 if (buf.byteLength) {
                     const parseContext = context !== null && context !== void 0 ? context : createFromBerContext();
                     const asn = localFromBERWithChildContext(buf, 0, buf.byteLength, parseContext);
-                    if (asn.offset !== -1 && asn.offset === (inputLength - 1)) {
+                    if (asn.offset !== -1 && asn.offset === inputLength - 1) {
                         this.value = [asn.result];
                     }
                 }
@@ -1375,7 +1899,7 @@ class LocalBitStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
         }
         this.valueHexView = intBuffer.subarray(1);
         this.blockLength = intBuffer.length;
-        return (inputOffset + inputLength);
+        return inputOffset + inputLength;
     }
     toBER(sizeOnly, writer) {
         if (this.isConstructed) {
@@ -1398,11 +1922,12 @@ class LocalBitStringValueBlock extends HexBlock(LocalConstructedValueBlock) {
         return {
             ...super.toJSON(),
             unusedBits: this.unusedBits,
-            isConstructed: this.isConstructed,
+            isConstructed: this.isConstructed
         };
     }
 }
 LocalBitStringValueBlock.NAME = "BitStringValueBlock";
+const ORIGINAL_LOCAL_BIT_STRING_TO_BER = LocalBitStringValueBlock.prototype.toBER;
 
 var _a$q;
 class BitString extends BaseBlock {
@@ -1412,13 +1937,13 @@ class BitString extends BaseBlock {
         super({
             idBlock: {
                 isConstructed: parameters.isConstructed,
-                ...idBlock,
+                ...idBlock
             },
             lenBlock: {
                 ...lenBlock,
-                isIndefiniteForm: !!parameters.isIndefiniteForm,
+                isIndefiniteForm: !!parameters.isIndefiniteForm
             },
-            ...parameters,
+            ...parameters
         }, LocalBitStringValueBlock);
         this.idBlock.tagClass = 1;
         this.idBlock.tagNumber = 3;
@@ -1451,94 +1976,53 @@ _a$q = BitString;
 })();
 BitString.NAME = BIT_STRING_NAME;
 
-var _a$p;
-function viewAdd(first, second) {
-    const c = new Uint8Array([0]);
-    const firstView = new Uint8Array(first);
-    const secondView = new Uint8Array(second);
-    let firstViewCopy = firstView.slice(0);
-    const firstViewCopyLength = firstViewCopy.length - 1;
-    const secondViewCopy = secondView.slice(0);
-    const secondViewCopyLength = secondViewCopy.length - 1;
-    let value = 0;
-    const max = (secondViewCopyLength < firstViewCopyLength) ? firstViewCopyLength : secondViewCopyLength;
-    let counter = 0;
-    for (let i = max; i >= 0; i--, counter++) {
-        switch (true) {
-            case (counter < secondViewCopy.length):
-                value = firstViewCopy[firstViewCopyLength - counter] + secondViewCopy[secondViewCopyLength - counter] + c[0];
-                break;
-            default:
-                value = firstViewCopy[firstViewCopyLength - counter] + c[0];
-        }
-        c[0] = value / 10;
-        switch (true) {
-            case (counter >= firstViewCopy.length):
-                firstViewCopy = pvutils__namespace.utilConcatView(new Uint8Array([value % 10]), firstViewCopy);
-                break;
-            default:
-                firstViewCopy[firstViewCopyLength - counter] = value % 10;
-        }
-    }
-    if (c[0] > 0)
-        firstViewCopy = pvutils__namespace.utilConcatView(c, firstViewCopy);
-    return firstViewCopy;
-}
-function power2(n) {
-    if (n >= powers2.length) {
-        for (let p = powers2.length; p <= n; p++) {
-            const c = new Uint8Array([0]);
-            let digits = (powers2[p - 1]).slice(0);
-            for (let i = (digits.length - 1); i >= 0; i--) {
-                const newValue = new Uint8Array([(digits[i] << 1) + c[0]]);
-                c[0] = newValue[0] / 10;
-                digits[i] = newValue[0] % 10;
-            }
-            if (c[0] > 0)
-                digits = pvutils__namespace.utilConcatView(c, digits);
-            powers2.push(digits);
-        }
-    }
-    return powers2[n];
-}
-function viewSub(first, second) {
-    let b = 0;
-    const firstView = new Uint8Array(first);
-    const secondView = new Uint8Array(second);
-    const firstViewCopy = firstView.slice(0);
-    const firstViewCopyLength = firstViewCopy.length - 1;
-    const secondViewCopy = secondView.slice(0);
-    const secondViewCopyLength = secondViewCopy.length - 1;
-    let value;
-    let counter = 0;
-    for (let i = secondViewCopyLength; i >= 0; i--, counter++) {
-        value = firstViewCopy[firstViewCopyLength - counter] - secondViewCopy[secondViewCopyLength - counter] - b;
-        switch (true) {
-            case (value < 0):
-                b = 1;
-                firstViewCopy[firstViewCopyLength - counter] = value + 10;
-                break;
-            default:
-                b = 0;
-                firstViewCopy[firstViewCopyLength - counter] = value;
-        }
-    }
-    if (b > 0) {
-        for (let i = (firstViewCopyLength - secondViewCopyLength + 1); i >= 0; i--, counter++) {
-            value = firstViewCopy[firstViewCopyLength - counter] - b;
-            if (value < 0) {
-                b = 1;
-                firstViewCopy[firstViewCopyLength - counter] = value + 10;
-            }
-            else {
-                b = 0;
-                firstViewCopy[firstViewCopyLength - counter] = value;
-                break;
-            }
-        }
-    }
-    return firstViewCopy.slice();
+function bytesToSignedBigInt(view) {
+    if (!view.byteLength)
+        return BigInt(0);
+    const value = BigInt(`0x${pvtsutils__namespace.Convert.ToHex(view)}`);
+    if (view[0] & 0x80)
+        return value - (BigInt(1) << BigInt(view.byteLength * 8));
+    return value;
+}
+function bytesToSignedDecimal(view) {
+    if (typeof BigInt !== "undefined")
+        return bytesToSignedBigInt(view).toString(10);
+    const BASE = 10000000;
+    const DECIMAL_DIGITS = 7;
+    if (!view.byteLength)
+        return "0";
+    const negative = !!(view[0] & 0x80);
+    let magnitude = view;
+    if (negative) {
+        magnitude = new Uint8Array(view.length);
+        let carry = 1;
+        for (let i = view.length - 1; i >= 0; i--) {
+            const value = (view[i] ^ 0xff) + carry;
+            magnitude[i] = value & 0xff;
+            carry = value >> 8;
+        }
+    }
+    const limbs = [0];
+    for (let index = 0; index < magnitude.length; index++) {
+        let carry = magnitude[index];
+        for (let i = 0; i < limbs.length; i++) {
+            const value = limbs[i] * 256 + carry;
+            limbs[i] = value % BASE;
+            carry = Math.floor(value / BASE);
+        }
+        if (carry)
+            limbs.push(carry);
+    }
+    let top = limbs.length - 1;
+    while (top > 0 && limbs[top] === 0)
+        top--;
+    let result = String(limbs[top]);
+    for (let i = top - 1; i >= 0; i--)
+        result += String(limbs[i]).padStart(DECIMAL_DIGITS, "0");
+    return negative && result !== "0" ? `-${result}` : result;
 }
+
+var _a$p;
 class LocalIntegerValueBlock extends HexBlock(ValueBlock) {
     setValueHex() {
         if (this.valueHexView.length >= 4) {
@@ -1576,13 +2060,13 @@ class LocalIntegerValueBlock extends HexBlock(ValueBlock) {
         if (offset === -1)
             return offset;
         const view = this.valueHexView;
-        if ((view[0] === 0x00) && ((view[1] & 0x80) !== 0)) {
+        if (view[0] === 0x00 && (view[1] & 0x80) !== 0) {
             this.valueHexView = view.subarray(1);
         }
         else {
             if (expectedLength !== 0) {
                 if (view.length < expectedLength) {
-                    if ((expectedLength - view.length) > 1)
+                    if (expectedLength - view.length > 1)
                         expectedLength = view.length + 1;
                     this.valueHexView = view.subarray(expectedLength - view.length);
                 }
@@ -1593,7 +2077,7 @@ class LocalIntegerValueBlock extends HexBlock(ValueBlock) {
     toDER(sizeOnly = false) {
         const view = this.valueHexView;
         switch (true) {
-            case ((view[0] & 0x80) !== 0):
+            case (view[0] & 0x80) !== 0:
                 {
                     const updatedView = new Uint8Array(this.valueHexView.length + 1);
                     updatedView[0] = 0x00;
@@ -1601,7 +2085,7 @@ class LocalIntegerValueBlock extends HexBlock(ValueBlock) {
                     this.valueHexView = updatedView;
                 }
                 break;
-            case ((view[0] === 0x00) && ((view[1] & 0x80) === 0)):
+            case view[0] === 0x00 && (view[1] & 0x80) === 0:
                 {
                     this.valueHexView = this.valueHexView.subarray(1);
                 }
@@ -1618,50 +2102,16 @@ class LocalIntegerValueBlock extends HexBlock(ValueBlock) {
         return resultOffset;
     }
     toBER(sizeOnly) {
-        return sizeOnly
-            ? new ArrayBuffer(this.valueHexView.length)
-            : this.valueHexView.slice().buffer;
+        return sizeOnly ? new ArrayBuffer(this.valueHexView.length) : this.valueHexView.slice().buffer;
     }
     toJSON() {
         return {
             ...super.toJSON(),
-            valueDec: this.valueDec,
+            valueDec: this.valueDec
         };
     }
     toString() {
-        const firstBit = (this.valueHexView.length * 8) - 1;
-        let digits = new Uint8Array((this.valueHexView.length * 8) / 3);
-        let bitNumber = 0;
-        let currentByte;
-        const asn1View = this.valueHexView;
-        let result = "";
-        let flag = false;
-        for (let byteNumber = (asn1View.byteLength - 1); byteNumber >= 0; byteNumber--) {
-            currentByte = asn1View[byteNumber];
-            for (let i = 0; i < 8; i++) {
-                if ((currentByte & 1) === 1) {
-                    switch (bitNumber) {
-                        case firstBit:
-                            digits = viewSub(power2(bitNumber), digits);
-                            result = "-";
-                            break;
-                        default:
-                            digits = viewAdd(digits, power2(bitNumber));
-                    }
-                }
-                bitNumber++;
-                currentByte >>= 1;
-            }
-        }
-        for (let i = 0; i < digits.length; i++) {
-            if (digits[i])
-                flag = true;
-            if (flag)
-                result += digitsString.charAt(digits[i]);
-        }
-        if (flag === false)
-            result += digitsString.charAt(0);
-        return result;
+        return bytesToSignedDecimal(this.valueHexView);
     }
 }
 _a$p = LocalIntegerValueBlock;
@@ -1674,9 +2124,11 @@ LocalIntegerValueBlock.NAME = "IntegerValueBlock";
         },
         get: function () {
             return this.valueHexView.slice().buffer;
-        },
+        }
     });
 })();
+const ORIGINAL_LOCAL_INTEGER_TO_BER = LocalIntegerValueBlock.prototype.toBER;
+const ORIGINAL_LOCAL_INTEGER_TO_STRING = LocalIntegerValueBlock.prototype.toString;
 
 var _a$o;
 class Integer extends BaseBlock {
@@ -1687,7 +2139,11 @@ class Integer extends BaseBlock {
     }
     toBigInt() {
         assertBigInt();
-        return BigInt(this.valueBlock.toString());
+        const valueBlock = this.valueBlock;
+        const toString = valueBlock.toString;
+        if (toString === ORIGINAL_LOCAL_INTEGER_TO_STRING)
+            return bytesToSignedBigInt(valueBlock.valueHexView);
+        return BigInt(Reflect.apply(toString, valueBlock, []));
     }
     static fromBigInt(value) {
         assertBigInt();
@@ -1720,9 +2176,7 @@ class Integer extends BaseBlock {
     }
     convertFromDER() {
         return new _a$o({
-            valueHex: this.valueBlock.valueHexView[0] === 0
-                ? this.valueBlock.valueHexView.subarray(1)
-                : this.valueBlock.valueHexView,
+            valueHex: this.valueBlock.valueHexView[0] === 0 ? this.valueBlock.valueHexView.subarray(1) : this.valueBlock.valueHexView
         });
     }
     onAsciiEncoding() {
@@ -1764,18 +2218,34 @@ class LocalSidValueBlock extends HexBlock(ValueBlock) {
             return -1;
         }
         const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
-        this.valueHexView = new Uint8Array(inputLength);
-        for (let i = 0; i < inputLength; i++) {
-            this.valueHexView[i] = intBuffer[i] & 0x7F;
-            this.blockLength++;
-            if ((intBuffer[i] & 0x80) === 0x00)
-                break;
+        const fastPath = this.blockLength === 0 && Number.isInteger(inputOffset) && Number.isInteger(inputLength);
+        if (fastPath) {
+            let sidLength = 0;
+            while (sidLength < inputLength) {
+                const octet = intBuffer[sidLength];
+                sidLength++;
+                if ((octet & 0x80) === 0x00)
+                    break;
+            }
+            this.blockLength = sidLength;
+            this.valueHexView = new Uint8Array(sidLength);
+            for (let i = 0; i < sidLength; i++)
+                this.valueHexView[i] = intBuffer[i] & 0x7f;
         }
-        const tempView = new Uint8Array(this.blockLength);
-        for (let i = 0; i < this.blockLength; i++) {
-            tempView[i] = this.valueHexView[i];
+        else {
+            this.valueHexView = new Uint8Array(inputLength);
+            for (let i = 0; i < inputLength; i++) {
+                this.valueHexView[i] = intBuffer[i] & 0x7f;
+                this.blockLength++;
+                if ((intBuffer[i] & 0x80) === 0x00)
+                    break;
+            }
+            const tempView = new Uint8Array(this.blockLength);
+            for (let i = 0; i < this.blockLength; i++) {
+                tempView[i] = this.valueHexView[i];
+            }
+            this.valueHexView = tempView;
         }
-        this.valueHexView = tempView;
         if ((intBuffer[this.blockLength - 1] & 0x80) !== 0x00) {
             this.error = "End of input reached before message was fully decoded";
             return -1;
@@ -1788,7 +2258,7 @@ class LocalSidValueBlock extends HexBlock(ValueBlock) {
             this.isHexOnly = true;
             this.warnings.push("Too big SID for decoding, hex only");
         }
-        return (inputOffset + this.blockLength);
+        return inputOffset + this.blockLength;
     }
     set valueBigInt(value) {
         assertBigInt();
@@ -1805,13 +2275,13 @@ class LocalSidValueBlock extends HexBlock(ValueBlock) {
     toBER(sizeOnly) {
         if (this.isHexOnly) {
             if (sizeOnly)
-                return (new ArrayBuffer(this.valueHexView.byteLength));
+                return new ArrayBuffer(this.valueHexView.byteLength);
             const curView = this.valueHexView;
             const retView = new Uint8Array(this.blockLength);
-            for (let i = 0; i < (this.blockLength - 1); i++)
+            for (let i = 0; i < this.blockLength - 1; i++)
                 retView[i] = curView[i] | 0x80;
             retView[this.blockLength - 1] = curView[this.blockLength - 1];
-            return retView.buffer;
+            return pvtsutils__namespace.BufferSourceConverter.toArrayBuffer(retView);
         }
         const encodedBuf = pvutils__namespace.utilToBase(this.valueDec, 7);
         if (encodedBuf.byteLength === 0) {
@@ -1826,7 +2296,7 @@ class LocalSidValueBlock extends HexBlock(ValueBlock) {
                 retView[i] = encodedView[i] | 0x80;
             retView[len] = encodedView[len];
         }
-        return retView;
+        return pvtsutils__namespace.BufferSourceConverter.toArrayBuffer(retView);
     }
     toString() {
         let result = "";
@@ -1858,7 +2328,7 @@ class LocalSidValueBlock extends HexBlock(ValueBlock) {
         return {
             ...super.toJSON(),
             valueDec: this.valueDec,
-            isFirstSid: this.isFirstSid,
+            isFirstSid: this.isFirstSid
         };
     }
 }
@@ -1981,7 +2451,7 @@ class LocalObjectIdentifierValueBlock extends ValueBlock {
         const object = {
             ...super.toJSON(),
             value: this.toString(),
-            sidArray: [],
+            sidArray: []
         };
         for (let i = 0; i < this.value.length; i++) {
             object.sidArray.push(this.value[i].toJSON());
@@ -2010,7 +2480,7 @@ class ObjectIdentifier extends BaseBlock {
     toJSON() {
         return {
             ...super.toJSON(),
-            value: this.getValue(),
+            value: this.getValue()
         };
     }
 }
@@ -2032,17 +2502,33 @@ class LocalRelativeSidValueBlock extends HexBlock(LocalBaseBlock) {
         if (!checkBufferParams(this, inputView, inputOffset, inputLength))
             return -1;
         const intBuffer = inputView.subarray(inputOffset, inputOffset + inputLength);
-        this.valueHexView = new Uint8Array(inputLength);
-        for (let i = 0; i < inputLength; i++) {
-            this.valueHexView[i] = intBuffer[i] & 0x7F;
-            this.blockLength++;
-            if ((intBuffer[i] & 0x80) === 0x00)
-                break;
+        const fastPath = this.blockLength === 0 && Number.isInteger(inputOffset) && Number.isInteger(inputLength);
+        if (fastPath) {
+            let sidLength = 0;
+            while (sidLength < inputLength) {
+                const octet = intBuffer[sidLength];
+                sidLength++;
+                if ((octet & 0x80) === 0x00)
+                    break;
+            }
+            this.blockLength = sidLength;
+            this.valueHexView = new Uint8Array(sidLength);
+            for (let i = 0; i < sidLength; i++)
+                this.valueHexView[i] = intBuffer[i] & 0x7f;
+        }
+        else {
+            this.valueHexView = new Uint8Array(inputLength);
+            for (let i = 0; i < inputLength; i++) {
+                this.valueHexView[i] = intBuffer[i] & 0x7f;
+                this.blockLength++;
+                if ((intBuffer[i] & 0x80) === 0x00)
+                    break;
+            }
+            const tempView = new Uint8Array(this.blockLength);
+            for (let i = 0; i < this.blockLength; i++)
+                tempView[i] = this.valueHexView[i];
+            this.valueHexView = tempView;
         }
-        const tempView = new Uint8Array(this.blockLength);
-        for (let i = 0; i < this.blockLength; i++)
-            tempView[i] = this.valueHexView[i];
-        this.valueHexView = tempView;
         if ((intBuffer[this.blockLength - 1] & 0x80) !== 0x00) {
             this.error = "End of input reached before message was fully decoded";
             return -1;
@@ -2055,15 +2541,15 @@ class LocalRelativeSidValueBlock extends HexBlock(LocalBaseBlock) {
             this.isHexOnly = true;
             this.warnings.push("Too big SID for decoding, hex only");
         }
-        return (inputOffset + this.blockLength);
+        return inputOffset + this.blockLength;
     }
     toBER(sizeOnly) {
         if (this.isHexOnly) {
             if (sizeOnly)
-                return (new ArrayBuffer(this.valueHexView.byteLength));
+                return new ArrayBuffer(this.valueHexView.byteLength);
             const curView = this.valueHexView;
             const retView = new Uint8Array(this.blockLength);
-            for (let i = 0; i < (this.blockLength - 1); i++)
+            for (let i = 0; i < this.blockLength - 1; i++)
                 retView[i] = curView[i] | 0x80;
             retView[this.blockLength - 1] = curView[this.blockLength - 1];
             return retView.buffer;
@@ -2095,7 +2581,7 @@ class LocalRelativeSidValueBlock extends HexBlock(LocalBaseBlock) {
     toJSON() {
         return {
             ...super.toJSON(),
-            valueDec: this.valueDec,
+            valueDec: this.valueDec
         };
     }
 }
@@ -2178,7 +2664,7 @@ class LocalRelativeObjectIdentifierValueBlock extends ValueBlock {
         const object = {
             ...super.toJSON(),
             value: this.toString(),
-            sidArray: [],
+            sidArray: []
         };
         for (let i = 0; i < this.value.length; i++)
             object.sidArray.push(this.value[i].toJSON());
@@ -2206,7 +2692,7 @@ class RelativeObjectIdentifier extends BaseBlock {
     toJSON() {
         return {
             ...super.toJSON(),
-            value: this.getValue(),
+            value: this.getValue()
         };
     }
 }
@@ -2253,7 +2739,7 @@ class LocalStringValueBlock extends HexBlock(ValueBlock) {
     toJSON() {
         return {
             ...super.toJSON(),
-            value: this.value,
+            value: this.value
         };
     }
 }
@@ -2272,7 +2758,7 @@ class LocalSimpleStringBlock extends BaseStringBlock {
     }
     fromString(inputString) {
         const strLen = inputString.length;
-        const view = this.valueBlock.valueHexView = new Uint8Array(strLen);
+        const view = (this.valueBlock.valueHexView = new Uint8Array(strLen));
         for (let i = 0; i < strLen; i++)
             view[i] = inputString.charCodeAt(i);
         this.valueBlock.value = inputString;
@@ -2352,14 +2838,14 @@ class LocalUniversalStringValueBlock extends LocalSimpleStringBlock {
     }
     fromString(inputString) {
         const strLength = inputString.length;
-        const valueHexView = this.valueBlock.valueHexView = new Uint8Array(strLength * 4);
+        const valueHexView = (this.valueBlock.valueHexView = new Uint8Array(strLength * 4));
         for (let i = 0; i < strLength; i++) {
             const codeBuf = pvutils__namespace.utilToBase(inputString.charCodeAt(i), 8);
             const codeView = new Uint8Array(codeBuf);
             if (codeView.length > 4)
                 continue;
             const dif = 4 - codeView.length;
-            for (let j = (codeView.length - 1); j >= 0; j--)
+            for (let j = codeView.length - 1; j >= 0; j--)
                 valueHexView[i * 4 + j + dif] = codeView[j];
         }
         this.valueBlock.value = inputString;
@@ -2550,10 +3036,10 @@ class UTCTime extends VisibleString {
         this.second = inputDate.getUTCSeconds();
     }
     toDate() {
-        return (new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second)));
+        return new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second));
     }
     fromString(inputString) {
-        const parser = /(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})Z/ig;
+        const parser = /(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})Z/gi;
         const parserArray = parser.exec(inputString);
         if (parserArray === null) {
             this.error = "Wrong input string for conversion";
@@ -2572,8 +3058,8 @@ class UTCTime extends VisibleString {
     }
     toString(encoding = "iso") {
         if (encoding === "iso") {
-            const outputArray = new Array(7);
-            outputArray[0] = pvutils__namespace.padNumber(((this.year < 2000) ? (this.year - 1900) : (this.year - 2000)), 2);
+            const outputArray = Array.from({ length: 7 });
+            outputArray[0] = pvutils__namespace.padNumber(this.year < 2000 ? this.year - 1900 : this.year - 2000, 2);
             outputArray[1] = pvutils__namespace.padNumber(this.month, 2);
             outputArray[2] = pvutils__namespace.padNumber(this.day, 2);
             outputArray[3] = pvutils__namespace.padNumber(this.hour, 2);
@@ -2595,7 +3081,7 @@ class UTCTime extends VisibleString {
             day: this.day,
             hour: this.hour,
             minute: this.minute,
-            second: this.second,
+            second: this.second
         };
     }
 }
@@ -2620,7 +3106,7 @@ class GeneralizedTime extends UTCTime {
     }
     toDate() {
         const utcDate = Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond);
-        return (new Date(utcDate));
+        return new Date(utcDate);
     }
     fromString(inputString) {
         let isUTC = false;
@@ -2657,7 +3143,7 @@ class GeneralizedTime extends UTCTime {
             if (differencePosition !== -1) {
                 differenceString = timeString.substring(differencePosition + 1);
                 timeString = timeString.substring(0, differencePosition);
-                if ((differenceString.length !== 2) && (differenceString.length !== 4))
+                if (differenceString.length !== 2 && differenceString.length !== 4)
                     throw new Error("Wrong input string for conversion");
                 let number = parseInt(differenceString.substring(0, 2), 10);
                 if (isNaN(number.valueOf()))
@@ -2684,13 +3170,13 @@ class GeneralizedTime extends UTCTime {
         else
             dateTimeString = timeString;
         switch (true) {
-            case (dateTimeString.length === 8):
-                parser = /(\d{4})(\d{2})(\d{2})/ig;
+            case dateTimeString.length === 8:
+                parser = /(\d{4})(\d{2})(\d{2})/gi;
                 if (fractionPointPosition !== -1)
                     throw new Error("Wrong input string for conversion");
                 break;
-            case (dateTimeString.length === 10):
-                parser = /(\d{4})(\d{2})(\d{2})(\d{2})/ig;
+            case dateTimeString.length === 10:
+                parser = /(\d{4})(\d{2})(\d{2})(\d{2})/gi;
                 if (fractionPointPosition !== -1) {
                     let fractionResult = 60 * fractionPart;
                     this.minute = Math.floor(fractionResult);
@@ -2700,8 +3186,8 @@ class GeneralizedTime extends UTCTime {
                     this.millisecond = Math.floor(fractionResult);
                 }
                 break;
-            case (dateTimeString.length === 12):
-                parser = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})/ig;
+            case dateTimeString.length === 12:
+                parser = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})/gi;
                 if (fractionPointPosition !== -1) {
                     let fractionResult = 60 * fractionPart;
                     this.second = Math.floor(fractionResult);
@@ -2709,8 +3195,8 @@ class GeneralizedTime extends UTCTime {
                     this.millisecond = Math.floor(fractionResult);
                 }
                 break;
-            case (dateTimeString.length === 14):
-                parser = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/ig;
+            case dateTimeString.length === 14:
+                parser = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/gi;
                 if (fractionPointPosition !== -1) {
                     const fractionResult = 1000 * fractionPart;
                     this.millisecond = Math.floor(fractionResult);
@@ -2768,7 +3254,7 @@ class GeneralizedTime extends UTCTime {
             outputArray.push(pvutils__namespace.padNumber(this.second, 2));
             if (this.millisecond !== 0) {
                 outputArray.push(".");
-                outputArray.push(pvutils__namespace.padNumber(this.millisecond, 3));
+                outputArray.push(pvutils__namespace.padNumber(this.millisecond, 3).replace(/0+$/, ""));
             }
             outputArray.push("Z");
             return outputArray.join("");
@@ -2778,7 +3264,7 @@ class GeneralizedTime extends UTCTime {
     toJSON() {
         return {
             ...super.toJSON(),
-            millisecond: this.millisecond,
+            millisecond: this.millisecond
         };
     }
 }
@@ -2907,14 +3393,14 @@ function compareSchema(root, inputData, inputSchema) {
             if (result.verified) {
                 return {
                     verified: true,
-                    result: root,
+                    result: root
                 };
             }
         }
         {
             const _result = {
                 verified: false,
-                result: { error: "Wrong values for Choice type" },
+                result: { error: "Wrong values for Choice type" }
             };
             if (inputSchema.hasOwnProperty(NAME))
                 _result.name = inputSchema.name;
@@ -2926,112 +3412,112 @@ function compareSchema(root, inputData, inputSchema) {
             root[inputSchema.name] = inputData;
         return {
             verified: true,
-            result: root,
+            result: root
         };
     }
-    if ((root instanceof Object) === false) {
+    if (root instanceof Object === false) {
         return {
             verified: false,
-            result: { error: "Wrong root object" },
+            result: { error: "Wrong root object" }
         };
     }
-    if ((inputData instanceof Object) === false) {
+    if (inputData instanceof Object === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 data" },
+            result: { error: "Wrong ASN.1 data" }
         };
     }
-    if ((inputSchema instanceof Object) === false) {
+    if (inputSchema instanceof Object === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
-    if ((ID_BLOCK in inputSchema) === false) {
+    if (ID_BLOCK in inputSchema === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
-    if ((FROM_BER in inputSchema.idBlock) === false) {
+    if (FROM_BER in inputSchema.idBlock === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
-    if ((TO_BER in inputSchema.idBlock) === false) {
+    if (TO_BER in inputSchema.idBlock === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
     const encodedId = inputSchema.idBlock.toBER(false);
     if (encodedId.byteLength === 0) {
         return {
             verified: false,
-            result: { error: "Error encoding idBlock for ASN.1 schema" },
+            result: { error: "Error encoding idBlock for ASN.1 schema" }
         };
     }
     const decodedOffset = inputSchema.idBlock.fromBER(encodedId, 0, encodedId.byteLength);
     if (decodedOffset === -1) {
         return {
             verified: false,
-            result: { error: "Error decoding idBlock for ASN.1 schema" },
+            result: { error: "Error decoding idBlock for ASN.1 schema" }
         };
     }
     if (inputSchema.idBlock.hasOwnProperty(TAG_CLASS) === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
     if (inputSchema.idBlock.tagClass !== inputData.idBlock.tagClass) {
         return {
             verified: false,
-            result: root,
+            result: root
         };
     }
     if (inputSchema.idBlock.hasOwnProperty(TAG_NUMBER) === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
     if (inputSchema.idBlock.tagNumber !== inputData.idBlock.tagNumber) {
         return {
             verified: false,
-            result: root,
+            result: root
         };
     }
     if (inputSchema.idBlock.hasOwnProperty(IS_CONSTRUCTED) === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
     if (inputSchema.idBlock.isConstructed !== inputData.idBlock.isConstructed) {
         return {
             verified: false,
-            result: root,
+            result: root
         };
     }
     if (!(IS_HEX_ONLY in inputSchema.idBlock)) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema" },
+            result: { error: "Wrong ASN.1 schema" }
         };
     }
     if (inputSchema.idBlock.isHexOnly !== inputData.idBlock.isHexOnly) {
         return {
             verified: false,
-            result: root,
+            result: root
         };
     }
     if (inputSchema.idBlock.isHexOnly) {
-        if ((VALUE_HEX_VIEW in inputSchema.idBlock) === false) {
+        if (VALUE_HEX_VIEW in inputSchema.idBlock === false) {
             return {
                 verified: false,
-                result: { error: "Wrong ASN.1 schema" },
+                result: { error: "Wrong ASN.1 schema" }
             };
         }
         const schemaView = inputSchema.idBlock.valueHexView;
@@ -3039,14 +3525,14 @@ function compareSchema(root, inputData, inputSchema) {
         if (schemaView.length !== asn1View.length) {
             return {
                 verified: false,
-                result: root,
+                result: root
             };
         }
         for (let i = 0; i < schemaView.length; i++) {
             if (schemaView[i] !== asn1View[1]) {
                 return {
                     verified: false,
-                    result: root,
+                    result: root
                 };
             }
         }
@@ -3060,7 +3546,7 @@ function compareSchema(root, inputData, inputSchema) {
         let admission = 0;
         let result = {
             verified: false,
-            result: { error: "Unknown error" },
+            result: { error: "Unknown error" }
         };
         let maxLength = inputSchema.valueBlock.value.length;
         if (maxLength > 0) {
@@ -3071,18 +3557,17 @@ function compareSchema(root, inputData, inputSchema) {
         if (maxLength === 0) {
             return {
                 verified: true,
-                result: root,
+                result: root
             };
         }
-        if ((inputData.valueBlock.value.length === 0)
-            && (inputSchema.valueBlock.value.length !== 0)) {
+        if (inputData.valueBlock.value.length === 0 && inputSchema.valueBlock.value.length !== 0) {
             let _optional = true;
             for (let i = 0; i < inputSchema.valueBlock.value.length; i++)
                 _optional = _optional && (inputSchema.valueBlock.value[i].optional || false);
             if (_optional) {
                 return {
                     verified: true,
-                    result: root,
+                    result: root
                 };
             }
             if (inputSchema.name) {
@@ -3093,15 +3578,15 @@ function compareSchema(root, inputData, inputSchema) {
             root.error = "Inconsistent object length";
             return {
                 verified: false,
-                result: root,
+                result: root
             };
         }
         for (let i = 0; i < maxLength; i++) {
-            if ((i - admission) >= inputData.valueBlock.value.length) {
+            if (i - admission >= inputData.valueBlock.value.length) {
                 if (inputSchema.valueBlock.value[i].optional === false) {
                     const _result = {
                         verified: false,
-                        result: root,
+                        result: root
                     };
                     root.error = "Inconsistent length between ASN.1 data and schema";
                     if (inputSchema.name) {
@@ -3129,9 +3614,9 @@ function compareSchema(root, inputData, inputSchema) {
                             return result;
                         }
                     }
-                    if ((NAME in inputSchema.valueBlock.value[0]) && (inputSchema.valueBlock.value[0].name.length > 0)) {
+                    if (NAME in inputSchema.valueBlock.value[0] && inputSchema.valueBlock.value[0].name.length > 0) {
                         let arrayRoot = {};
-                        if ((LOCAL in inputSchema.valueBlock.value[0]) && (inputSchema.valueBlock.value[0].local))
+                        if (LOCAL in inputSchema.valueBlock.value[0] && inputSchema.valueBlock.value[0].local)
                             arrayRoot = inputData;
                         else
                             arrayRoot = root;
@@ -3160,7 +3645,7 @@ function compareSchema(root, inputData, inputSchema) {
         if (result.verified === false) {
             const _result = {
                 verified: false,
-                result: root,
+                result: root
             };
             if (inputSchema.name) {
                 inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
@@ -3173,16 +3658,15 @@ function compareSchema(root, inputData, inputSchema) {
         }
         return {
             verified: true,
-            result: root,
+            result: root
         };
     }
-    if (inputSchema.primitiveSchema
-        && (VALUE_HEX_VIEW in inputData.valueBlock)) {
+    if (inputSchema.primitiveSchema && VALUE_HEX_VIEW in inputData.valueBlock) {
         const asn1 = localFromBER(inputData.valueBlock.valueHexView);
         if (asn1.offset === -1) {
             const _result = {
                 verified: false,
-                result: asn1.result,
+                result: asn1.result
             };
             if (inputSchema.name) {
                 inputSchema.name = inputSchema.name.replace(/^\s+|\s+$/g, EMPTY_STRING);
@@ -3197,26 +3681,49 @@ function compareSchema(root, inputData, inputSchema) {
     }
     return {
         verified: true,
-        result: root,
+        result: root
     };
 }
 function verifySchema(inputBuffer, inputSchema) {
-    if ((inputSchema instanceof Object) === false) {
+    if (inputSchema instanceof Object === false) {
         return {
             verified: false,
-            result: { error: "Wrong ASN.1 schema type" },
+            result: { error: "Wrong ASN.1 schema type" }
         };
     }
     const asn1 = localFromBER(pvtsutils__namespace.BufferSourceConverter.toUint8Array(inputBuffer));
     if (asn1.offset === -1) {
         return {
             verified: false,
-            result: asn1.result,
+            result: asn1.result
         };
     }
     return compareSchema(asn1.result, asn1.result, inputSchema);
 }
 
+registerBuiltinEncoder({ BitString, Integer, OctetString, Primitive, Constructed, Sequence, Set }, {
+    BaseBlock,
+    ViewWriter,
+    LocalIdentificationBlock,
+    LocalLengthBlock,
+    LocalIntegerValueBlock,
+    LocalOctetStringValueBlock,
+    LocalConstructedValueBlock,
+    LocalBitStringValueBlock,
+    LocalPrimitiveValueBlock,
+    originalBaseBlockToBER: ORIGINAL_BASE_BLOCK_TO_BER,
+    originalWriterWrite: ORIGINAL_VIEW_WRITER_WRITE,
+    originalWriterFinal: ORIGINAL_VIEW_WRITER_FINAL,
+    originalIdentificationToBER: ORIGINAL_LOCAL_IDENTIFICATION_TO_BER,
+    originalLengthToBER: ORIGINAL_LOCAL_LENGTH_TO_BER,
+    originalIntegerToBER: ORIGINAL_LOCAL_INTEGER_TO_BER,
+    originalOctetStringToBER: ORIGINAL_LOCAL_OCTET_STRING_TO_BER,
+    originalBitStringToBER: ORIGINAL_LOCAL_BIT_STRING_TO_BER,
+    originalConstructedToBER: ORIGINAL_LOCAL_CONSTRUCTED_TO_BER,
+    originalPrimitiveToBER: ORIGINAL_LOCAL_PRIMITIVE_TO_BER
+});
+registerFastParser({ Integer, Null, Sequence });
+
 exports.Any = Any;
 exports.BaseBlock = BaseBlock;
 exports.BaseStringBlock = BaseStringBlock;