@matter/general 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/MatterError.js

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { errorOf } from "./util/Error.js";
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+class MatterError extends Error {
+  /**
+   * Convert the error to formatted text.
+   *
+   * Matter encodes errors with modern JS features including {@link Error#cause} and {@link AggregateError#errors}
+   * subfields.  You can use this function to ensure all error details are presented regardless of environment.
+   */
+  format(format = "plain", indents = 0) {
+    let formatterFor = MatterError.formatterFor;
+    if (typeof formatterFor !== "function") {
+      formatterFor = MatterError.defaultFormatterFactory;
+    }
+    let formatter = formatterFor(format);
+    if (typeof formatter !== "function") {
+      formatter = fallbackFormatter;
+    }
+    let result = formatter(this, indents);
+    if (typeof result !== "string") {
+      result = `${result}`;
+    }
+    return result;
+  }
+  /**
+   * Node.js-style object inspection.
+   *
+   * Node's default inspection only prevents two levels of depth which may hide critical information.  It's also
+   * considerably more verbose than native matter.js formatting.  We therefore offer this custom implementation.
+   *
+   * Note that this conforms to Node's API but is not dependent on Node.
+   */
+  [inspect](depth, inspectionOptions) {
+    const formatterFor = MatterError.formatterFor;
+    if (typeof formatterFor !== "function") {
+      return this;
+    }
+    const format = formatterFor(inspectionOptions?.colors ? "ansi" : "plain");
+    if (typeof format !== "function") {
+      return this;
+    }
+    return format(this, depth);
+  }
+  /**
+   * Rethrow an error unless it is an instance of this class.
+   */
+  static accept(error) {
+    if (error instanceof this) {
+      return;
+    }
+    throw error;
+  }
+  /**
+   * Rethrow an error if it is an instance of this class.
+   */
+  static reject(error) {
+    if (error instanceof this) {
+      throw error;
+    }
+  }
+  /**
+   * The fallback formatter factory.  This produces a limited plaintext formatter.
+   */
+  static defaultFormatterFactory = () => fallbackFormatter;
+  /**
+   * The error formatter factory.  The default formatter is replaced by Matter.js in ./Format.ts.
+   */
+  static formatterFor = MatterError.defaultFormatterFactory;
+  // TODO - this is probably correct; MatterAggregateError should be typeof MatterError.  Need to diagnose some test
+  // breakage before enabling though
+  // static [Symbol.hasInstance](instance: unknown) {
+  //     if (instance instanceof MatterAggregateError) {
+  //         return true;
+  //     }
+  //     return Error[Symbol.hasInstance](instance);
+  // }
+}
+class NoProviderError extends MatterError {
+}
+class InternalError extends MatterError {
+}
+class NotImplementedError extends InternalError {
+}
+class MatterFlowError extends MatterError {
+}
+class UnexpectedDataError extends MatterError {
+}
+class ImplementationError extends MatterError {
+}
+class ReadOnlyError extends ImplementationError {
+  constructor(message = "This view is read-only") {
+    super(message);
+  }
+}
+class MatterAggregateError extends AggregateError {
+  constructor(causes, message) {
+    causes = [...causes].map(errorOf);
+    super(causes, message);
+  }
+  [inspect] = MatterError.prototype[inspect];
+  format = MatterError.prototype.format;
+  // TODO - see comment on MatterError.  If that one is correct this is incorrect
+  static [Symbol.hasInstance](instance) {
+    if (instance instanceof MatterError) {
+      return true;
+    }
+    return AggregateError[Symbol.hasInstance](instance);
+  }
+}
+function fallbackFormatter(value, indents = 0) {
+  if (value === void 0 || value === null) {
+    return `${value}`;
+  }
+  function formatOne(value2, indents2, messagePrefix) {
+    const { message, stack, cause, errors } = value2;
+    let indent;
+    if (typeof indents2 !== "number" || indents2 < 0) {
+      indent = "";
+    } else {
+      indent = "  ".repeat(indents2);
+    }
+    const buffer = [`${indent}${messagePrefix}${message ?? "(unknown error)"}`];
+    if (stack !== void 0 && stack !== null) {
+      const frames = stack.toString().split("\n");
+      frames.shift();
+      buffer.push(...frames.map((f) => `${indent}  ${f.trim()}`));
+    }
+    if (cause !== void 0) {
+      buffer.push(formatOne(cause, indents2, "Caused by: "));
+    }
+    if (typeof errors?.[Symbol.iterator] === "function") {
+      let causeNumber = 0;
+      for (const error of errors) {
+        buffer.push(formatOne(error, indents2 + 1, `Cause #${causeNumber++}: `));
+      }
+    }
+    return buffer.join("\n");
+  }
+  return formatOne(value, indents, "");
+}
+export {
+  ImplementationError,
+  InternalError,
+  MatterAggregateError,
+  MatterError,
+  MatterFlowError,
+  NoProviderError,
+  NotImplementedError,
+  ReadOnlyError,
+  UnexpectedDataError
+};
+//# sourceMappingURL=MatterError.js.map

package/dist/esm/MatterError.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/MatterError.ts"],
+  "mappings": "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",
+  "names": ["value", "indents"]
+}

package/dist/esm/codec/Base64Codec.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare namespace Base64 {
+    /**
+     * Encodes base64.
+     *
+     * @param input an indexable sequence of bytes
+     * @param url set to true to encode as base46url
+     * @returns an encoded string
+     */
+    function encode(input: ArrayLike<number>, url?: boolean): string;
+    /**
+     * Decodes base64.
+     *
+     * @param input binary data encoded as a base64 or base64url string
+     * @returns decoded bytes in a ByteArray
+     */
+    function decode(input: string): Uint8Array;
+}
+//# sourceMappingURL=Base64Codec.d.ts.map

package/dist/esm/codec/Base64Codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Base64Codec.d.ts","sourceRoot":"","sources":["../../../src/codec/Base64Codec.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqCH,yBAAiB,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,SAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,UAAQ,UA+B3D;IAED;;;;;OAKG;IACH,SAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,cA+CnC;CACJ"}

package/dist/esm/codec/Base64Codec.js

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function cp(text) {
+  return text.codePointAt(0) ?? 0;
+}
+const A2B = [];
+const B2A = new Uint8Array(64);
+const B2A_URL = new Uint8Array(64);
+const PAD = cp("=");
+{
+  let addRange = function(start, stop) {
+    const end = cp(stop) + 1;
+    for (let i = cp(start); i < end; i++) {
+      A2B[i] = pos;
+      B2A[pos++] = i;
+    }
+  };
+  var addRange2 = addRange;
+  let pos = 0;
+  addRange("A", "Z");
+  addRange("a", "z");
+  addRange("0", "9");
+  addRange("+", "+");
+  addRange("/", "/");
+  const slashValue = A2B[cp("/")];
+  const plusValue = A2B[cp("+")];
+  A2B[cp("_")] = slashValue;
+  A2B[cp("-")] = plusValue;
+  B2A_URL.set(B2A);
+  B2A_URL[slashValue] = cp("_");
+  B2A_URL[plusValue] = cp("-");
+}
+var Base64;
+((Base642) => {
+  function encode(input, url = false) {
+    const dict = url ? B2A_URL : B2A;
+    let outLength = Math.trunc(input.length / 3) * 4;
+    if (url) {
+      const partial = input.length % 3;
+      if (partial) outLength += partial + 1;
+    } else {
+      outLength += input.length % 3 ? 4 : 0;
+    }
+    const out = new Uint8Array(outLength);
+    for (let inPos = 0, outPos = 0; outPos < outLength; ) {
+      const n = (input[inPos++] << 16) + ((input[inPos++] ?? 0) << 8) + (input[inPos++] ?? 0);
+      out[outPos++] = dict[n >>> 18];
+      out[outPos++] = dict[n >>> 12 & 63];
+      if (inPos - input.length === 2) {
+        if (!url) out[outPos++] = PAD;
+      } else {
+        out[outPos++] = dict[n >>> 6 & 63];
+      }
+      if (inPos > input.length) {
+        if (!url) out[outPos++] = PAD;
+      } else {
+        out[outPos++] = dict[n & 63];
+      }
+    }
+    return new TextDecoder("iso-8859-1").decode(out);
+  }
+  Base642.encode = encode;
+  function decode(input) {
+    if (!input.length) {
+      return new Uint8Array();
+    }
+    let inputLength = input.length;
+    while (input.codePointAt(inputLength - 1) === PAD) inputLength--;
+    let outLength = Math.trunc(inputLength / 4) * 3;
+    switch (inputLength % 4) {
+      case 3:
+        outLength += 2;
+        break;
+      case 2:
+        outLength += 1;
+        break;
+      case 1:
+        throw new Error("Invalid base-64 encoding");
+    }
+    const out = new Uint8Array(outLength);
+    for (let inPos = 0, outPos = 0; ; ) {
+      let lookup2 = function() {
+        if (inPos >= inputLength) return 0;
+        const v = A2B[input.codePointAt(inPos++) ?? -1];
+        if (v === void 0) {
+          throw new Error("Invalid base-64 encoding");
+        }
+        return v;
+      };
+      var lookup = lookup2;
+      const n = (lookup2() << 18) + (lookup2() << 12) + (lookup2() << 6) + lookup2();
+      out[outPos++] = n >>> 16;
+      if (outPos < outLength) {
+        out[outPos++] = n >>> 8 & 255;
+      } else {
+        break;
+      }
+      if (outPos < outLength) {
+        out[outPos++] = n & 255;
+      } else {
+        break;
+      }
+    }
+    return out;
+  }
+  Base642.decode = decode;
+})(Base64 || (Base64 = {}));
+export {
+  Base64
+};
+//# sourceMappingURL=Base64Codec.js.map

package/dist/esm/codec/Base64Codec.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/codec/Base64Codec.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,GAAG,MAAc;AACtB,SAAO,KAAK,YAAY,CAAC,KAAK;AAClC;AAEA,MAAM,MAAgB,CAAC;AACvB,MAAM,MAAM,IAAI,WAAW,EAAE;AAC7B,MAAM,UAAU,IAAI,WAAW,EAAE;AACjC,MAAM,MAAM,GAAG,GAAG;AAElB;AAGI,MAAS,WAAT,SAAkB,OAAe,MAAc;AAC3C,UAAM,MAAM,GAAG,IAAI,IAAI;AACvB,aAAS,IAAI,GAAG,KAAK,GAAG,IAAI,KAAK,KAAK;AAClC,UAAI,CAAC,IAAI;AACT,UAAI,KAAK,IAAI;AAAA,IACjB;AAAA,EACJ;AANS,MAAAA,YAAA;AAFT,MAAI,MAAM;AASV,WAAS,KAAK,GAAG;AACjB,WAAS,KAAK,GAAG;AACjB,WAAS,KAAK,GAAG;AACjB,WAAS,KAAK,GAAG;AACjB,WAAS,KAAK,GAAG;AAGjB,QAAM,aAAa,IAAI,GAAG,GAAG,CAAC;AAC9B,QAAM,YAAY,IAAI,GAAG,GAAG,CAAC;AAC7B,MAAI,GAAG,GAAG,CAAC,IAAI;AACf,MAAI,GAAG,GAAG,CAAC,IAAI;AACf,UAAQ,IAAI,GAAG;AACf,UAAQ,UAAU,IAAI,GAAG,GAAG;AAC5B,UAAQ,SAAS,IAAI,GAAG,GAAG;AAC/B;AAEO,IAAU;AAAA,CAAV,CAAUC,YAAV;AAQI,WAAS,OAAO,OAA0B,MAAM,OAAO;AAC1D,UAAM,OAAO,MAAM,UAAU;AAC7B,QAAI,YAAY,KAAK,MAAM,MAAM,SAAS,CAAC,IAAI;AAC/C,QAAI,KAAK;AACL,YAAM,UAAU,MAAM,SAAS;AAC/B,UAAI,QAAS,cAAa,UAAU;AAAA,IACxC,OAAO;AACH,mBAAa,MAAM,SAAS,IAAI,IAAI;AAAA,IACxC;AACA,UAAM,MAAM,IAAI,WAAW,SAAS;AAEpC,aAAS,QAAQ,GAAG,SAAS,GAAG,SAAS,aAAa;AAClD,YAAM,KAAK,MAAM,OAAO,KAAK,QAAQ,MAAM,OAAO,KAAK,MAAM,MAAM,MAAM,OAAO,KAAK;AAErF,UAAI,QAAQ,IAAI,KAAK,MAAM,EAAE;AAC7B,UAAI,QAAQ,IAAI,KAAM,MAAM,KAAM,EAAI;AAEtC,UAAI,QAAQ,MAAM,WAAW,GAAG;AAC5B,YAAI,CAAC,IAAK,KAAI,QAAQ,IAAI;AAAA,MAC9B,OAAO;AACH,YAAI,QAAQ,IAAI,KAAM,MAAM,IAAK,EAAI;AAAA,MACzC;AAEA,UAAI,QAAQ,MAAM,QAAQ;AACtB,YAAI,CAAC,IAAK,KAAI,QAAQ,IAAI;AAAA,MAC9B,OAAO;AACH,YAAI,QAAQ,IAAI,KAAK,IAAI,EAAI;AAAA,MACjC;AAAA,IACJ;AAEA,WAAO,IAAI,YAAY,YAAY,EAAE,OAAO,GAAG;AAAA,EACnD;AA/BO,EAAAA,QAAS;AAuCT,WAAS,OAAO,OAAe;AAClC,QAAI,CAAC,MAAM,QAAQ;AACf,aAAO,IAAI,WAAW;AAAA,IAC1B;AAEA,QAAI,cAAc,MAAM;AACxB,WAAO,MAAM,YAAY,cAAc,CAAC,MAAM,IAAK;AAEnD,QAAI,YAAY,KAAK,MAAM,cAAc,CAAC,IAAI;AAC9C,YAAQ,cAAc,GAAG;AAAA,MACrB,KAAK;AACD,qBAAa;AACb;AAAA,MACJ,KAAK;AACD,qBAAa;AACb;AAAA,MACJ,KAAK;AACD,cAAM,IAAI,MAAM,0BAA0B;AAAA,IAClD;AAEA,UAAM,MAAM,IAAI,WAAW,SAAS;AAEpC,aAAS,QAAQ,GAAG,SAAS,OAAO;AAChC,UAASC,UAAT,WAAkB;AACd,YAAI,SAAS,YAAa,QAAO;AACjC,cAAM,IAAI,IAAI,MAAM,YAAY,OAAO,KAAK,EAAE;AAC9C,YAAI,MAAM,QAAW;AACjB,gBAAM,IAAI,MAAM,0BAA0B;AAAA,QAC9C;AACA,eAAO;AAAA,MACX;AAPS,mBAAAA;AAST,YAAM,KAAKA,QAAO,KAAK,OAAOA,QAAO,KAAK,OAAOA,QAAO,KAAK,KAAKA,QAAO;AACzE,UAAI,QAAQ,IAAI,MAAM;AACtB,UAAI,SAAS,WAAW;AACpB,YAAI,QAAQ,IAAK,MAAM,IAAK;AAAA,MAChC,OAAO;AACH;AAAA,MACJ;AACA,UAAI,SAAS,WAAW;AACpB,YAAI,QAAQ,IAAI,IAAI;AAAA,MACxB,OAAO;AACH;AAAA,MACJ;AAAA,IACJ;AAEA,WAAO;AAAA,EACX;AA/CO,EAAAD,QAAS;AAAA,GA/CH;",
+  "names": ["addRange", "Base64", "lookup"]
+}

package/dist/esm/codec/DerCodec.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { UnexpectedDataError } from "../MatterError.js";
+export declare enum DerKey {
+    ObjectId = "_objectId",
+    TagId = "_tag",
+    Bytes = "_bytes",
+    Elements = "_elements",
+    BitsPadding = "_padding",
+    TypeOverride = "_type",
+    RawData = "_raw"
+}
+export declare class DerError extends UnexpectedDataError {
+}
+export declare enum DerType {
+    Boolean = 1,
+    Integer = 2,
+    BitString = 3,
+    OctetString = 4,
+    Null = 5,
+    ObjectIdentifier = 6,
+    UTF8String = 12,
+    Sequence = 16,
+    Set = 17,
+    PrintableString = 19,
+    T16String = 20,
+    IA5String = 22,
+    UtcDate = 23,
+    GeneralizedTime = 24
+}
+export declare const ObjectId: (objectId: string) => {
+    _tag: number;
+    _bytes: Uint8Array;
+};
+export declare const DerObject: (objectId: string, content?: any) => any;
+export declare const BitByteArray: (data: Uint8Array, padding?: number) => {
+    _tag: number;
+    _bytes: Uint8Array;
+    _padding: number;
+};
+export declare const ContextTagged: (tagId: number, value?: any) => {
+    _tag: number;
+    _bytes: Uint8Array;
+};
+export declare const ContextTaggedBytes: (tagId: number, value: Uint8Array) => {
+    _tag: number;
+    _bytes: Uint8Array;
+};
+export declare const DatatypeOverride: (type: DerType, value: any) => {
+    _type: DerType;
+    _raw: any;
+};
+export declare const RawBytes: (bytes: Uint8Array) => {
+    _bytes: Uint8Array;
+};
+export type DerNode = {
+    [DerKey.TagId]: number;
+    [DerKey.Bytes]: Uint8Array;
+    [DerKey.Elements]?: DerNode[];
+    [DerKey.BitsPadding]?: number;
+};
+export declare class DerCodec {
+    static encode(value: any): Uint8Array;
+    private static encodeDate;
+    private static encodeBoolean;
+    private static encodeArray;
+    private static encodeOctetString;
+    private static encodeObject;
+    private static encodeString;
+    private static encodePrintableString;
+    private static encodeIA5String;
+    private static encodeInteger;
+    private static encodeBitString;
+    private static encodeLengthBytes;
+    private static encodeAsn1;
+    static decode(data: Uint8Array): DerNode;
+    private static decodeRec;
+    private static decodeAsn1;
+}
+//# sourceMappingURL=DerCodec.d.ts.map

package/dist/esm/codec/DerCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DerCodec.d.ts","sourceRoot":"","sources":["../../../src/codec/DerCodec.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAMxD,oBAAY,MAAM;IACd,QAAQ,cAAc;IACtB,KAAK,SAAS;IACd,KAAK,WAAW;IAChB,QAAQ,cAAc;IACtB,WAAW,aAAa;IACxB,YAAY,UAAU;IACtB,OAAO,SAAS;CACnB;AAED,qBAAa,QAAS,SAAQ,mBAAmB;CAAG;AAEpD,oBAAY,OAAO;IACf,OAAO,IAAO;IACd,OAAO,IAAO;IACd,SAAS,IAAO;IAChB,WAAW,IAAO;IAClB,IAAI,IAAO;IACX,gBAAgB,IAAO;IACvB,UAAU,KAAO;IACjB,QAAQ,KAAO;IACf,GAAG,KAAO;IACV,eAAe,KAAO;IACtB,SAAS,KAAO;IAChB,SAAS,KAAO;IAChB,OAAO,KAAO;IACd,eAAe,KAAO;CACzB;AAUD,eAAO,MAAM,QAAQ,aAAc,MAAM;UACO,MAAM;;CAEpD,CAAC;AACH,eAAO,MAAM,SAAS,aAAc,MAAM,YAAW,GAAG,QAGtD,CAAC;AACH,eAAO,MAAM,YAAY,SAAU,UAAU;UACJ,MAAM;;;CAG7C,CAAC;AACH,eAAO,MAAM,aAAa,UAAW,MAAM,UAAU,GAAG;;;CAGtD,CAAC;AACH,eAAO,MAAM,kBAAkB,UAAW,MAAM,SAAS,UAAU;;;CAGjE,CAAC;AACH,eAAO,MAAM,gBAAgB,SAAU,OAAO,SAAS,GAAG;;;CAGxD,CAAC;AACH,eAAO,MAAM,QAAQ,UAAW,UAAU;;CAExC,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG;IAClB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACvB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC3B,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC;IAC9B,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,qBAAa,QAAQ;IACjB,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,GAAG,UAAU;IAuErC,OAAO,CAAC,MAAM,CAAC,UAAU;IAwBzB,OAAO,CAAC,MAAM,CAAC,aAAa;IAI5B,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAIhC,OAAO,CAAC,MAAM,CAAC,YAAY;IAQ3B,OAAO,CAAC,MAAM,CAAC,YAAY;IAI3B,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAOpC,OAAO,CAAC,MAAM,CAAC,eAAe;IAQ9B,OAAO,CAAC,MAAM,CAAC,aAAa;IAoB5B,OAAO,CAAC,MAAM,CAAC,eAAe;IAO9B,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAkBhC,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO;IAIxC,OAAO,CAAC,MAAM,CAAC,SAAS;IAaxB,OAAO,CAAC,MAAM,CAAC,UAAU;CAc5B"}

package/dist/esm/codec/DerCodec.js

@@ -0,0 +1,266 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { UnexpectedDataError } from "../MatterError.js";
+import { Bytes, Endian } from "../util/Bytes.js";
+import { DataReader } from "../util/DataReader.js";
+import { toHex } from "../util/Number.js";
+import { isObject } from "../util/Type.js";
+var DerKey = /* @__PURE__ */ ((DerKey2) => {
+  DerKey2["ObjectId"] = "_objectId";
+  DerKey2["TagId"] = "_tag";
+  DerKey2["Bytes"] = "_bytes";
+  DerKey2["Elements"] = "_elements";
+  DerKey2["BitsPadding"] = "_padding";
+  DerKey2["TypeOverride"] = "_type";
+  DerKey2["RawData"] = "_raw";
+  return DerKey2;
+})(DerKey || {});
+class DerError extends UnexpectedDataError {
+}
+var DerType = /* @__PURE__ */ ((DerType2) => {
+  DerType2[DerType2["Boolean"] = 1] = "Boolean";
+  DerType2[DerType2["Integer"] = 2] = "Integer";
+  DerType2[DerType2["BitString"] = 3] = "BitString";
+  DerType2[DerType2["OctetString"] = 4] = "OctetString";
+  DerType2[DerType2["Null"] = 5] = "Null";
+  DerType2[DerType2["ObjectIdentifier"] = 6] = "ObjectIdentifier";
+  DerType2[DerType2["UTF8String"] = 12] = "UTF8String";
+  DerType2[DerType2["Sequence"] = 16] = "Sequence";
+  DerType2[DerType2["Set"] = 17] = "Set";
+  DerType2[DerType2["PrintableString"] = 19] = "PrintableString";
+  DerType2[DerType2["T16String"] = 20] = "T16String";
+  DerType2[DerType2["IA5String"] = 22] = "IA5String";
+  DerType2[DerType2["UtcDate"] = 23] = "UtcDate";
+  DerType2[DerType2["GeneralizedTime"] = 24] = "GeneralizedTime";
+  return DerType2;
+})(DerType || {});
+const CONSTRUCTED = 32;
+var DerClass = /* @__PURE__ */ ((DerClass2) => {
+  DerClass2[DerClass2["Universal"] = 0] = "Universal";
+  DerClass2[DerClass2["Application"] = 64] = "Application";
+  DerClass2[DerClass2["ContextSpecific"] = 128] = "ContextSpecific";
+  DerClass2[DerClass2["Private"] = 192] = "Private";
+  return DerClass2;
+})(DerClass || {});
+const ObjectId = (objectId) => ({
+  ["_tag" /* TagId */]: 6 /* ObjectIdentifier */,
+  ["_bytes" /* Bytes */]: Bytes.fromHex(objectId)
+});
+const DerObject = (objectId, content = {}) => ({
+  ["_objectId" /* ObjectId */]: ObjectId(objectId),
+  ...content
+});
+const BitByteArray = (data, padding = 0) => ({
+  ["_tag" /* TagId */]: 3 /* BitString */,
+  ["_bytes" /* Bytes */]: data,
+  ["_padding" /* BitsPadding */]: padding
+});
+const ContextTagged = (tagId, value) => ({
+  ["_tag" /* TagId */]: tagId | 128 /* ContextSpecific */ | CONSTRUCTED,
+  ["_bytes" /* Bytes */]: value === void 0 ? new Uint8Array(0) : DerCodec.encode(value)
+});
+const ContextTaggedBytes = (tagId, value) => ({
+  ["_tag" /* TagId */]: tagId | 128 /* ContextSpecific */,
+  ["_bytes" /* Bytes */]: value
+});
+const DatatypeOverride = (type, value) => ({
+  ["_type" /* TypeOverride */]: type,
+  ["_raw" /* RawData */]: value
+});
+const RawBytes = (bytes) => ({
+  ["_bytes" /* Bytes */]: bytes
+});
+class DerCodec {
+  static encode(value) {
+    if (Array.isArray(value)) {
+      return this.encodeArray(value);
+    } else if (value instanceof Uint8Array) {
+      return this.encodeOctetString(value);
+    } else if (value instanceof Date) {
+      return this.encodeDate(value);
+    } else if (typeof value === "string") {
+      return this.encodeString(value);
+    } else if (typeof value === "number" || typeof value === "bigint") {
+      return this.encodeInteger(value);
+    } else if (typeof value === "boolean") {
+      return this.encodeBoolean(value);
+    } else if (value === void 0) {
+      return new Uint8Array(0);
+    } else if (isObject(value)) {
+      if (value["_tag" /* TagId */] !== void 0) {
+        const { ["_tag" /* TagId */]: tagId, ["_padding" /* BitsPadding */]: bitsPadding, ["_bytes" /* Bytes */]: bytes } = value;
+        if (typeof tagId !== "number") {
+          throw new DerError("Tag ID is non-numeric");
+        }
+        if (bitsPadding !== void 0 && typeof bitsPadding !== "number") {
+          throw new DerError("Bits padding is not a numeric byte value");
+        }
+        if (bytes === void 0 || !ArrayBuffer.isView(bytes)) {
+          throw new DerError("DER bytes is not a byte array");
+        }
+        return this.encodeAsn1(
+          tagId,
+          bitsPadding === void 0 ? bytes : Bytes.concat(Uint8Array.of(bitsPadding), bytes)
+        );
+      } else if (value["_type" /* TypeOverride */] !== void 0 && value["_raw" /* RawData */] !== void 0) {
+        if (value["_type" /* TypeOverride */] === 2 /* Integer */ && value["_raw" /* RawData */] instanceof Uint8Array) {
+          return this.encodeInteger(value["_raw" /* RawData */]);
+        } else if (value["_type" /* TypeOverride */] === 3 /* BitString */ && typeof value["_raw" /* RawData */] === "number") {
+          return this.encodeBitString(value["_raw" /* RawData */]);
+        } else if (value["_type" /* TypeOverride */] === 19 /* PrintableString */ && typeof value["_raw" /* RawData */] === "string") {
+          return this.encodePrintableString(value["_raw" /* RawData */]);
+        } else if (value["_type" /* TypeOverride */] === 22 /* IA5String */ && typeof value["_raw" /* RawData */] === "string") {
+          return this.encodeIA5String(value["_raw" /* RawData */]);
+        } else {
+          throw new UnexpectedDataError(`Unsupported override type ${value["_type" /* TypeOverride */]}`);
+        }
+      } else if (value["_bytes" /* Bytes */] !== void 0 && value["_bytes" /* Bytes */] instanceof Uint8Array && Object.keys(value).length === 1) {
+        return value["_bytes" /* Bytes */];
+      } else if (value["_type" /* TypeOverride */] === void 0 && value["_bytes" /* Bytes */] === void 0) {
+        return this.encodeObject(value);
+      } else {
+        throw new UnexpectedDataError(`Unsupported object type ${typeof value}`);
+      }
+    } else {
+      throw new UnexpectedDataError(`Unsupported type ${typeof value}`);
+    }
+  }
+  static encodeDate(date) {
+    if (date.getFullYear() > 2049) {
+      return this.encodeAsn1(
+        24 /* GeneralizedTime */,
+        Bytes.fromString(
+          date.toISOString().replace(/[-:.T]/g, "").slice(0, 14) + "Z"
+        )
+      );
+    } else
+      return this.encodeAsn1(
+        23 /* UtcDate */,
+        Bytes.fromString(
+          date.toISOString().replace(/[-:.T]/g, "").slice(2, 14) + "Z"
+        )
+      );
+  }
+  static encodeBoolean(bool) {
+    return this.encodeAsn1(1 /* Boolean */, Uint8Array.of(bool ? 255 : 0));
+  }
+  static encodeArray(array) {
+    return this.encodeAsn1(17 /* Set */ | CONSTRUCTED, Bytes.concat(...array.map((element) => this.encode(element))));
+  }
+  static encodeOctetString(value) {
+    return this.encodeAsn1(4 /* OctetString */, value);
+  }
+  static encodeObject(object) {
+    const attributes = new Array();
+    for (const key in object) {
+      attributes.push(this.encode(object[key]));
+    }
+    return this.encodeAsn1(16 /* Sequence */ | CONSTRUCTED, Bytes.concat(...attributes));
+  }
+  static encodeString(value) {
+    return this.encodeAsn1(12 /* UTF8String */, Bytes.fromString(value));
+  }
+  static encodePrintableString(value) {
+    if (!/^[A-Za-z0-9 '()+,-./:=?]*$/g.test(value)) {
+      throw new UnexpectedDataError(`String ${value} is not a printable string.`);
+    }
+    return this.encodeAsn1(19 /* PrintableString */, Bytes.fromString(value));
+  }
+  static encodeIA5String(value) {
+    if (!/^[\x00-\x7F]*$/.test(value)) {
+      throw new UnexpectedDataError(`String ${value} is not an IA5 string.`);
+    }
+    return this.encodeAsn1(22 /* IA5String */, Bytes.fromString(value));
+  }
+  static encodeInteger(value) {
+    const isByteArray = ArrayBuffer.isView(value);
+    let valueBytes;
+    if (isByteArray) {
+      valueBytes = value;
+    } else {
+      valueBytes = Bytes.fromHex(toHex(value));
+    }
+    const byteArray = Bytes.concat(new Uint8Array(1), valueBytes);
+    const dataView = Bytes.dataViewOf(byteArray);
+    let start = 0;
+    while (true) {
+      if (dataView.getUint8(start) !== 0) break;
+      if (dataView.getUint8(start + 1) >= 128) break;
+      start++;
+      if (start === byteArray.length - 1) break;
+    }
+    return this.encodeAsn1(2 /* Integer */, byteArray.slice(start));
+  }
+  static encodeBitString(value) {
+    const reversedBits = value.toString(2).padStart(8, "0");
+    const unusedBits = reversedBits.indexOf("1");
+    const bitByteArray = Uint8Array.of(parseInt(reversedBits.split("").reverse().join(""), 2));
+    return this.encode(BitByteArray(bitByteArray, unusedBits === -1 ? 8 : unusedBits));
+  }
+  static encodeLengthBytes(value) {
+    const byteArray = new Uint8Array(5);
+    const dataView = Bytes.dataViewOf(byteArray);
+    dataView.setUint32(1, value);
+    let start = 0;
+    while (true) {
+      if (dataView.getUint8(start) !== 0) break;
+      start++;
+      if (start === 4) break;
+    }
+    const lengthLength = byteArray.length - start;
+    if (lengthLength > 1 || dataView.getUint8(start) >= 128) {
+      start--;
+      dataView.setUint8(start, 128 + lengthLength);
+    }
+    return byteArray.slice(start);
+  }
+  static encodeAsn1(tag, data) {
+    return Bytes.concat(Uint8Array.of(tag), this.encodeLengthBytes(data.length), data);
+  }
+  static decode(data) {
+    return this.decodeRec(new DataReader(data, Endian.Big));
+  }
+  static decodeRec(reader) {
+    const { tag, bytes } = this.decodeAsn1(reader);
+    if (tag === 3 /* BitString */)
+      return { ["_tag" /* TagId */]: tag, ["_bytes" /* Bytes */]: bytes.slice(1), ["_padding" /* BitsPadding */]: bytes[0] };
+    if ((tag & CONSTRUCTED) === 0) return { ["_tag" /* TagId */]: tag, ["_bytes" /* Bytes */]: bytes };
+    const elementsReader = new DataReader(bytes, Endian.Big);
+    const elements = [];
+    while (elementsReader.getRemainingBytesCount() > 0) {
+      elements.push(this.decodeRec(elementsReader));
+    }
+    return { ["_tag" /* TagId */]: tag, ["_bytes" /* Bytes */]: bytes, ["_elements" /* Elements */]: elements };
+  }
+  static decodeAsn1(reader) {
+    const tag = reader.readUInt8();
+    let length = reader.readUInt8();
+    if ((length & 128) !== 0) {
+      let lengthLength = length & 127;
+      length = 0;
+      while (lengthLength > 0) {
+        length = (length << 8) + reader.readUInt8();
+        lengthLength--;
+      }
+    }
+    const bytes = reader.readByteArray(length);
+    return { tag, bytes };
+  }
+}
+export {
+  BitByteArray,
+  ContextTagged,
+  ContextTaggedBytes,
+  DatatypeOverride,
+  DerCodec,
+  DerError,
+  DerKey,
+  DerObject,
+  DerType,
+  ObjectId,
+  RawBytes
+};
+//# sourceMappingURL=DerCodec.js.map