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

package/dist/cjs/crypto/Key.js

@@ -0,0 +1,356 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Key_exports = {};
+__export(Key_exports, {
+  CurveType: () => CurveType,
+  Key: () => Key,
+  KeyType: () => KeyType,
+  PrivateKey: () => PrivateKey,
+  PublicKey: () => PublicKey,
+  SymmetricKey: () => SymmetricKey
+});
+module.exports = __toCommonJS(Key_exports);
+var import_Base64Codec = require("../codec/Base64Codec.js");
+var import_DerCodec = require("../codec/DerCodec.js");
+var import_MatterError = require("../MatterError.js");
+var import_Bytes = require("../util/Bytes.js");
+var import_Crypto = require("./Crypto.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const {
+  numberToBytesBE,
+  p256: { ProjectivePoint }
+} = import_Crypto.ec;
+class KeyError extends import_MatterError.MatterError {
+}
+const JWK_KEYS = [
+  "crv",
+  "d",
+  "dp",
+  "dq",
+  "e",
+  "ext",
+  "k",
+  "key_ops",
+  "kty",
+  "n",
+  "oth",
+  "p",
+  "q",
+  "qi",
+  "use",
+  "x",
+  "y"
+];
+var KeyType = /* @__PURE__ */ ((KeyType2) => {
+  KeyType2["EC"] = "EC";
+  KeyType2["RSA"] = "RSA";
+  KeyType2["oct"] = "oct";
+  return KeyType2;
+})(KeyType || {});
+var CurveType = /* @__PURE__ */ ((CurveType2) => {
+  CurveType2["p256"] = "P-256";
+  CurveType2["p384"] = "P-384";
+  CurveType2["p521"] = "P-521";
+  return CurveType2;
+})(CurveType || {});
+var Asn1ObjectID = /* @__PURE__ */ ((Asn1ObjectID2) => {
+  Asn1ObjectID2["ecPublicKey"] = "2a8648ce3d0201";
+  Asn1ObjectID2["prime256r1"] = "2a8648ce3d030107";
+  Asn1ObjectID2["prime384r1"] = "0103840022";
+  Asn1ObjectID2["prime521r1"] = "0103840023";
+  return Asn1ObjectID2;
+})(Asn1ObjectID || {});
+const CurveLookup = {
+  ["2a8648ce3d030107" /* prime256r1 */]: "P-256" /* p256 */,
+  ["0103840022" /* prime384r1 */]: "P-384" /* p384 */,
+  ["0103840023" /* prime521r1 */]: "P-521" /* p521 */
+};
+function checkDerVersion(type, node, version) {
+  const derVersion = node && node._tag === import_DerCodec.DerType.Integer && node._bytes && node._bytes.length === 1 && node._bytes[0];
+  if (derVersion !== version) {
+    throw new KeyError(`${type} key version mismatch`);
+  }
+}
+function getDerObjectID(type, node) {
+  const id = node && node._tag === import_DerCodec.DerType.ObjectIdentifier && node._bytes?.length > 1 && node._bytes;
+  if (id) return id;
+  throw new KeyError(`Missing object in ${type} key`);
+}
+function getDerCurve(type, node) {
+  const oid = getDerObjectID(type, node);
+  const curve = CurveLookup[import_Bytes.Bytes.toHex(oid)];
+  if (curve) return curve;
+  throw new KeyError(`Unsupported ${type} EC curve`);
+}
+function getDerKey(type, node, derType = import_DerCodec.DerType.OctetString) {
+  const key = node && node._tag === derType && node._bytes?.length > 1 && node._bytes;
+  if (key) return key;
+  throw new import_MatterError.MatterError(`Missing ${type} key node`);
+}
+var Translators;
+((Translators2) => {
+  Translators2.sec1 = {
+    set: function(input) {
+      const decoded = import_DerCodec.DerCodec.decode(input);
+      const versionNode = decoded?._elements?.[0];
+      checkDerVersion("SEC 1", versionNode, 1);
+      const curveNode = decoded?._elements?.[2]?._elements?.[0];
+      const curve = getDerCurve("SEC 1", curveNode);
+      const keyNode = decoded?._elements?.[1];
+      const key = getDerKey("SEC 1", keyNode);
+      this.type = "EC" /* EC */;
+      this.curve = curve;
+      this.privateBits = key;
+    },
+    get: function() {
+      throw new import_MatterError.NotImplementedError("SEC1 export not implemented");
+    }
+  };
+  Translators2.pkcs8 = {
+    set: function(input) {
+      const outer = import_DerCodec.DerCodec.decode(input);
+      const version = outer?._elements?.[0];
+      checkDerVersion("PKCS #8", version, 0);
+      const algorithmElements = outer?._elements?.[1]?._elements;
+      const algorithm = getDerObjectID("PKCS #8", algorithmElements?.[0]);
+      if (import_Bytes.Bytes.toHex(algorithm) !== "2a8648ce3d0201" /* ecPublicKey */) {
+        throw new KeyError("Unsupported PKCS #8 decryption algorithm");
+      }
+      const curve = getDerCurve("PKCS #8", algorithmElements?.[1]);
+      const innerBytes = outer?._elements?.[2]._bytes;
+      if (innerBytes === void 0 || innerBytes === null) {
+        throw new KeyError("Invalid PKCS #8 key");
+      }
+      const inner = import_DerCodec.DerCodec.decode(innerBytes);
+      const key = getDerKey("PKCS #8", inner?._elements?.[1]);
+      this.type = "EC" /* EC */;
+      this.curve = curve;
+      this.privateBits = key;
+    },
+    get: function() {
+      throw new import_MatterError.NotImplementedError("PKCS #8 export not implemented");
+    }
+  };
+  Translators2.spki = {
+    set: function(input) {
+      const decoded = import_DerCodec.DerCodec.decode(input);
+      const algorithmElements = decoded?._elements?.[0]?._elements;
+      const algorithm = getDerObjectID("SPKI", algorithmElements?.[0]);
+      if (import_Bytes.Bytes.toHex(algorithm) !== "2a8648ce3d0201" /* ecPublicKey */) {
+        throw new KeyError("Unsupported SPKI decryption algorithm");
+      }
+      const curve = getDerCurve("SPKI", algorithmElements?.[1]);
+      const key = getDerKey("SPKI", decoded?._elements?.[1], import_DerCodec.DerType.BitString);
+      this.type = "EC" /* EC */;
+      this.curve = curve;
+      this.publicBits = key;
+    },
+    get: function() {
+      throw new import_MatterError.NotImplementedError("SPKI export not implemented");
+    }
+  };
+  Translators2.publicBits = {
+    set: function(input) {
+      if (!(input.length % 2)) {
+        throw new KeyError("Invalid public key encoding");
+      }
+      switch (input[0]) {
+        case 2:
+        case 3:
+          throw new KeyError("Unsupported public key compression");
+        case 4:
+          break;
+        case 5:
+          throw new KeyError("Illegal public key format specifier");
+      }
+      const coordinateLength = (input.length - 1) / 2;
+      inferCurve(this, coordinateLength);
+      this.type = "EC" /* EC */;
+      this.xBits = input.slice(1, coordinateLength + 1);
+      this.yBits = input.slice(coordinateLength + 1);
+    },
+    get: function() {
+      if (this.xBits === void 0 || this.yBits === void 0) {
+        return void 0;
+      }
+      return new Uint8Array([4, ...this.xBits, ...this.yBits]);
+    }
+  };
+  Translators2.keyPairBits = {
+    set: function(keyPair) {
+      this.publicBits = keyPair.publicKey;
+      this.privateBits = keyPair.privateKey;
+    },
+    get: function() {
+      const publicBits2 = this.publicBits;
+      const privateBits = this.privateBits;
+      if (publicBits2 === void 0 || privateBits === void 0) {
+        return;
+      }
+      return {
+        publicKey: publicBits2,
+        privateKey: privateBits
+      };
+    }
+  };
+})(Translators || (Translators = {}));
+var Aliases = /* @__PURE__ */ ((Aliases2) => {
+  Aliases2["algorithm"] = "alg";
+  Aliases2["curve"] = "crv";
+  Aliases2["type"] = "kty";
+  Aliases2["operations"] = "key_ops";
+  Aliases2["private"] = "d";
+  Aliases2["extractable"] = "ext";
+  return Aliases2;
+})(Aliases || {});
+var Base64Codecs = /* @__PURE__ */ ((Base64Codecs2) => {
+  Base64Codecs2["privateBits"] = "d";
+  Base64Codecs2["xBits"] = "x";
+  Base64Codecs2["yBits"] = "y";
+  return Base64Codecs2;
+})(Base64Codecs || {});
+var AssertedAliases = /* @__PURE__ */ ((AssertedAliases2) => {
+  AssertedAliases2["publicKey"] = "publicBits";
+  AssertedAliases2["privateKey"] = "privateBits";
+  AssertedAliases2["keyPair"] = "keyPairBits";
+  return AssertedAliases2;
+})(AssertedAliases || {});
+function inferCurve(key, bytes) {
+  if (!key.curve) {
+    switch (bytes) {
+      case 66:
+        key.curve = "P-521" /* p521 */;
+        break;
+      case 48:
+        key.curve = "P-384" /* p384 */;
+        break;
+      case 32:
+        key.curve = "P-256" /* p256 */;
+        break;
+      default:
+        throw new KeyError(`Cannot infer named curve from key length ${bytes}`);
+    }
+  }
+}
+function Key(properties) {
+  const that = {};
+  for (const key of JWK_KEYS) {
+    if (properties[key] !== void 0) that[key] = properties[key];
+  }
+  function assign(name) {
+    const d = Object.getOwnPropertyDescriptor(properties, name);
+    if (d && d.value !== void 0) {
+      that[name] = d.value;
+    }
+  }
+  Object.entries(Aliases).forEach(([alias, target]) => {
+    Object.defineProperty(that, alias, {
+      get: () => that[target],
+      set: (value) => that[target] = value
+    });
+    assign(alias);
+  });
+  Object.entries(Base64Codecs).forEach(([alias, target]) => {
+    Object.defineProperty(that, alias, {
+      get: () => that[target] !== void 0 && import_Base64Codec.Base64.decode(that[target]),
+      set: (value) => that[target] = value === void 0 ? void 0 : import_Base64Codec.Base64.encode(value, true)
+    });
+    assign(alias);
+  });
+  Object.entries(Translators).forEach(([name, translator]) => {
+    Object.defineProperty(that, name, translator);
+  });
+  Object.keys(Translators).forEach((name) => assign(name));
+  Object.entries(AssertedAliases).forEach(([alias, target]) => {
+    Object.defineProperty(that, alias, {
+      get: () => {
+        const result = that[target];
+        if (result === void 0) {
+          throw new KeyError(`Key field ${target} is not defined`);
+        }
+        return result;
+      },
+      set: (value) => {
+        that[target] = value;
+      }
+    });
+    assign(alias);
+  });
+  function derivePublicFromPrivate() {
+    if (that.type !== "EC" /* EC */) throw new KeyError("EC key type required to compute public point");
+    if (!that.private) throw new KeyError("EC private key required to compute public point");
+    const crv = that.crv;
+    let keyLength;
+    switch (crv) {
+      case "P-256" /* p256 */:
+        keyLength = 32;
+        break;
+      default:
+        throw new KeyError(`Unsupported elliptic curve ${crv}`);
+    }
+    const ecKey = ProjectivePoint.fromPrivateKey(that.privateKey);
+    that.xBits = numberToBytesBE(ecKey.x, keyLength);
+    that.yBits = numberToBytesBE(ecKey.y, keyLength);
+  }
+  if (that.type === "EC" /* EC */) {
+    if (that.d) {
+      inferCurve(that, that.privateKey.length);
+    } else if (that.xBits) {
+      inferCurve(that, that.xBits.length);
+    }
+    if (that.d && (!that.x || !that.y)) {
+      derivePublicFromPrivate();
+    }
+  }
+  return that;
+}
+function PrivateKey(privateKey, options) {
+  let priv, pub;
+  if (ArrayBuffer.isView(privateKey)) {
+    priv = privateKey;
+  } else {
+    priv = privateKey.privateKey;
+    pub = privateKey.publicKey;
+  }
+  return Key({
+    type: "EC" /* EC */,
+    privateKey: priv,
+    publicKey: pub,
+    ...options
+  });
+}
+function PublicKey(publicKey, options) {
+  return Key({
+    type: "EC" /* EC */,
+    publicKey,
+    ...options
+  });
+}
+function SymmetricKey(privateKey, options) {
+  return Key({
+    type: "oct" /* oct */,
+    privateKey,
+    ...options
+  });
+}
+//# sourceMappingURL=Key.js.map

package/dist/cjs/crypto/Key.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/crypto/Key.ts"],
+  "mappings": "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",
+  "names": ["KeyType", "CurveType", "Asn1ObjectID", "Translators", "publicBits", "Aliases", "Base64Codecs", "AssertedAliases"]
+}

package/dist/cjs/crypto/Spake2p.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface PbkdfParameters {
+    iterations: number;
+    salt: Uint8Array;
+}
+export declare class Spake2p {
+    private readonly context;
+    private readonly random;
+    private readonly w0;
+    static computeW0W1({ iterations, salt }: PbkdfParameters, pin: number): Promise<{
+        w0: bigint;
+        w1: bigint;
+    }>;
+    static computeW0L(pbkdfParameters: PbkdfParameters, pin: number): Promise<{
+        w0: bigint;
+        L: Uint8Array;
+    }>;
+    static create(context: Uint8Array, w0: bigint): Spake2p;
+    constructor(context: Uint8Array, random: bigint, w0: bigint);
+    computeX(): Uint8Array;
+    computeY(): Uint8Array;
+    computeSecretAndVerifiersFromY(w1: bigint, X: Uint8Array, Y: Uint8Array): Promise<{
+        Ke: Uint8Array;
+        hAY: Uint8Array;
+        hBX: Uint8Array;
+    }>;
+    computeSecretAndVerifiersFromX(L: Uint8Array, X: Uint8Array, Y: Uint8Array): Promise<{
+        Ke: Uint8Array;
+        hAY: Uint8Array;
+        hBX: Uint8Array;
+    }>;
+    private computeSecretAndVerifiers;
+    private computeTranscriptHash;
+    private addToContext;
+}
+//# sourceMappingURL=Spake2p.d.ts.map

package/dist/cjs/crypto/Spake2p.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Spake2p.d.ts","sourceRoot":"","sources":["../../../src/crypto/Spake2p.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAqBH,MAAM,WAAW,eAAe;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,UAAU,CAAC;CACpB;AAED,qBAAa,OAAO;IAsBZ,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,EAAE;WAvBV,WAAW,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM;;;;WAS9D,UAAU,CAAC,eAAe,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM;;;;IAMrE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM;gBAMxB,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM;IAG/B,QAAQ,IAAI,UAAU;IAKtB,QAAQ,IAAI,UAAU;IAKhB,8BAA8B,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;;;;;IAavE,8BAA8B,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;;;;;YAalE,yBAAyB;IAevC,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,YAAY;CAIvB"}

package/dist/cjs/crypto/Spake2p.js

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+var Spake2p_exports = {};
+__export(Spake2p_exports, {
+  Spake2p: () => Spake2p
+});
+module.exports = __toCommonJS(Spake2p_exports);
+var import_MatterError = require("../MatterError.js");
+var import_Bytes = require("../util/Bytes.js");
+var import_DataWriter = require("../util/DataWriter.js");
+var import_Crypto = require("./Crypto.js");
+var import_CryptoConstants = require("./CryptoConstants.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const {
+  p256: { ProjectivePoint, CURVE: P256_CURVE },
+  numberToBytesBE,
+  bytesToNumberBE,
+  mod
+} = import_Crypto.ec;
+const M = ProjectivePoint.fromHex("02886e2f97ace46e55ba9dd7242579f2993b64e16ef3dcab95afd497333d8fa12f");
+const N = ProjectivePoint.fromHex("03d8bbd6c639c62937b04d997f38c3770719c629d7014d49a24b4f98baa1292b49");
+const CRYPTO_W_SIZE_BYTES = import_CryptoConstants.CRYPTO_GROUP_SIZE_BYTES + 8;
+class Spake2p {
+  constructor(context, random, w0) {
+    this.context = context;
+    this.random = random;
+    this.w0 = w0;
+  }
+  static async computeW0W1({ iterations, salt }, pin) {
+    const pinWriter = new import_DataWriter.DataWriter(import_Bytes.Endian.Little);
+    pinWriter.writeUInt32(pin);
+    const ws = await import_Crypto.Crypto.pbkdf2(pinWriter.toByteArray(), salt, iterations, CRYPTO_W_SIZE_BYTES * 2);
+    const w0 = mod(bytesToNumberBE(ws.slice(0, 40)), P256_CURVE.n);
+    const w1 = mod(bytesToNumberBE(ws.slice(40, 80)), P256_CURVE.n);
+    return { w0, w1 };
+  }
+  static async computeW0L(pbkdfParameters, pin) {
+    const { w0, w1 } = await this.computeW0W1(pbkdfParameters, pin);
+    const L = ProjectivePoint.BASE.multiply(w1).toRawBytes(false);
+    return { w0, L };
+  }
+  static create(context, w0) {
+    const random = import_Crypto.Crypto.getRandomBigInt(32, P256_CURVE.p);
+    return new Spake2p(context, random, w0);
+  }
+  computeX() {
+    const X = ProjectivePoint.BASE.multiply(this.random).add(M.multiply(this.w0));
+    return X.toRawBytes(false);
+  }
+  computeY() {
+    const Y = ProjectivePoint.BASE.multiply(this.random).add(N.multiply(this.w0));
+    return Y.toRawBytes(false);
+  }
+  async computeSecretAndVerifiersFromY(w1, X, Y) {
+    const YPoint = ProjectivePoint.fromHex(Y);
+    try {
+      YPoint.assertValidity();
+    } catch (error) {
+      throw new import_MatterError.InternalError(`Y is not on the curve: ${error.message}`);
+    }
+    const yNwo = YPoint.add(N.multiply(this.w0).negate());
+    const Z = yNwo.multiply(this.random);
+    const V = yNwo.multiply(w1);
+    return this.computeSecretAndVerifiers(X, Y, Z.toRawBytes(false), V.toRawBytes(false));
+  }
+  async computeSecretAndVerifiersFromX(L, X, Y) {
+    const XPoint = ProjectivePoint.fromHex(X);
+    const LPoint = ProjectivePoint.fromHex(L);
+    try {
+      XPoint.assertValidity();
+    } catch (error) {
+      throw new import_MatterError.InternalError(`X is not on the curve: ${error.message}`);
+    }
+    const Z = XPoint.add(M.multiply(this.w0).negate()).multiply(this.random);
+    const V = LPoint.multiply(this.random);
+    return this.computeSecretAndVerifiers(X, Y, Z.toRawBytes(false), V.toRawBytes(false));
+  }
+  async computeSecretAndVerifiers(X, Y, Z, V) {
+    const TT_HASH = this.computeTranscriptHash(X, Y, Z, V);
+    const Ka = TT_HASH.slice(0, 16);
+    const Ke = TT_HASH.slice(16, 32);
+    const KcAB = await import_Crypto.Crypto.hkdf(Ka, new Uint8Array(0), import_Bytes.Bytes.fromString("ConfirmationKeys"), 32);
+    const KcA = KcAB.slice(0, 16);
+    const KcB = KcAB.slice(16, 32);
+    const hAY = import_Crypto.Crypto.hmac(KcA, Y);
+    const hBX = import_Crypto.Crypto.hmac(KcB, X);
+    return { Ke, hAY, hBX };
+  }
+  computeTranscriptHash(X, Y, Z, V) {
+    const TTwriter = new import_DataWriter.DataWriter(import_Bytes.Endian.Little);
+    this.addToContext(TTwriter, this.context);
+    this.addToContext(TTwriter, import_Bytes.Bytes.fromString(""));
+    this.addToContext(TTwriter, import_Bytes.Bytes.fromString(""));
+    this.addToContext(TTwriter, M.toRawBytes(false));
+    this.addToContext(TTwriter, N.toRawBytes(false));
+    this.addToContext(TTwriter, X);
+    this.addToContext(TTwriter, Y);
+    this.addToContext(TTwriter, Z);
+    this.addToContext(TTwriter, V);
+    this.addToContext(TTwriter, numberToBytesBE(this.w0, 32));
+    return import_Crypto.Crypto.hash(TTwriter.toByteArray());
+  }
+  addToContext(TTwriter, data) {
+    TTwriter.writeUInt64(data.length);
+    TTwriter.writeByteArray(data);
+  }
+}
+//# sourceMappingURL=Spake2p.js.map

package/dist/cjs/crypto/Spake2p.js.map

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

package/dist/cjs/crypto/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./Crypto.js";
+export * from "./CryptoConstants.js";
+export * from "./Key.js";
+export * from "./Spake2p.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,sBAAsB,CAAC;AACrC,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC"}

package/dist/cjs/crypto/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var crypto_exports = {};
+module.exports = __toCommonJS(crypto_exports);
+__reExport(crypto_exports, require("./Crypto.js"), module.exports);
+__reExport(crypto_exports, require("./CryptoConstants.js"), module.exports);
+__reExport(crypto_exports, require("./Key.js"), module.exports);
+__reExport(crypto_exports, require("./Spake2p.js"), module.exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=index.js.map

package/dist/cjs/crypto/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/crypto/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,2BAAc,wBANd;AAOA,2BAAc,iCAPd;AAQA,2BAAc,qBARd;AASA,2BAAc,yBATd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}