@project-chip/matter.js 0.2.1 → 0.3.0

package/dist/es/fabric/Fabric.js

@@ -0,0 +1,205 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Crypto } from "../crypto/Crypto.js";
+import { CertificateManager, TlvOperationalCertificate, TlvRootCertificate } from "../certificate/CertificateManager.js";
+import { NodeId } from "../datatype/NodeId.js";
+import { FabricIndex } from "../datatype/FabricIndex.js";
+import { FabricId } from "../datatype/FabricId.js";
+import { VendorId } from "../datatype/VendorId.js";
+import { ByteArray, Endian } from "../util/ByteArray.js";
+import { DataWriter } from "../util/DataWriter.js";
+import { toBigInt } from "../util/Number.js";
+const COMPRESSED_FABRIC_ID_INFO = ByteArray.fromString("CompressedFabric");
+const GROUP_SECURITY_INFO = ByteArray.fromString("GroupKey v1.0");
+export class Fabric {
+    constructor(fabricIndex, fabricId, nodeId, rootNodeId, operationalId, rootPublicKey, keyPair, rootVendorId, rootCert, identityProtectionKey, operationalIdentityProtectionKey, intermediateCACert, operationalCert, label, scopedClusterData) {
+        this.fabricIndex = fabricIndex;
+        this.fabricId = fabricId;
+        this.nodeId = nodeId;
+        this.rootNodeId = rootNodeId;
+        this.operationalId = operationalId;
+        this.rootPublicKey = rootPublicKey;
+        this.keyPair = keyPair;
+        this.rootVendorId = rootVendorId;
+        this.rootCert = rootCert;
+        this.identityProtectionKey = identityProtectionKey;
+        this.operationalIdentityProtectionKey = operationalIdentityProtectionKey;
+        this.intermediateCACert = intermediateCACert;
+        this.operationalCert = operationalCert;
+        this.label = label;
+        this.sessions = new Array();
+        this.scopedClusterData = scopedClusterData !== null && scopedClusterData !== void 0 ? scopedClusterData : new Map();
+    }
+    toStorageObject() {
+        return {
+            fabricIndex: this.fabricIndex.index,
+            fabricId: this.fabricId.id,
+            nodeId: this.nodeId.id,
+            rootNodeId: this.rootNodeId.id,
+            operationalId: this.operationalId,
+            rootPublicKey: this.rootPublicKey,
+            keyPair: this.keyPair,
+            rootVendorId: this.rootVendorId.id,
+            rootCert: this.rootCert,
+            identityProtectionKey: this.identityProtectionKey,
+            operationalIdentityProtectionKey: this.operationalIdentityProtectionKey,
+            intermediateCACert: this.intermediateCACert,
+            operationalCert: this.operationalCert,
+            label: this.label,
+            scopedClusterData: this.scopedClusterData
+        };
+    }
+    static createFromStorageObject(fabricObject) {
+        return new Fabric(new FabricIndex(fabricObject.fabricIndex), new FabricId(fabricObject.fabricId), new NodeId(fabricObject.nodeId), new NodeId(fabricObject.rootNodeId), fabricObject.operationalId, fabricObject.rootPublicKey, fabricObject.keyPair, new VendorId(fabricObject.rootVendorId), fabricObject.rootCert, fabricObject.identityProtectionKey, fabricObject.operationalIdentityProtectionKey, fabricObject.intermediateCACert, fabricObject.operationalCert, fabricObject.label);
+    }
+    setLabel(label) {
+        this.label = label;
+        this.persist();
+    }
+    getPublicKey() {
+        return this.keyPair.publicKey;
+    }
+    sign(data) {
+        return Crypto.signPkcs8(this.keyPair.privateKey, data);
+    }
+    verifyCredentials(_operationalCert, _intermediateCACert) {
+        // TODO: implement verification
+        return;
+    }
+    getDestinationId(nodeId, random) {
+        const writer = new DataWriter(Endian.Little);
+        writer.writeByteArray(random);
+        writer.writeByteArray(this.rootPublicKey);
+        writer.writeUInt64(this.fabricId.id);
+        writer.writeUInt64(nodeId.id);
+        return Crypto.hmac(this.operationalIdentityProtectionKey, writer.toByteArray());
+    }
+    addSession(session) {
+        this.sessions.push(session);
+    }
+    removeSession(session) {
+        const index = this.sessions.indexOf(session);
+        if (index >= 0) {
+            this.sessions.splice(index, 1);
+        }
+    }
+    setRemoveCallback(callback) {
+        this.removeCallback = callback;
+    }
+    setPersistCallback(callback) {
+        this.persistCallback = callback;
+    }
+    remove() {
+        var _a;
+        this.sessions.forEach(session => session.destroy());
+        (_a = this.removeCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    persist() {
+        var _a;
+        (_a = this.persistCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    getScopedClusterDataValue(cluster, clusterDataKey) {
+        const dataMap = this.scopedClusterData.get(cluster.id);
+        if (dataMap === undefined) {
+            return undefined;
+        }
+        return dataMap.get(clusterDataKey);
+    }
+    setScopedClusterDataValue(cluster, clusterDataKey, value) {
+        if (!this.scopedClusterData.has(cluster.id)) {
+            this.scopedClusterData.set(cluster.id, new Map());
+        }
+        this.scopedClusterData.get(cluster.id).set(clusterDataKey, value);
+        this.persist();
+    }
+    deleteScopedClusterDataValue(cluster, clusterDataKey) {
+        if (!this.scopedClusterData.has(cluster.id)) {
+            return;
+        }
+        this.scopedClusterData.get(cluster.id).delete(clusterDataKey);
+        this.persist();
+    }
+    hasScopedClusterDataValue(cluster, clusterDataKey) {
+        return this.scopedClusterData.has(cluster.id) && this.scopedClusterData.get(cluster.id).has(clusterDataKey);
+    }
+    deleteScopedClusterData(cluster) {
+        this.scopedClusterData.delete(cluster.id);
+        this.persist();
+    }
+    getScopedClusterDataKeys(cluster) {
+        if (!this.scopedClusterData.has(cluster.id)) {
+            return [];
+        }
+        return Array.from(this.scopedClusterData.get(cluster.id).keys());
+    }
+}
+export class FabricBuilder {
+    constructor(fabricIndex) {
+        this.fabricIndex = fabricIndex;
+        this.keyPair = Crypto.createKeyPair();
+    }
+    getPublicKey() {
+        return this.keyPair.publicKey;
+    }
+    createCertificateSigningRequest() {
+        return CertificateManager.createCertificateSigningRequest(this.keyPair);
+    }
+    setRootCert(rootCert) {
+        this.rootCert = rootCert;
+        this.rootPublicKey = TlvRootCertificate.decode(rootCert).ellipticCurvePublicKey;
+        return this;
+    }
+    setOperationalCert(operationalCert) {
+        this.operationalCert = operationalCert;
+        const { subject: { nodeId, fabricId } } = TlvOperationalCertificate.decode(operationalCert);
+        this.fabricId = new FabricId(toBigInt(fabricId));
+        this.nodeId = nodeId;
+        return this;
+    }
+    setIntermediateCACert(certificate) {
+        this.intermediateCACert = certificate;
+        return this;
+    }
+    setRootVendorId(rootVendorId) {
+        this.rootVendorId = rootVendorId;
+        return this;
+    }
+    setRootNodeId(rootNodeId) {
+        this.rootNodeId = rootNodeId;
+        return this;
+    }
+    setIdentityProtectionKey(key) {
+        this.identityProtectionKey = key;
+        return this;
+    }
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.rootNodeId === undefined)
+                throw new Error("rootNodeId needs to be set");
+            if (this.rootVendorId === undefined)
+                throw new Error("vendorId needs to be set");
+            if (this.rootCert === undefined || this.rootPublicKey === undefined)
+                throw new Error("rootCert needs to be set");
+            if (this.identityProtectionKey === undefined)
+                throw new Error("identityProtectionKey needs to be set");
+            if (this.operationalCert === undefined || this.fabricId === undefined || this.nodeId === undefined)
+                throw new Error("operationalCert needs to be set");
+            const saltWriter = new DataWriter(Endian.Big);
+            saltWriter.writeUInt64(this.fabricId.id);
+            const operationalId = yield Crypto.hkdf(this.rootPublicKey.slice(1), saltWriter.toByteArray(), COMPRESSED_FABRIC_ID_INFO, 8);
+            return new Fabric(this.fabricIndex, this.fabricId, this.nodeId, this.rootNodeId, operationalId, this.rootPublicKey, this.keyPair, this.rootVendorId, this.rootCert, this.identityProtectionKey, yield Crypto.hkdf(this.identityProtectionKey, operationalId, GROUP_SECURITY_INFO, 16), this.intermediateCACert, this.operationalCert, "");
+        });
+    }
+}

package/dist/es/fabric/FabricManager.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Fabric, FabricBuilder } from "./Fabric.js";
+import { MatterError } from "../common/MatterError.js";
+import { FabricIndex } from "../datatype/FabricIndex.js";
+import { StorageManager } from "../storage/StorageManager.js";
+import { ByteArray } from "../util/ByteArray.js";
+/** Specific Error for when a fabric is not found. */
+export declare class FabricNotFoundError extends MatterError {
+}
+export declare class FabricManager {
+    private nextFabricIndex;
+    private readonly fabrics;
+    private fabricBuilder?;
+    private readonly fabricStorage;
+    constructor(storageManager: StorageManager);
+    persistFabrics(): void;
+    addFabric(fabric: Fabric): void;
+    removeFabric(fabricIndex: FabricIndex): void;
+    getFabrics(): Fabric[];
+    findFabricFromDestinationId(destinationId: ByteArray, initiatorRandom: ByteArray): Fabric;
+    armFailSafe(): void;
+    getFabricBuilder(): FabricBuilder;
+    tentativelyAddFabric(): Promise<void>;
+    completeCommission(): void;
+}
+//# sourceMappingURL=FabricManager.d.ts.map

package/dist/es/fabric/FabricManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FabricManager.d.ts","sourceRoot":"","sources":["../../../src/fabric/FabricManager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,aAAa,EAAoB,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,qDAAqD;AACrD,qBAAa,mBAAoB,SAAQ,WAAW;CAAI;AAExD,qBAAa,aAAa;IACtB,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiB;gBAEnC,cAAc,EAAE,cAAc;IAO1C,cAAc;IAKd,SAAS,CAAC,MAAM,EAAE,MAAM;IAMxB,YAAY,CAAC,WAAW,EAAE,WAAW;IAOrC,UAAU;IAIV,2BAA2B,CAAC,aAAa,EAAE,SAAS,EAAE,eAAe,EAAE,SAAS;IAUhF,WAAW;IAIX,gBAAgB;IAMV,oBAAoB;IAM1B,kBAAkB;CAKrB"}

package/dist/es/fabric/FabricManager.js

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Fabric, FabricBuilder } from "./Fabric.js";
+import { MatterError } from "../common/MatterError.js";
+import { FabricIndex } from "../datatype/FabricIndex.js";
+/** Specific Error for when a fabric is not found. */
+export class FabricNotFoundError extends MatterError {
+}
+export class FabricManager {
+    constructor(storageManager) {
+        this.nextFabricIndex = 1;
+        this.fabrics = new Array();
+        this.fabricStorage = storageManager.createContext("FabricManager");
+        const fabrics = this.fabricStorage.get("fabrics", []);
+        fabrics.forEach(fabric => this.addFabric(Fabric.createFromStorageObject(fabric)));
+        this.nextFabricIndex = this.fabricStorage.get("nextFabricIndex", this.nextFabricIndex);
+    }
+    persistFabrics() {
+        this.fabricStorage.set("fabrics", this.fabrics.map(fabric => fabric.toStorageObject()));
+        this.fabricStorage.set("nextFabricIndex", this.nextFabricIndex);
+    }
+    addFabric(fabric) {
+        this.fabrics.push(fabric);
+        fabric.setRemoveCallback(() => this.removeFabric(fabric.fabricIndex));
+        fabric.setPersistCallback(() => this.persistFabrics());
+    }
+    removeFabric(fabricIndex) {
+        const index = this.fabrics.findIndex(fabric => fabric.fabricIndex.index === fabricIndex.index);
+        if (index === -1)
+            throw new FabricNotFoundError(`Fabric with index ${fabricIndex} cannot be removed because it does not exist.`);
+        this.fabrics.splice(index, 1);
+        this.persistFabrics();
+    }
+    getFabrics() {
+        return this.fabrics;
+    }
+    findFabricFromDestinationId(destinationId, initiatorRandom) {
+        for (const fabric of this.fabrics) {
+            const candidateDestinationId = fabric.getDestinationId(fabric.nodeId, initiatorRandom);
+            if (!candidateDestinationId.equals(destinationId))
+                continue;
+            return fabric;
+        }
+        throw new Error("Fabric cannot be found from destinationId");
+    }
+    armFailSafe() {
+        this.fabricBuilder = new FabricBuilder(new FabricIndex(this.nextFabricIndex++));
+    }
+    getFabricBuilder() {
+        const result = this.fabricBuilder;
+        if (result === undefined)
+            throw new Error("armFailSafe should be called first!");
+        return result;
+    }
+    tentativelyAddFabric() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fabricBuilder === undefined)
+                throw new Error("armFailSafe should be called first!");
+            this.fabrics.push(yield this.fabricBuilder.build());
+            this.fabricBuilder = undefined;
+        });
+    }
+    completeCommission() {
+        this.persistFabrics();
+        // TODO: disable failSafe timer
+        // TODO: delete CASE sessions
+    }
+}

package/dist/es/fabric/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./Fabric.js";
+export * from "./FabricManager.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/es/fabric/index.d.ts.map

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

package/dist/es/fabric/index.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./Fabric.js";
+export * from "./FabricManager.js";

package/dist/es/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./spec/Specifications.js";
+export { MatterController } from "./MatterController.js";
+export { MatterDevice } from "./MatterDevice.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/es/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,0BAA0B,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/es/index.js

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Export Specs types
+export * from "./spec/Specifications.js";
+// Export Legacy API
+export { MatterController } from "./MatterController.js";
+export { MatterDevice } from "./MatterDevice.js";

package/dist/es/log/Logger.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare enum Level {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    FATAL = 4
+}
+/**
+ * Logger that can be used to emit traces.
+ *
+ * Usage:
+ * const logger = Logger.get("loggerName");
+ * logger.debug("My debug message", "my extra value to log");
+ *
+ * Configuration:
+ * Logger.defaultLogLevel sets the default log level for all the logger
+ * Logger.logLevels = { loggerName: Level.DEBUG } can set the level for the specific loggers
+ */
+export declare class Logger {
+    private readonly name;
+    static logFormater: (now: Date, level: Level, logger: string, ...values: any[]) => string;
+    static log: (level: Level, formatedLog: string) => void;
+    static defaultLogLevel: Level;
+    static logLevels: {
+        [logger: string]: Level;
+    };
+    static get(name: string): Logger;
+    /**
+     * Returns the value as (BigInt aware) stringified JSON.
+     */
+    static toJSON(data: any): string;
+    constructor(name: string);
+    debug: (...values: any[]) => void;
+    info: (...values: any[]) => void;
+    warn: (...values: any[]) => void;
+    error: (...values: any[]) => void;
+    fatal: (...values: any[]) => void;
+    private log;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/dist/es/log/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../../src/log/Logger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,oBAAY,KAAK;IACb,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;IACT,KAAK,IAAI;CACZ;AAyBD;;;;;;;;;;GAUG;AAEH,qBAAa,MAAM;IAkBX,OAAO,CAAC,QAAQ,CAAC,IAAI;IAjBzB,MAAM,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,MAAM,CAAe;IACxG,MAAM,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAiB;IACxE,MAAM,CAAC,eAAe,QAAe;IACrC,MAAM,CAAC,SAAS,EAAE;QAAE,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAM;IAEnD,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM;IAIvB;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG;gBAKF,IAAI,EAAE,MAAM;IAGjC,KAAK,cAAe,GAAG,EAAE,UAAmC;IAC5D,IAAI,cAAe,GAAG,EAAE,UAAkC;IAC1D,IAAI,cAAe,GAAG,EAAE,UAAkC;IAC1D,KAAK,cAAe,GAAG,EAAE,UAAmC;IAC5D,KAAK,cAAe,GAAG,EAAE,UAAmC;IAE5D,OAAO,CAAC,GAAG;CAId"}

package/dist/es/log/Logger.js

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray } from "../util/ByteArray.js";
+import { Time } from "../time/Time.js";
+import * as console from "console";
+export var Level;
+(function (Level) {
+    Level[Level["DEBUG"] = 0] = "DEBUG";
+    Level[Level["INFO"] = 1] = "INFO";
+    Level[Level["WARN"] = 2] = "WARN";
+    Level[Level["ERROR"] = 3] = "ERROR";
+    Level[Level["FATAL"] = 4] = "FATAL";
+})(Level = Level || (Level = {}));
+function logFormater(now, level, logger, values) {
+    const formattedNow = `${now.getFullYear()}-${(now.getMonth() + 1).toString().padStart(2, "0")}-${now.getDate().toString().padStart(2, "0")} ${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}.${now.getMilliseconds().toString().padStart(3, "0")}`;
+    const formattedValues = values.map(value => {
+        if (value instanceof ByteArray) {
+            return value.toHex();
+        }
+        else if (value instanceof Error) {
+            return value.stack;
+        }
+        return value.toString();
+    });
+    return `${formattedNow} ${Level[level]} ${logger} ${formattedValues.join(" ")}`;
+}
+function consoleLogger(level, formatedLog) {
+    switch (level) {
+        case Level.DEBUG:
+            console.debug(formatedLog);
+            break;
+        case Level.INFO:
+            console.info(formatedLog);
+            break;
+        case Level.WARN:
+            console.warn(formatedLog);
+            break;
+        case Level.ERROR:
+            console.error(formatedLog);
+            break;
+        case Level.FATAL:
+            console.error(formatedLog);
+            break;
+    }
+}
+/**
+ * Logger that can be used to emit traces.
+ *
+ * Usage:
+ * const logger = Logger.get("loggerName");
+ * logger.debug("My debug message", "my extra value to log");
+ *
+ * Configuration:
+ * Logger.defaultLogLevel sets the default log level for all the logger
+ * Logger.logLevels = { loggerName: Level.DEBUG } can set the level for the specific loggers
+ */
+export class Logger {
+    static get(name) {
+        return new Logger(name);
+    }
+    /**
+     * Returns the value as (BigInt aware) stringified JSON.
+     */
+    static toJSON(data) {
+        return JSON.stringify(data, (_, v) => typeof v === 'bigint' ? v.toString() : v);
+    }
+    constructor(name) {
+        this.name = name;
+        this.debug = (...values) => this.log(Level.DEBUG, values);
+        this.info = (...values) => this.log(Level.INFO, values);
+        this.warn = (...values) => this.log(Level.WARN, values);
+        this.error = (...values) => this.log(Level.ERROR, values);
+        this.fatal = (...values) => this.log(Level.FATAL, values);
+    }
+    log(level, values) {
+        var _a;
+        if (level < ((_a = Logger.logLevels[this.name]) !== null && _a !== void 0 ? _a : Logger.defaultLogLevel))
+            return;
+        Logger.log(level, Logger.logFormater(Time.now(), level, this.name, values));
+    }
+}
+Logger.logFormater = logFormater;
+Logger.log = consoleLogger;
+Logger.defaultLogLevel = Level.DEBUG;
+Logger.logLevels = {};

package/dist/es/log/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./Logger.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/es/log/index.d.ts.map

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

package/dist/es/log/index.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./Logger.js";

package/dist/es/math/ReedSolomon.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray } from "../util/ByteArray.js";
+export declare class ReedSolomon {
+    private readonly galoisField;
+    computeErrorCorrection(data: ByteArray, ecLength: number): Uint8Array;
+    private generatePolynom;
+}
+//# sourceMappingURL=ReedSolomon.d.ts.map

package/dist/es/math/ReedSolomon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReedSolomon.d.ts","sourceRoot":"","sources":["../../../src/math/ReedSolomon.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AA8DjD,qBAAa,WAAW;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IAEjD,sBAAsB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM;IAkBxD,OAAO,CAAC,eAAe;CAO1B"}

package/dist/es/math/ReedSolomon.js

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray } from "../util/ByteArray.js";
+class GaloisField {
+    constructor(prime = 0x11d, generator = 2, c_exp = 8) {
+        this.prime = prime;
+        this.exp = new Array();
+        this.log = new Array();
+        this.size = Math.floor(Math.pow(2, c_exp) - 1);
+        let x = 1;
+        for (let i = 0; i < this.size; i++) {
+            this.exp[i] = x;
+            this.log[x] = i;
+            x = this.multiplyNoLut(x, generator);
+        }
+        for (let i = this.size; i < this.size * 2; i++) {
+            this.exp[i] = this.exp[i - this.size];
+        }
+    }
+    multiply(x, y) {
+        if (x === 0 || y === 0)
+            return 0;
+        return this.exp[(this.log[x] + this.log[y]) % this.size];
+    }
+    multiplyPolynom(p, q) {
+        const result = new Array();
+        const logP = new Array();
+        for (let i = 0; i < p.length; i++) {
+            logP[i] = this.log[p[i]];
+        }
+        for (let j = 0; j < q.length; j++) {
+            if (q[j] === 0)
+                continue;
+            const lq = this.log[q[j]];
+            for (let i = 0; i < p.length; i++) {
+                if (p[i] === 0)
+                    continue;
+                result[i + j] ^= this.exp[logP[i] + lq];
+            }
+        }
+        return result;
+    }
+    power(x, power) {
+        return this.exp[(this.log[x] * power) % this.size];
+    }
+    multiplyNoLut(x, y) {
+        let result = 0;
+        while (y > 0) {
+            if ((y & 1) !== 0)
+                result = result ^ x;
+            y = y >> 1;
+            x = x << 1;
+            if (x > this.size) {
+                x = x ^ this.prime;
+            }
+        }
+        return result;
+    }
+}
+export class ReedSolomon {
+    constructor() {
+        this.galoisField = new GaloisField();
+    }
+    computeErrorCorrection(data, ecLength) {
+        const { length } = data;
+        if (length + ecLength > this.galoisField.size)
+            throw new Error("Message is too long");
+        const generator = this.generatePolynom(ecLength);
+        const { length: generatorLength } = generator;
+        const buffer = new ByteArray(length + generatorLength - 1);
+        buffer.set(data, 0);
+        for (let i = 0; i < length; i++) {
+            const coef = buffer[i];
+            if (coef === 0)
+                continue;
+            for (let j = 0; j < generatorLength; j++) {
+                buffer[i + j] ^= this.galoisField.multiply(generator[j], coef);
+            }
+        }
+        return buffer.slice(length);
+    }
+    generatePolynom(ecLength) {
+        let result = [1];
+        for (let i = 0; i < ecLength; i++) {
+            result = this.galoisField.multiplyPolynom(result, [1, this.galoisField.power(2, i)]);
+        }
+        return result;
+    }
+}

package/dist/es/math/Verhoeff.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022-2023 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Verhoeff algorithm to compute a checksum.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Verhoeff_algorithm}
+ */
+export declare class Verhoeff {
+    private readonly multiply;
+    private readonly inverse;
+    private readonly permute;
+    computeChecksum(digits: string): number;
+}
+//# sourceMappingURL=Verhoeff.d.ts.map

package/dist/es/math/Verhoeff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Verhoeff.d.ts","sourceRoot":"","sources":["../../../src/math/Verhoeff.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,qBAAa,QAAQ;IAEjB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAWvB;IACF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAStB;IAEF,eAAe,CAAC,MAAM,EAAE,MAAM;CASjC"}