asn1-ts 10.0.0 → 11.0.0

package/dist/codecs/ber/encoders/encodeGeneralString.mjs

@@ -1,13 +1,5 @@
-import isGeneralCharacter from "../../../validators/isGeneralCharacter.mjs";
 import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
-import { ASN1CharactersError } from "../../../errors.mjs";
 export default function encodeGeneralString(value) {
     const bytes = convertTextToBytes(value);
-    for (const char of bytes) {
-        if (!isGeneralCharacter(char)) {
-            throw new ASN1CharactersError("GeneralString can only contain ASCII characters."
-                + `Encountered character code ${char}.`);
-        }
-    }
     return bytes;
 }

package/dist/codecs/ber/encoders/encodeGraphicString.mjs

@@ -1,13 +1,5 @@
-import isGraphicCharacter from "../../../validators/isGraphicCharacter.mjs";
 import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
-import { ASN1CharactersError } from "../../../errors.mjs";
 export default function encodeGraphicString(value) {
     const bytes = convertTextToBytes(value);
-    for (const char of bytes) {
-        if (!isGraphicCharacter(char)) {
-            throw new ASN1CharactersError("GraphicString can only contain characters between 0x20 and 0x7E. "
-                + `Encountered character code ${char}.`);
-        }
-    }
     return bytes;
 }

package/dist/codecs/ber/encoders/encodeNumericString.mjs

@@ -1,13 +1,5 @@
-import isNumericCharacter from "../../../validators/isNumericCharacter.mjs";
 import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
-import { ASN1CharactersError } from "../../../errors.mjs";
 export default function encodeNumericString(value) {
     const bytes = convertTextToBytes(value);
-    for (const char of bytes) {
-        if (!isNumericCharacter(char)) {
-            throw new ASN1CharactersError("NumericString can only contain characters 0 - 9 and space. "
-                + `Encountered character code ${char}.`);
-        }
-    }
     return bytes;
 }

package/dist/codecs/ber/encoders/encodeObjectDescriptor.mjs

@@ -1,13 +1,5 @@
-import isObjectDescriptorCharacter from "../../../validators/isObjectDescriptorCharacter.mjs";
 import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
-import { ASN1CharactersError } from "../../../errors.mjs";
 export default function encodeObjectDescriptor(value) {
     const bytes = convertTextToBytes(value);
-    for (const char of bytes) {
-        if (!isObjectDescriptorCharacter(char)) {
-            throw new ASN1CharactersError("ObjectDescriptor can only contain characters between 0x20 and 0x7E. "
-                + `Encountered character code ${char}.`);
-        }
-    }
     return bytes;
 }

package/dist/codecs/ber/encoders/encodePrintableString.mjs

@@ -1,14 +1,5 @@
-import isPrintableCharacter from "../../../validators/isPrintableCharacter.mjs";
 import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
-import { ASN1CharactersError } from "../../../errors.mjs";
-import { printableStringCharacters } from "../../../values.mjs";
 export default function encodeNumericString(value) {
     const bytes = convertTextToBytes(value);
-    for (const char of bytes) {
-        if (!isPrintableCharacter(char)) {
-            throw new ASN1CharactersError(`PrintableString can only contain these characters: ${printableStringCharacters}. `
-                + `Encountered character code ${char}.`);
-        }
-    }
     return bytes;
 }

package/dist/codecs/ber/encoders/encodeVisibleString.mjs

@@ -1,13 +1,5 @@
-import isGraphicCharacter from "../../../validators/isGraphicCharacter.mjs";
 import convertTextToBytes from "../../../utils/convertTextToBytes.mjs";
-import { ASN1CharactersError } from "../../../errors.mjs";
 export default function encodeVisibleString(value) {
     const bytes = convertTextToBytes(value);
-    for (const char of bytes) {
-        if (!isGraphicCharacter(char)) {
-            throw new ASN1CharactersError("VisibleString can only contain characters between 0x20 and 0x7E. "
-                + `Encountered character code ${char}.`);
-        }
-    }
     return bytes;
 }

package/dist/codecs/x690/decoders/decodeObjectIdentifier.mjs

@@ -1,46 +1,4 @@
 import ObjectIdentifier from "../../../types/ObjectIdentifier.mjs";
-import * as errors from "../../../errors.mjs";
 export default function decodeObjectIdentifier(value) {
-    if (value.length === 0) {
-        throw new errors.ASN1TruncationError("Encoded value was too short to be an OBJECT IDENTIFIER!");
-    }
-    const nodes = [0, 0];
-    if (value[0] >= 0x50) {
-        nodes[0] = 2;
-        nodes[1] = (value[0] - 0x50);
-    }
-    else if (value[0] >= 0x28) {
-        nodes[0] = 1;
-        nodes[1] = (value[0] - 0x28);
-    }
-    else {
-        nodes[0] = 0;
-        nodes[1] = value[0];
-    }
-    if (value.length === 1) {
-        return new ObjectIdentifier(nodes);
-    }
-    if (value[value.length - 1] & 0b10000000) {
-        throw new errors.ASN1TruncationError("OID was truncated.");
-    }
-    let current_node = 0;
-    for (let i = 1; i < value.length; i++) {
-        const byte = value[i];
-        if (current_node === 0) {
-            if (byte < 128) {
-                nodes.push(byte);
-                continue;
-            }
-            if (byte === 0x80) {
-                throw new errors.ASN1PaddingError("Prohibited padding on OBJECT IDENTIFIER node.");
-            }
-        }
-        current_node <<= 7;
-        current_node += (byte & 127);
-        if ((byte & 128) === 0) {
-            nodes.push(current_node);
-            current_node = 0;
-        }
-    }
-    return new ObjectIdentifier(nodes);
+    return ObjectIdentifier.fromBytes(value);
 }

package/dist/codecs/x690/encoders/encodeObjectIdentifier.mjs

@@ -1,29 +1,4 @@
 import { Buffer } from "node:buffer";
 export default function encodeObjectIdentifier(value) {
-    const arcs = value.uint32ArrayRef;
-    const node0 = arcs[0];
-    const node1 = arcs[1];
-    const byte0 = (node0 * 40) + node1;
-    const ret = [byte0];
-    for (const arc of arcs.slice(2)) {
-        if (arc < 128) {
-            ret.push(arc);
-            continue;
-        }
-        let l = 0;
-        let i = arc;
-        while (i > 0) {
-            l++;
-            i >>>= 7;
-        }
-        for (let j = l - 1; j >= 0; j--) {
-            let o = (arc >>> (j * 7));
-            o &= 0x7f;
-            if (j !== 0) {
-                o |= 0x80;
-            }
-            ret.push(o);
-        }
-    }
-    return Buffer.from(ret);
+    return value.toBytes();
 }

package/dist/functional.mjs

@@ -564,7 +564,7 @@ export function _parse_set(set, decodingCallbacks, rootComponentTypeList1, exten
     const missingRequiredComponents = rootComponents
         .filter((c) => (!c.optional && !encounteredComponents.has(c.name)))
         .map((c) => c.name);
-    Array.from(encounteredExtensionGroups).forEach((exg) => {
+    for (const exg of encounteredExtensionGroups.values()) {
         for (const c of extensionAdditionsList) {
             if (!((c.groupIndex === exg)
                 && !c.optional
@@ -573,7 +573,7 @@ export function _parse_set(set, decodingCallbacks, rootComponentTypeList1, exten
             }
             missingRequiredComponents.push(c.name);
         }
-    });
+    }
     if (missingRequiredComponents.length > 0) {
         throw new Error(`SET '${set.name}' missing these required components: ${missingRequiredComponents.join(", ")}.`);
     }
@@ -647,9 +647,9 @@ function _parse_sequence_with_trailing_rctl(seq, decodingCallbacks, rootComponen
     const startOfRCTL2 = (startOfExtensions + numberOfExtensionElements);
     const numberOfExtensionsRead = _parse_component_type_list(extensionAdditionsList, decodingCallbacks, elements.slice(startOfExtensions, startOfRCTL2), true);
     const endOfRecognizedExtensions = (startOfExtensions + numberOfExtensionsRead);
-    elements
-        .slice(endOfRecognizedExtensions, startOfRCTL2)
-        .forEach((x) => unrecognizedExtensionHandler(x));
+    for (let i = endOfRecognizedExtensions; i < startOfRCTL2; i++) {
+        unrecognizedExtensionHandler(elements[i]);
+    }
     const numberOfRCTL2ElementsRead = _parse_component_type_list(rootComponentTypeList2, decodingCallbacks, elements.slice(startOfRCTL2), false);
     if (startOfRCTL2 + numberOfRCTL2ElementsRead !== elements.length) {
         throw new Error(`SEQUENCE '${seq.name}' had excess elements at the end.`);
@@ -660,9 +660,9 @@ function _parse_sequence_without_trailing_rctl(seq, decodingCallbacks, rootCompo
     const startOfExtensions = _parse_component_type_list(rootComponentTypeList1, decodingCallbacks, elements, false);
     const numberOfExtensionsRead = _parse_component_type_list(extensionAdditionsList, decodingCallbacks, elements.slice(startOfExtensions), true);
     const endOfRecognizedExtensions = (startOfExtensions + numberOfExtensionsRead);
-    elements
-        .slice(endOfRecognizedExtensions)
-        .forEach((x) => unrecognizedExtensionHandler(x));
+    for (let i = endOfRecognizedExtensions; i < elements.length; i++) {
+        unrecognizedExtensionHandler(elements[i]);
+    }
 }
 export function _parse_sequence(seq, decodingCallbacks, rootComponentTypeList1, extensionAdditionsList, rootComponentTypeList2, unrecognizedExtensionHandler = () => { }) {
     if (rootComponentTypeList2.length > 0) {
@@ -689,12 +689,14 @@ export function _encode_choice(choices, elGetter) {
     };
 }
 export function _decode_inextensible_choice(choices) {
+    const choiceMap = new Map(Object.entries(choices));
     return function (el) {
-        const result = choices[`${tagClassName(el.tagClass)} ${el.tagNumber}`];
+        const result = choiceMap.get(`${tagClassName(el.tagClass)} ${el.tagNumber}`);
         if (!result) {
-            if (choices["*"]) {
+            const star = choiceMap.get("*");
+            if (star) {
                 const ret = {};
-                ret[choices["*"][0]] = choices["*"][1](el);
+                ret[star[0]] = star[1](el);
                 return ret;
             }
             else {
@@ -708,8 +710,9 @@ export function _decode_inextensible_choice(choices) {
     };
 }
 export function _decode_extensible_choice(choices) {
+    const choiceMap = new Map(Object.entries(choices));
     return function (el) {
-        const result = choices[`${tagClassName(el.tagClass)} ${el.tagNumber}`];
+        const result = choiceMap.get(`${tagClassName(el.tagClass)} ${el.tagNumber}`);
         if (!result) {
             return el;
         }
@@ -720,30 +723,50 @@ export function _decode_extensible_choice(choices) {
     };
 }
 export function _decodeSequenceOf(decoderGetter) {
+    const decoder = decoderGetter();
     return function (el) {
-        return el.sequence.map(decoderGetter());
+        const seq = el.sequence;
+        const result = new Array(seq.length);
+        for (let i = 0; i < seq.length; i++) {
+            result[i] = decoder(seq[i]);
+        }
+        return result;
     };
 }
 export function _encodeSequenceOf(encoderGetter, outerElGetter) {
+    const encoder = encoderGetter();
     return function (value) {
         const el = outerElGetter(value, outerElGetter);
-        const encoder = encoderGetter();
-        el.sequence = value.map((v) => encoder(v, outerElGetter));
+        const seq = new Array(value.length);
+        for (let i = 0; i < value.length; i++) {
+            seq[i] = encoder(value[i], outerElGetter);
+        }
+        el.sequence = seq;
         el.tagClass = ASN1TagClass.universal;
         el.tagNumber = ASN1UniversalType.sequence;
         return el;
     };
 }
 export function _decodeSetOf(decoderGetter) {
+    const decoder = decoderGetter();
     return function (el) {
-        return el.setOf.map(decoderGetter());
+        const setOf = el.setOf;
+        const result = new Array(setOf.length);
+        for (let i = 0; i < setOf.length; i++) {
+            result[i] = decoder(setOf[i]);
+        }
+        return result;
     };
 }
 export function _encodeSetOf(encoderGetter, outerElGetter) {
+    const encoder = encoderGetter();
     return function (value) {
         const el = outerElGetter(value, outerElGetter);
-        const encoder = encoderGetter();
-        el.setOf = value.map((v) => encoder(v, outerElGetter));
+        const seq = new Array(value.length);
+        for (let i = 0; i < value.length; i++) {
+            seq[i] = encoder(value[i], outerElGetter);
+        }
+        el.setOf = seq;
         el.tagClass = ASN1TagClass.universal;
         el.tagNumber = ASN1UniversalType.set;
         return el;

package/dist/types/ObjectIdentifier.d.mts

@@ -1,8 +1,7 @@
-import type { Buffer } from "node:buffer";
+import { Buffer } from "node:buffer";
 export default class ObjectIdentifier {
-    private _nodes;
-    constructor(nodes: number[], prefix?: ObjectIdentifier | number);
-    get uint32ArrayRef(): Uint32Array;
+    protected encoding: Uint8Array;
+    static fromParts(nodes: number[], prefix?: ObjectIdentifier | number): ObjectIdentifier;
     get nodes(): number[];
     get dotDelimitedNotation(): string;
     get asn1Notation(): string;
@@ -11,6 +10,7 @@ export default class ObjectIdentifier {
     toBytes(): Buffer;
     static fromString(str: string): ObjectIdentifier;
     static fromBytes(bytes: Uint8Array): ObjectIdentifier;
+    static fromBytesUnsafe(bytes: Uint8Array): ObjectIdentifier;
     static compare(a: ObjectIdentifier, b: ObjectIdentifier): boolean;
     isEqualTo(other: ObjectIdentifier): boolean;
 }

package/dist/types/ObjectIdentifier.mjs

@@ -1,36 +1,52 @@
-import decodeObjectIdentifier from "../codecs/x690/decoders/decodeObjectIdentifier.mjs";
-import encodeObjectIdentifier from "../codecs/x690/encoders/encodeObjectIdentifier.mjs";
+import encodeRelativeObjectIdentifier from "../codecs/x690/encoders/encodeRelativeObjectIdentifier.mjs";
+import decodeRelativeObjectIdentifier from "../codecs/x690/decoders/decodeRelativeObjectIdentifier.mjs";
+import { Buffer } from "node:buffer";
+import * as errors from "../errors.mjs";
 const PERIOD = ".".charCodeAt(0);
 export default class ObjectIdentifier {
-    constructor(nodes, prefix) {
-        const _nodes = prefix
-            ? typeof prefix === "number"
-                ? [prefix, ...nodes]
-                : [...prefix.nodes, ...nodes]
-            : nodes.slice(0);
-        if (_nodes.length < 2) {
-            throw new Error("Cannot construct an OID with less than two nodes!");
+    constructor() {
+        this.encoding = new Uint8Array(0);
+    }
+    static fromParts(nodes, prefix) {
+        let _nodes = typeof prefix === "number" ? [prefix, ...nodes] : nodes;
+        if (!prefix || typeof prefix === "number") {
+            if (_nodes.length < 2) {
+                throw new Error("Cannot construct an OID with less than two nodes!");
+            }
+            if ((_nodes[0] < 0) || (_nodes[0] > 2)) {
+                throw new Error("OIDs first node must be 0, 1, or 2!");
+            }
+            if (((_nodes[0] < 2) && (_nodes[1] > 39))) {
+                throw new Error(`OID Node #2 cannot exceed 39 if node #1 is 0 or 1. Received these nodes: ${_nodes}.`);
+            }
         }
-        if ((_nodes[0] < 0) || (_nodes[0] > 2)) {
-            throw new Error("OIDs first node must be 0, 1, or 2!");
+        const oid = new ObjectIdentifier();
+        if (prefix && typeof prefix !== "number") {
+            oid.encoding = Buffer.concat([prefix.encoding, encodeRelativeObjectIdentifier(_nodes)]);
         }
-        if (((_nodes[0] < 2) && (_nodes[1] > 39)) || (_nodes[1] > 175)) {
-            throw new Error("OID Node #2 cannot exceed 39 if node #1 is 0 or 1, and 175 "
-                + `if node #1 is 2. Received these nodes: ${_nodes}.`);
+        else {
+            oid.encoding = encodeRelativeObjectIdentifier([
+                (_nodes[0] * 40) + _nodes[1],
+                ..._nodes.slice(2),
+            ]);
         }
-        this._nodes = new Uint32Array(_nodes);
-    }
-    get uint32ArrayRef() {
-        return this._nodes;
+        return oid;
     }
     get nodes() {
-        return Array.from(this._nodes);
+        const subcomponents = decodeRelativeObjectIdentifier(this.encoding);
+        return [
+            Math.min(2, Math.floor(subcomponents[0] / 40)),
+            ((subcomponents[0] >= 80)
+                ? (subcomponents[0] - 80)
+                : (subcomponents[0] % 40)),
+            ...subcomponents.slice(1),
+        ];
     }
     get dotDelimitedNotation() {
-        return this._nodes.join(".");
+        return this.nodes.join(".");
     }
     get asn1Notation() {
-        return `{ ${Array.from(this._nodes).map((node) => node.toString()).join(" ")} }`;
+        return `{ ${Array.from(this.nodes).map((node) => node.toString()).join(" ")} }`;
     }
     toString() {
         return this.dotDelimitedNotation;
@@ -39,7 +55,7 @@ export default class ObjectIdentifier {
         return this.dotDelimitedNotation;
     }
     toBytes() {
-        return encodeObjectIdentifier(this);
+        return Buffer.from(this.encoding);
     }
     static fromString(str) {
         const arcs = [];
@@ -55,24 +71,39 @@ export default class ObjectIdentifier {
         }
         const arc = Number.parseInt(str.slice(last, i), 10);
         arcs.push(arc);
-        return new ObjectIdentifier(arcs);
+        return ObjectIdentifier.fromParts(arcs);
     }
     static fromBytes(bytes) {
-        return decodeObjectIdentifier(bytes);
-    }
-    static compare(a, b) {
-        if (a._nodes.length !== b._nodes.length) {
-            return false;
+        if (bytes.length === 0) {
+            throw new errors.ASN1TruncationError("Encoded value was too short to be an OBJECT IDENTIFIER!");
         }
-        const len = a._nodes.length;
-        let i = len - 1;
-        while (i >= 0) {
-            if (a._nodes[i] !== b._nodes[i]) {
-                return false;
+        if (bytes[bytes.length - 1] & 0b10000000) {
+            throw new errors.ASN1TruncationError("OID was truncated.");
+        }
+        let current_node = 0;
+        for (let i = 1; i < bytes.length; i++) {
+            const byte = bytes[i];
+            if ((current_node === 0) && (byte === 0x80)) {
+                throw new errors.ASN1PaddingError("Prohibited padding on OBJECT IDENTIFIER node.");
+            }
+            if (byte < 0x80) {
+                current_node = 0;
+            }
+            else {
+                current_node++;
             }
-            i--;
         }
-        return true;
+        const oid = new ObjectIdentifier();
+        oid.encoding = bytes;
+        return oid;
+    }
+    static fromBytesUnsafe(bytes) {
+        const oid = new ObjectIdentifier();
+        oid.encoding = bytes;
+        return oid;
+    }
+    static compare(a, b) {
+        return Buffer.compare(a.encoding, b.encoding) === 0;
     }
     isEqualTo(other) {
         return ObjectIdentifier.compare(this, other);

package/dist/validators/isObjectDescriptorCharacter.d.mts

@@ -1 +1,3 @@
-export default function isObjectDescriptorCharacter(characterCode: number): boolean;
+import isGraphicCharacter from "./isGraphicCharacter.mjs";
+declare const isObjectDescriptorCharacter: typeof isGraphicCharacter;
+export default isObjectDescriptorCharacter;

package/dist/validators/isObjectDescriptorCharacter.mjs

@@ -1,4 +1,3 @@
 import isGraphicCharacter from "./isGraphicCharacter.mjs";
-export default function isObjectDescriptorCharacter(characterCode) {
-    return isGraphicCharacter(characterCode);
-}
+const isObjectDescriptorCharacter = isGraphicCharacter;
+export default isObjectDescriptorCharacter;

package/dist/validators/isVisibleCharacter.d.mts

@@ -1 +1,3 @@
-export default function isVisibleCharacter(characterCode: number): boolean;
+import isGraphicCharacter from "./isGraphicCharacter.mjs";
+declare const isVisibleCharacter: typeof isGraphicCharacter;
+export default isVisibleCharacter;

package/dist/validators/isVisibleCharacter.mjs

@@ -1,4 +1,3 @@
 import isGraphicCharacter from "./isGraphicCharacter.mjs";
-export default function isVisibleCharacter(characterCode) {
-    return isGraphicCharacter(characterCode);
-}
+const isVisibleCharacter = isGraphicCharacter;
+export default isVisibleCharacter;

package/dist/x690.mjs

@@ -36,9 +36,6 @@ export default class X690Element extends ASN1Element {
         if (this.construction !== ASN1Construction.primitive) {
             throw new errors.ASN1ConstructionError("OBJECT IDENTIFIER cannot be constructed.", this);
         }
-        if (this.value.length === 0) {
-            throw new errors.ASN1TruncationError("Encoded value was too short to be an OBJECT IDENTIFIER!", this);
-        }
         return decodeObjectIdentifier(this.value);
     }
     set enumerated(value) {

package/package.json

@@ -48,5 +48,5 @@
         "test": "node --test"
     },
     "types": "./dist/index.d.mts",
-    "version": "10.0.0"
+    "version": "11.0.0"
 }