@project-chip/matter.js 0.0.1 → 0.0.2

package/dist-cjs/schema/BitmapSchema.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitmapSchema = exports.BitFieldEnum = exports.BitField = exports.BitFlag = void 0;
+const Schema_js_1 = require("./Schema.js");
+const BitRange = (type, offset, length) => ({ type, mask: ((1 << length) - 1) << offset, offset });
+const BitFlag = (offset) => BitRange(0 /* BitRangeType.Flag */, offset, 1);
+exports.BitFlag = BitFlag;
+const BitField = (offset, length) => BitRange(1 /* BitRangeType.Number */, offset, length);
+exports.BitField = BitField;
+const BitFieldEnum = (offset, length) => BitRange(2 /* BitRangeType.Enum */, offset, length);
+exports.BitFieldEnum = BitFieldEnum;
+class BitmapSchemaInternal extends Schema_js_1.Schema {
+    constructor(bitSchemas) {
+        super();
+        this.bitSchemas = bitSchemas;
+        // TODO: validate that bitSchemas is coherent
+    }
+    encodeInternal(value) {
+        let result = 0;
+        for (const name in this.bitSchemas) {
+            const { type, offset, mask } = this.bitSchemas[name];
+            switch (type) {
+                case 0 /* BitRangeType.Flag */:
+                    if (value[name])
+                        result |= mask;
+                    break;
+                case 2 /* BitRangeType.Enum */:
+                case 1 /* BitRangeType.Number */:
+                    result |= value[name] << offset;
+            }
+        }
+        return result;
+    }
+    decodeInternal(bitmap) {
+        const result = {};
+        for (const name in this.bitSchemas) {
+            const { type, offset, mask } = this.bitSchemas[name];
+            if (type === 0 /* BitRangeType.Flag */) {
+                result[name] = (bitmap & mask) !== 0;
+            }
+            else {
+                result[name] = (bitmap & mask) >> offset;
+            }
+        }
+        return result;
+    }
+}
+/** Declares a bitmap schema by indicating the bit position and their names. */
+const BitmapSchema = (bitSchemas) => new BitmapSchemaInternal(bitSchemas);
+exports.BitmapSchema = BitmapSchema;

package/dist-cjs/schema/Schema.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+/** Define a schema to encode / decode convert type T to type E. */
+class Schema {
+    /** Encodes the value using the schema. */
+    encode(value) {
+        this.validate(value);
+        return this.encodeInternal(value);
+    }
+    /** Decodes the encoded data using the schema. */
+    decode(encoded) {
+        const result = this.decodeInternal(encoded);
+        this.validate(result);
+        return result;
+    }
+    /** Optional validator that can be used to enforce constraints on the data before encoding / after decoding. */
+    validate(_value) {
+    }
+}
+exports.Schema = Schema;

package/dist-cjs/spec/Specifications.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/tlv/TlvAny.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvAny = exports.AnySchema = void 0;
+const TlvSchema_js_1 = require("./TlvSchema.js");
+class AnySchema extends TlvSchema_js_1.TlvSchema {
+    encodeTlvInternal(writer, tlvStream, tagAssigned) {
+        tlvStream.forEach(({ tag, typeLength, value }) => {
+            if (tagAssigned !== undefined) {
+                // Assign the tag to the 1st TLV element in the stream
+                tag = tagAssigned;
+                tagAssigned = undefined;
+            }
+            switch (typeLength.type) {
+                case 20 /* TlvType.Null */:
+                case 8 /* TlvType.Boolean */:
+                case 22 /* TlvType.Array */:
+                case 21 /* TlvType.Structure */:
+                case 23 /* TlvType.List */:
+                case 24 /* TlvType.EndOfContainer */:
+                    writer.writeTag(typeLength, tagAssigned !== null && tagAssigned !== void 0 ? tagAssigned : tag);
+                    break;
+                case 4 /* TlvType.UnsignedInt */:
+                case 0 /* TlvType.SignedInt */:
+                case 10 /* TlvType.Float */:
+                case 12 /* TlvType.Utf8String */:
+                case 16 /* TlvType.ByteString */:
+                    writer.writeTag(typeLength, tagAssigned !== null && tagAssigned !== void 0 ? tagAssigned : tag);
+                    writer.writePrimitive(typeLength, value);
+                    break;
+            }
+        });
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        return this.decodeTlvValueRec(reader, typeLength, new Array());
+    }
+    decodeTlvValueRec(reader, typeLength, tlvStream, tag) {
+        switch (typeLength.type) {
+            case 20 /* TlvType.Null */:
+            case 8 /* TlvType.Boolean */:
+            case 4 /* TlvType.UnsignedInt */:
+            case 0 /* TlvType.SignedInt */:
+            case 10 /* TlvType.Float */:
+            case 12 /* TlvType.Utf8String */:
+            case 16 /* TlvType.ByteString */:
+                tlvStream.push({ tag, typeLength, value: reader.readPrimitive(typeLength) });
+                break;
+            case 22 /* TlvType.Array */:
+            case 21 /* TlvType.Structure */:
+            case 23 /* TlvType.List */:
+                tlvStream.push({ tag, typeLength });
+                while (true) {
+                    const { tag: elementTag, typeLength: typeLengthElement } = reader.readTagType();
+                    this.decodeTlvValueRec(reader, typeLengthElement, tlvStream, elementTag);
+                    if (typeLengthElement.type === 24 /* TlvType.EndOfContainer */)
+                        break;
+                }
+                break;
+            case 24 /* TlvType.EndOfContainer */:
+                tlvStream.push({ tag, typeLength });
+                break;
+        }
+        return tlvStream;
+    }
+}
+exports.AnySchema = AnySchema;
+exports.TlvAny = new AnySchema();

package/dist-cjs/tlv/TlvArray.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvArray = exports.ArraySchema = void 0;
+const TlvSchema_js_1 = require("./TlvSchema.js");
+/**
+ * Schema to encode an array or string in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.2 and A.11.4
+ */
+class ArraySchema extends TlvSchema_js_1.TlvSchema {
+    constructor(elementSchema, minLength = 0, maxLength = 1024) {
+        super();
+        this.elementSchema = elementSchema;
+        this.minLength = minLength;
+        this.maxLength = maxLength;
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        writer.writeTag({ type: 22 /* TlvType.Array */ }, tag);
+        value.forEach(element => this.elementSchema.encodeTlvInternal(writer, element));
+        writer.writeTag({ type: 24 /* TlvType.EndOfContainer */ });
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type !== 22 /* TlvType.Array */)
+            throw new Error(`Unexpected type ${typeLength.type}.`);
+        const result = new Array();
+        while (true) {
+            const { tag: elementTag, typeLength: elementTypeLength } = reader.readTagType();
+            if (elementTag !== undefined)
+                throw new Error("Array element tags should be anonymous.");
+            if (elementTypeLength.type === 24 /* TlvType.EndOfContainer */)
+                break;
+            result.push(this.elementSchema.decodeTlvInternalValue(reader, elementTypeLength));
+        }
+        this.validate(result);
+        return result;
+    }
+    validate({ length }) {
+        if (length > this.maxLength)
+            throw new Error(`Array is too long: ${length}, max ${this.maxLength}.`);
+        if (length < this.minLength)
+            throw new Error(`Array is too short: ${length}, min ${this.minLength}.`);
+    }
+}
+exports.ArraySchema = ArraySchema;
+/** Array TLV schema. */
+const TlvArray = (elementSchema, { minLength, maxLength, length } = {}) => new ArraySchema(elementSchema, length !== null && length !== void 0 ? length : minLength, length !== null && length !== void 0 ? length : maxLength);
+exports.TlvArray = TlvArray;

package/dist-cjs/tlv/TlvBoolean.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvBoolean = exports.BooleanSchema = void 0;
+const TlvSchema_js_1 = require("./TlvSchema.js");
+/**
+ * Schema to encode a boolean in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.3
+ */
+class BooleanSchema extends TlvSchema_js_1.TlvSchema {
+    encodeTlvInternal(writer, value, tag = {}) {
+        writer.writeTag({ type: 8 /* TlvType.Boolean */, value }, tag);
+    }
+    decodeTlvInternalValue(_reader, typeLength) {
+        if (typeLength.type !== 8 /* TlvType.Boolean */)
+            throw new Error(`Unexpected type ${typeLength.type}.`);
+        return typeLength.value;
+    }
+}
+exports.BooleanSchema = BooleanSchema;
+/** Boolean TLV schema. */
+exports.TlvBoolean = new BooleanSchema();

package/dist-cjs/tlv/TlvCodec.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvCodec = void 0;
+const Number_js_1 = require("../util/Number.js");
+const BitmapSchema_js_1 = require("../schema/BitmapSchema.js");
+/**
+ * Schema of the ControlByte.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.7.2
+ */
+const ControlByteSchema = (0, BitmapSchema_js_1.BitmapSchema)({
+    typeLength: (0, BitmapSchema_js_1.BitField)(0, 5),
+    tagControl: (0, BitmapSchema_js_1.BitFieldEnum)(5, 3),
+});
+/** {@link MatterCoreSpecificationV1_0} § 2.5.2 and § A.8.3 */
+const MATTER_COMMON_PROFILE = 0x00000000;
+class TlvCodec {
+    static getUIntTlvLength(value) {
+        if (value <= Number_js_1.UINT8_MAX) {
+            return 0 /* TlvLength.OneByte */;
+        }
+        else if (value <= Number_js_1.UINT16_MAX) {
+            return 1 /* TlvLength.TwoBytes */;
+        }
+        else if (value <= Number_js_1.UINT32_MAX) {
+            return 2 /* TlvLength.FourBytes */;
+        }
+        else {
+            return 3 /* TlvLength.EightBytes */;
+        }
+    }
+    static getIntTlvLength(value) {
+        if (value > 0) {
+            if (value <= Number_js_1.INT8_MAX) {
+                return 0 /* TlvLength.OneByte */;
+            }
+            else if (value <= Number_js_1.INT16_MAX) {
+                return 1 /* TlvLength.TwoBytes */;
+            }
+            else if (value <= Number_js_1.INT32_MAX) {
+                return 2 /* TlvLength.FourBytes */;
+            }
+            else {
+                return 3 /* TlvLength.EightBytes */;
+            }
+        }
+        else {
+            if (value >= Number_js_1.INT8_MIN) {
+                return 0 /* TlvLength.OneByte */;
+            }
+            else if (value >= Number_js_1.INT16_MIN) {
+                return 1 /* TlvLength.TwoBytes */;
+            }
+            else if (value >= Number_js_1.INT32_MIN) {
+                return 2 /* TlvLength.FourBytes */;
+            }
+            else {
+                return 3 /* TlvLength.EightBytes */;
+            }
+        }
+    }
+    /** @see {@link MatterCoreSpecificationV1_0} § A.7 */
+    static readTagType(reader) {
+        const { tagControl, typeLength } = ControlByteSchema.decode(reader.readUInt8());
+        return { tag: this.readTag(reader, tagControl), typeLength: this.parseTypeLength(typeLength) };
+    }
+    static readTag(reader, tagControl) {
+        switch (tagControl) {
+            case 0 /* TagControl.Anonymous */:
+                return undefined;
+            case 1 /* TagControl.ContextSpecific */:
+                return { id: reader.readUInt8() };
+            case 2 /* TagControl.CommonProfile16 */:
+                return { profile: MATTER_COMMON_PROFILE, id: reader.readUInt16() };
+            case 3 /* TagControl.CommonProfile32 */:
+                return { profile: MATTER_COMMON_PROFILE, id: reader.readUInt32() };
+            case 4 /* TagControl.ImplicitProfile16 */:
+            case 5 /* TagControl.ImplicitProfile32 */:
+                throw new Error(`Unsupported implicit profile ${tagControl}`);
+            case 6 /* TagControl.FullyQualified48 */:
+                return { profile: reader.readUInt32(), id: reader.readUInt16() };
+            case 6 /* TagControl.FullyQualified48 */:
+                return { profile: reader.readUInt32(), id: reader.readUInt32() };
+            default:
+                throw new Error(`Unexpected tagControl ${tagControl}`);
+        }
+    }
+    static parseTypeLength(typeLength) {
+        const length = (typeLength & 0x03);
+        const type = typeLength & 0xFC;
+        switch (type) {
+            case 12 /* TlvType.Utf8String */:
+            case 16 /* TlvType.ByteString */:
+            case 0 /* TlvType.SignedInt */:
+            case 4 /* TlvType.UnsignedInt */:
+                return { type, length };
+            case 8 /* TlvType.Boolean */:
+                switch (length) {
+                    case 0 /* TlvLength.OneByte */: return { type, value: false };
+                    case 1 /* TlvLength.TwoBytes */: return { type, value: true };
+                    case 2 /* TlvLength.FourBytes */: return { type: 10 /* TlvType.Float */, length };
+                    case 3 /* TlvLength.EightBytes */: return { type: 10 /* TlvType.Float */, length };
+                }
+            default:
+                return { type: typeLength };
+        }
+    }
+    static readPrimitive(reader, typeLength) {
+        switch (typeLength.type) {
+            case 0 /* TlvType.SignedInt */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readInt8();
+                    case 1 /* TlvLength.TwoBytes */: return reader.readInt16();
+                    case 2 /* TlvLength.FourBytes */: return reader.readInt32();
+                    case 3 /* TlvLength.EightBytes */: return reader.readInt64();
+                }
+            case 4 /* TlvType.UnsignedInt */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readUInt8();
+                    case 1 /* TlvLength.TwoBytes */: return reader.readUInt16();
+                    case 2 /* TlvLength.FourBytes */: return reader.readUInt32();
+                    case 3 /* TlvLength.EightBytes */: return reader.readUInt64();
+                }
+            case 10 /* TlvType.Float */:
+                switch (typeLength.length) {
+                    case 2 /* TlvLength.FourBytes */: return reader.readFloat();
+                    case 3 /* TlvLength.EightBytes */: return reader.readDouble();
+                }
+            case 12 /* TlvType.Utf8String */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readUtf8String(reader.readUInt8());
+                    case 1 /* TlvLength.TwoBytes */: return reader.readUtf8String(reader.readUInt16());
+                    case 2 /* TlvLength.FourBytes */: return reader.readUtf8String(reader.readUInt32());
+                    case 3 /* TlvLength.EightBytes */: return reader.readUtf8String(Number(reader.readUInt64()));
+                }
+            case 16 /* TlvType.ByteString */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return reader.readByteArray(reader.readUInt8());
+                    case 1 /* TlvLength.TwoBytes */: return reader.readByteArray(reader.readUInt16());
+                    case 2 /* TlvLength.FourBytes */: return reader.readByteArray(reader.readUInt32());
+                    case 3 /* TlvLength.EightBytes */: return reader.readByteArray(Number(reader.readUInt64()));
+                }
+            case 8 /* TlvType.Boolean */:
+                return typeLength.value;
+            case 20 /* TlvType.Null */:
+                return null;
+            default:
+                throw new Error(`Unexpected TLV type ${typeLength.type}`);
+        }
+    }
+    /** @see {@link MatterCoreSpecificationV1_0} § A.7 & A.8 */
+    static writeTag(writer, typeLengthValue, { profile, id } = {}) {
+        let typeLength;
+        switch (typeLengthValue.type) {
+            case 12 /* TlvType.Utf8String */:
+            case 16 /* TlvType.ByteString */:
+            case 0 /* TlvType.SignedInt */:
+            case 4 /* TlvType.UnsignedInt */:
+            case 10 /* TlvType.Float */:
+                typeLength = typeLengthValue.type | typeLengthValue.length;
+                break;
+            case 8 /* TlvType.Boolean */:
+                typeLength = typeLengthValue.type + (typeLengthValue.value ? 1 : 0);
+                break;
+            default:
+                typeLength = typeLengthValue.type;
+        }
+        if (profile === undefined && id === undefined) {
+            writer.writeUInt8(ControlByteSchema.encode({ tagControl: 0 /* TagControl.Anonymous */, typeLength }));
+        }
+        else if (profile === undefined) {
+            if (id === undefined)
+                throw new Error("Invalid TLV tag: id should be defined for a context specific tag.");
+            writer.writeUInt8(ControlByteSchema.encode({ tagControl: 1 /* TagControl.ContextSpecific */, typeLength }));
+            writer.writeUInt8(id);
+        }
+        else if (profile === MATTER_COMMON_PROFILE) {
+            if (id === undefined)
+                throw new Error("Invalid TLV tag: id should be defined for a common profile.");
+            if ((id & 0xFFFF0000) === 0) {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 2 /* TagControl.CommonProfile16 */, typeLength }));
+                writer.writeUInt16(id);
+            }
+            else {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 3 /* TagControl.CommonProfile32 */, typeLength }));
+                writer.writeUInt32(id);
+            }
+        }
+        else {
+            if (id === undefined)
+                throw new Error("Invalid TLV tag: id should be defined for a custom profile.");
+            if ((id & 0xFFFF0000) === 0) {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 6 /* TagControl.FullyQualified48 */, typeLength }));
+                writer.writeUInt32(profile);
+                writer.writeUInt16(id);
+            }
+            else {
+                writer.writeUInt8(ControlByteSchema.encode({ tagControl: 7 /* TagControl.FullyQualified64 */, typeLength }));
+                writer.writeUInt32(profile);
+                writer.writeUInt32(id);
+            }
+        }
+    }
+    static writePrimitive(writer, typeLength, value) {
+        switch (typeLength.type) {
+            case 0 /* TlvType.SignedInt */:
+                return this.writeUInt(writer, typeLength.length, value);
+            case 4 /* TlvType.UnsignedInt */:
+                switch (typeLength.length) {
+                    case 0 /* TlvLength.OneByte */: return writer.writeUInt8(value);
+                    case 1 /* TlvLength.TwoBytes */: return writer.writeUInt16(value);
+                    case 2 /* TlvLength.FourBytes */: return writer.writeUInt32(value);
+                    case 3 /* TlvLength.EightBytes */: return writer.writeUInt64(value);
+                }
+            case 10 /* TlvType.Float */:
+                switch (typeLength.length) {
+                    case 2 /* TlvLength.FourBytes */: return writer.writeFloat(value);
+                    case 3 /* TlvLength.EightBytes */: return writer.writeDouble(value);
+                }
+            case 12 /* TlvType.Utf8String */:
+                const string = value;
+                this.writeUInt(writer, typeLength.length, string.length);
+                return writer.writeUtf8String(string);
+            case 16 /* TlvType.ByteString */:
+                const byteArray = value;
+                this.writeUInt(writer, typeLength.length, byteArray.length);
+                return writer.writeByteArray(byteArray);
+            case 8 /* TlvType.Boolean */:
+                return;
+            default:
+                throw new Error(`Unexpected TLV type ${typeLength.type}`);
+        }
+    }
+    static writeUInt(writer, length, value) {
+        switch (length) {
+            case 0 /* TlvLength.OneByte */: return writer.writeInt8(value);
+            case 1 /* TlvLength.TwoBytes */: return writer.writeInt16(value);
+            case 2 /* TlvLength.FourBytes */: return writer.writeInt32(value);
+            case 3 /* TlvLength.EightBytes */: return writer.writeInt64(value);
+        }
+    }
+}
+exports.TlvCodec = TlvCodec;

package/dist-cjs/tlv/TlvNullable.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvNullable = exports.NullableSchema = void 0;
+const TlvSchema_js_1 = require("./TlvSchema.js");
+/**
+ * Schema to encode a nulable value in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.6
+ */
+class NullableSchema extends TlvSchema_js_1.TlvSchema {
+    constructor(schema) {
+        super();
+        this.schema = schema;
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        if (value === null) {
+            writer.writeTag({ type: 20 /* TlvType.Null */ }, tag);
+        }
+        else {
+            this.schema.encodeTlvInternal(writer, value, tag);
+        }
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type === 20 /* TlvType.Null */)
+            return null;
+        return this.schema.decodeTlvInternalValue(reader, typeLength);
+    }
+}
+exports.NullableSchema = NullableSchema;
+/** Nullable TLV schema. */
+const TlvNullable = (schema) => new NullableSchema(schema);
+exports.TlvNullable = TlvNullable;

package/dist-cjs/tlv/TlvNumber.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvBitmap = exports.TlvEnum = exports.TlvUInt64 = exports.TlvUInt32 = exports.TlvUInt16 = exports.TlvUInt8 = exports.TlvInt64 = exports.TlvInt32 = exports.TlvInt16 = exports.TlvInt8 = exports.TlvDouble = exports.TlvFloat = exports.TlvLongNumberSchema = exports.TlvNumberSchema = exports.TlvNumericSchema = void 0;
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const Number_js_1 = require("../util/Number.js");
+const TlvCodec_js_1 = require("./TlvCodec.js");
+const TlvSchema_js_1 = require("./TlvSchema.js");
+const TlvWrapper_js_1 = require("./TlvWrapper.js");
+const BitmapSchema_js_1 = require("../schema/BitmapSchema.js");
+/**
+ * Schema to encode an unsigned integer in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.1
+ */
+class TlvNumericSchema extends TlvSchema_js_1.TlvSchema {
+    constructor(type, lengthProvider, min, max) {
+        super();
+        this.type = type;
+        this.lengthProvider = lengthProvider;
+        this.min = min;
+        this.max = max;
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        const typeLength = { type: this.type, length: this.lengthProvider(value) };
+        writer.writeTag(typeLength, tag);
+        writer.writePrimitive(typeLength, value);
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type !== this.type)
+            throw new Error(`Unexpected type ${typeLength.type}, was expecting ${this.type}.`);
+        const value = reader.readPrimitive(typeLength);
+        this.validate(value);
+        return value;
+    }
+    validate(value) {
+        super.validate(value);
+        if (this.min !== undefined && value < this.min)
+            throw new Error(`Invalid value: ${value} is below the minimum, ${this.min}.`);
+        if (this.max !== undefined && value > this.max)
+            throw new Error(`Invalid value: ${value} is above the maximum, ${this.max}.`);
+    }
+    /** Restrict value range. */
+    bound({ min, max }) {
+        return new TlvNumericSchema(this.type, this.lengthProvider, (0, Number_js_1.maxValue)(min, this.min), (0, Number_js_1.minValue)(max, this.max));
+    }
+}
+exports.TlvNumericSchema = TlvNumericSchema;
+class TlvNumberSchema extends TlvNumericSchema {
+    constructor(type, lengthProvider, min, max) {
+        super(type, lengthProvider, min, max);
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        const value = super.decodeTlvInternalValue(reader, typeLength);
+        return typeof value === "bigint" ? Number(value) : value;
+    }
+    bound({ min, max }) {
+        return new TlvNumberSchema(this.type, this.lengthProvider, (0, Number_js_1.maxValue)(min, this.min), (0, Number_js_1.minValue)(max, this.max));
+    }
+}
+exports.TlvNumberSchema = TlvNumberSchema;
+exports.TlvLongNumberSchema = (TlvNumericSchema);
+/** Unsigned integer TLV schema. */
+exports.TlvFloat = new TlvNumberSchema(10 /* TlvType.Float */, _value => 2 /* TlvLength.FourBytes */, Number_js_1.FLOAT32_MIN, Number_js_1.FLOAT32_MAX);
+exports.TlvDouble = new TlvNumberSchema(10 /* TlvType.Float */, _value => 3 /* TlvLength.EightBytes */);
+exports.TlvInt8 = new TlvNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec_js_1.TlvCodec.getIntTlvLength(value), Number_js_1.INT8_MIN, Number_js_1.INT8_MAX);
+exports.TlvInt16 = new TlvNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec_js_1.TlvCodec.getIntTlvLength(value), Number_js_1.INT16_MIN, Number_js_1.INT16_MAX);
+exports.TlvInt32 = new TlvNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec_js_1.TlvCodec.getIntTlvLength(value), Number_js_1.INT32_MIN, Number_js_1.INT32_MAX);
+exports.TlvInt64 = new exports.TlvLongNumberSchema(0 /* TlvType.SignedInt */, value => TlvCodec_js_1.TlvCodec.getIntTlvLength(value), Number_js_1.INT64_MIN, Number_js_1.INT64_MAX);
+exports.TlvUInt8 = new TlvNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec_js_1.TlvCodec.getUIntTlvLength(value), 0, Number_js_1.UINT8_MAX);
+exports.TlvUInt16 = new TlvNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec_js_1.TlvCodec.getUIntTlvLength(value), 0, Number_js_1.UINT16_MAX);
+exports.TlvUInt32 = new TlvNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec_js_1.TlvCodec.getUIntTlvLength(value), 0, Number_js_1.UINT32_MAX);
+exports.TlvUInt64 = new exports.TlvLongNumberSchema(4 /* TlvType.UnsignedInt */, value => TlvCodec_js_1.TlvCodec.getUIntTlvLength(value), 0, Number_js_1.UINT64_MAX);
+const TlvEnum = () => exports.TlvUInt32;
+exports.TlvEnum = TlvEnum;
+const TlvBitmap = (underlyingSchema, bitSchema) => {
+    const bitmapSchema = (0, BitmapSchema_js_1.BitmapSchema)(bitSchema);
+    return new TlvWrapper_js_1.TlvWrapper(underlyingSchema, (bitmapData) => bitmapSchema.encode(bitmapData), value => bitmapSchema.decode(value));
+};
+exports.TlvBitmap = TlvBitmap;

package/dist-cjs/tlv/TlvObject.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvOptionalField = exports.TlvField = exports.TlvList = exports.TlvObject = exports.ObjectSchema = void 0;
+const TlvSchema_js_1 = require("./TlvSchema.js");
+;
+/**
+ * Schema to encode an object in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.5.1 and § A.11.4
+ */
+class ObjectSchema extends TlvSchema_js_1.TlvSchema {
+    constructor(fieldDefinitions, type = 21 /* TlvType.Structure */) {
+        super();
+        this.fieldDefinitions = fieldDefinitions;
+        this.type = type;
+        this.fieldById = new Array();
+        for (const name in this.fieldDefinitions) {
+            const field = this.fieldDefinitions[name];
+            this.fieldById[field.id] = { name, field };
+        }
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        writer.writeTag({ type: this.type }, tag);
+        for (const name in this.fieldDefinitions) {
+            const { id, schema, optional: isOptional } = this.fieldDefinitions[name];
+            const fieldValue = value[name];
+            if (fieldValue === undefined) {
+                if (!isOptional)
+                    throw new Error(`Missing mandatory field ${name}`);
+                continue;
+            }
+            schema.encodeTlvInternal(writer, fieldValue, { id });
+        }
+        writer.writeTag({ type: 24 /* TlvType.EndOfContainer */ });
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type !== this.type)
+            throw new Error(`Unexpected type ${typeLength.type}.`);
+        const result = {};
+        while (true) {
+            const { tag: { profile, id } = {}, typeLength: elementTypeLength } = reader.readTagType();
+            if (elementTypeLength.type === 24 /* TlvType.EndOfContainer */)
+                break;
+            if (profile !== undefined)
+                throw new Error("Structure element tags should be context-specific.");
+            if (id === undefined)
+                throw new Error("Structure element tags should have an id.");
+            const fieldName = this.fieldById[id];
+            if (fieldName === undefined)
+                throw new Error(`Unknown field ${id}`);
+            const { field, name } = fieldName;
+            result[name] = field.schema.decodeTlvInternalValue(reader, elementTypeLength);
+        }
+        this.validate(result);
+        return result;
+    }
+    validate(value) {
+        for (const name in this.fieldDefinitions) {
+            if (!this.fieldDefinitions[name].optional && value[name] === undefined)
+                throw new Error(`Missing mandatory field ${name}`);
+        }
+    }
+}
+exports.ObjectSchema = ObjectSchema;
+/** Object TLV schema. */
+const TlvObject = (fields) => new ObjectSchema(fields, 21 /* TlvType.Structure */);
+exports.TlvObject = TlvObject;
+/** List TLV schema. */
+const TlvList = (fields) => new ObjectSchema(fields, 23 /* TlvType.List */);
+exports.TlvList = TlvList;
+/** Object TLV mandatory field. */
+const TlvField = (id, schema) => ({ id, schema, optional: false });
+exports.TlvField = TlvField;
+/** Object TLV optional field. */
+const TlvOptionalField = (id, schema) => ({ id, schema, optional: true });
+exports.TlvOptionalField = TlvOptionalField;

package/dist-cjs/tlv/TlvSchema.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvByteArrayReader = exports.TlvByteArrayWriter = exports.TlvArrayReader = exports.TlvArrayWriter = exports.TlvSchema = void 0;
+const ByteArray_js_1 = require("../util/ByteArray.js");
+const DataReader_js_1 = require("../util/DataReader.js");
+const DataWriter_js_1 = require("../util/DataWriter.js");
+const Schema_js_1 = require("../schema/Schema.js");
+const TlvCodec_js_1 = require("./TlvCodec.js");
+class TlvSchema extends Schema_js_1.Schema {
+    decodeInternal(encoded) {
+        return this.decodeTlvInternal(new TlvByteArrayReader(encoded)).value;
+    }
+    encodeInternal(value) {
+        const writer = new TlvByteArrayWriter();
+        this.encodeTlvInternal(writer, value);
+        return writer.toByteArray();
+    }
+    encodeTlv(value) {
+        const writer = new TlvArrayWriter();
+        this.encodeTlvInternal(writer, value);
+        return writer.toTlvArray();
+    }
+    decodeTlv(encoded) {
+        return this.decodeTlvInternal(new TlvArrayReader(encoded)).value;
+    }
+    decodeTlvInternal(reader) {
+        const { tag, typeLength } = reader.readTagType();
+        return { tag, value: this.decodeTlvInternalValue(reader, typeLength) };
+    }
+}
+exports.TlvSchema = TlvSchema;
+class TlvArrayWriter {
+    constructor() {
+        this.tlvArray = new Array();
+    }
+    writeTag(typeLength, tag) {
+        this.tlvArray.push({ tag, typeLength });
+    }
+    writePrimitive(_typeLength, value) {
+        this.tlvArray[this.tlvArray.length - 1].value = value;
+    }
+    toTlvArray() {
+        return this.tlvArray;
+    }
+}
+exports.TlvArrayWriter = TlvArrayWriter;
+class TlvArrayReader {
+    constructor(tlvElements) {
+        this.tlvElements = tlvElements;
+        this.index = -1;
+    }
+    readTagType() {
+        this.index++;
+        return this.tlvElements[this.index];
+    }
+    readPrimitive(_typeLength) {
+        return this.tlvElements[this.index].value;
+    }
+}
+exports.TlvArrayReader = TlvArrayReader;
+class TlvByteArrayWriter {
+    constructor() {
+        this.writer = new DataWriter_js_1.DataWriter(ByteArray_js_1.Endian.Little);
+    }
+    writeTag(typeLength, tag) {
+        TlvCodec_js_1.TlvCodec.writeTag(this.writer, typeLength, tag);
+    }
+    writePrimitive(typeLength, value) {
+        TlvCodec_js_1.TlvCodec.writePrimitive(this.writer, typeLength, value);
+    }
+    toByteArray() {
+        return this.writer.toByteArray();
+    }
+}
+exports.TlvByteArrayWriter = TlvByteArrayWriter;
+class TlvByteArrayReader {
+    constructor(byteArray) {
+        this.reader = new DataReader_js_1.DataReader(byteArray, ByteArray_js_1.Endian.Little);
+    }
+    readTagType() {
+        return TlvCodec_js_1.TlvCodec.readTagType(this.reader);
+    }
+    readPrimitive(typeLength) {
+        return TlvCodec_js_1.TlvCodec.readPrimitive(this.reader, typeLength);
+    }
+}
+exports.TlvByteArrayReader = TlvByteArrayReader;

package/dist-cjs/tlv/TlvString.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvString256max = exports.TlvString64max = exports.TlvString32max = exports.TlvString = exports.TlvByteString = exports.StringSchema = void 0;
+const TlvCodec_js_1 = require("./TlvCodec.js");
+const TlvSchema_js_1 = require("./TlvSchema.js");
+const Number_js_1 = require("../util/Number.js");
+/**
+ * Schema to encode an byte string or an Utf8 string in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.2
+ */
+class StringSchema extends TlvSchema_js_1.TlvSchema {
+    constructor(type, minLength = 0, maxLength = 1024) {
+        super();
+        this.type = type;
+        this.minLength = minLength;
+        this.maxLength = maxLength;
+        if (minLength < 0)
+            throw new Error("Minimum length should be a positive number.");
+    }
+    encodeTlvInternal(writer, value, tag = {}) {
+        const typeLength = { type: this.type, length: TlvCodec_js_1.TlvCodec.getUIntTlvLength(value.length) };
+        writer.writeTag(typeLength, tag);
+        writer.writePrimitive(typeLength, value);
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        if (typeLength.type !== this.type)
+            throw new Error(`Unexpected type ${typeLength.type}.`);
+        return reader.readPrimitive(typeLength);
+    }
+    validate({ length }) {
+        if (length > this.maxLength)
+            throw new Error(`Array is too long: ${length}, max ${this.maxLength}.`);
+        if (length < this.minLength)
+            throw new Error(`Array is too short: ${length}, min ${this.minLength}.`);
+    }
+    bound({ minLength, maxLength, length }) {
+        return new StringSchema(this.type, length !== null && length !== void 0 ? length : (0, Number_js_1.maxValue)(this.minLength, minLength), length !== null && length !== void 0 ? length : (0, Number_js_1.minValue)(this.maxLength, maxLength));
+    }
+}
+exports.StringSchema = StringSchema;
+/** ByteString TLV schema. */
+exports.TlvByteString = new StringSchema(16 /* TlvType.ByteString */);
+/** String TLV schema. */
+exports.TlvString = new StringSchema(12 /* TlvType.Utf8String */);
+/** String TLV schema. */
+exports.TlvString32max = exports.TlvString.bound({ maxLength: 32 });
+/** String TLV schema. */
+exports.TlvString64max = exports.TlvString.bound({ maxLength: 64 });
+/** String TLV schema. */
+exports.TlvString256max = exports.TlvString.bound({ maxLength: 256 });

package/dist-cjs/tlv/TlvVoid.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvVoid = exports.VoidSchema = void 0;
+const TlvSchema_js_1 = require("./TlvSchema.js");
+/**
+ * Schema to encode void.
+ */
+class VoidSchema extends TlvSchema_js_1.TlvSchema {
+    encodeTlvInternal(_writer, _value, _tag) {
+        // Nothing to do
+    }
+    decodeTlv(_encoded) {
+        // Nothing to do
+    }
+    decodeTlvInternalValue(_reader, _typeLength) {
+        throw new Error("decodeTlvInternalValue should never be called");
+    }
+}
+exports.VoidSchema = VoidSchema;
+/** Void TLV schema. */
+exports.TlvVoid = new VoidSchema();

package/dist-cjs/tlv/TlvWrapper.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TlvWrapper = void 0;
+const TlvSchema_js_1 = require("./TlvSchema.js");
+class TlvWrapper extends TlvSchema_js_1.TlvSchema {
+    constructor(underlyingSchema, wrap, unwrap) {
+        super();
+        this.underlyingSchema = underlyingSchema;
+        this.wrap = wrap;
+        this.unwrap = unwrap;
+    }
+    decodeTlvInternalValue(reader, typeLength) {
+        return this.unwrap(this.underlyingSchema.decodeTlvInternalValue(reader, typeLength));
+    }
+    encodeTlvInternal(writer, value, tag) {
+        this.underlyingSchema.encodeTlvInternal(writer, this.wrap(value), tag);
+    }
+    validate(value) {
+        this.underlyingSchema.validate(this.wrap(value));
+    }
+}
+exports.TlvWrapper = TlvWrapper;

package/dist-cjs/util/ByteArray.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endian = exports.ByteArray = void 0;
+Uint8Array.prototype.toHex = function () {
+    return this.reduce((result, byte) => result + byte.toString(16).padStart(2, "0"), "");
+};
+Uint8Array.prototype.getDataView = function () {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength);
+};
+Uint8Array.prototype.equals = function (other) {
+    if (other.length !== this.length)
+        return false;
+    return this.every((value, index) => other[index] === value);
+};
+Uint8Array.fromHex = function (hexString) {
+    var _a;
+    if (hexString.length % 2 !== 0)
+        throw new Error("Hex string should have an even length.");
+    const bytes = (_a = hexString.match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map(byteHex => parseInt(byteHex, 16));
+    if (bytes === undefined)
+        throw new Error("Failed to parse the hex string.");
+    return exports.ByteArray.from(bytes);
+};
+Uint8Array.fromString = function (string) {
+    return new TextEncoder().encode(string);
+};
+Uint8Array.concat = function (...arrays) {
+    let length = 0;
+    arrays.forEach(array => length += array.length);
+    const result = new Uint8Array(length);
+    let offset = 0;
+    arrays.forEach(array => {
+        result.set(array, offset);
+        offset += array.length;
+    });
+    return result;
+};
+exports.ByteArray = Uint8Array;
+var Endian;
+(function (Endian) {
+    Endian[Endian["Little"] = 0] = "Little";
+    Endian[Endian["Big"] = 1] = "Big";
+})(Endian = exports.Endian || (exports.Endian = {}));

package/dist-cjs/util/DataReader.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataReader = void 0;
+const ByteArray_js_1 = require("./ByteArray.js");
+/** Reader that auto-increments its offset after each read. */
+class DataReader {
+    constructor(buffer, endian) {
+        this.buffer = buffer;
+        this.offset = 0;
+        this.dataView = buffer.getDataView();
+        this.littleEndian = endian === ByteArray_js_1.Endian.Little;
+    }
+    readUInt8() {
+        return this.dataView.getUint8(this.getOffsetAndAdvance(1));
+    }
+    readUInt16() {
+        return this.dataView.getUint16(this.getOffsetAndAdvance(2), this.littleEndian);
+    }
+    readUInt32() {
+        return this.dataView.getUint32(this.getOffsetAndAdvance(4), this.littleEndian);
+    }
+    readUInt64() {
+        return this.dataView.getBigUint64(this.getOffsetAndAdvance(8), this.littleEndian);
+    }
+    readInt8() {
+        return this.dataView.getInt8(this.getOffsetAndAdvance(1));
+    }
+    readInt16() {
+        return this.dataView.getInt16(this.getOffsetAndAdvance(2), this.littleEndian);
+    }
+    readInt32() {
+        return this.dataView.getInt32(this.getOffsetAndAdvance(4), this.littleEndian);
+    }
+    readInt64() {
+        return this.dataView.getBigInt64(this.getOffsetAndAdvance(8), this.littleEndian);
+    }
+    readFloat() {
+        return this.dataView.getFloat32(this.getOffsetAndAdvance(4), this.littleEndian);
+    }
+    readDouble() {
+        return this.dataView.getFloat64(this.getOffsetAndAdvance(8), this.littleEndian);
+    }
+    readUtf8String(length) {
+        const offset = this.getOffsetAndAdvance(length);
+        return new TextDecoder().decode(this.buffer.subarray(offset, offset + length));
+    }
+    readByteArray(length) {
+        const offset = this.getOffsetAndAdvance(length);
+        const result = this.buffer.subarray(offset, offset + length);
+        return result;
+    }
+    getRemainingBytesCount() {
+        return this.dataView.byteLength - this.offset;
+    }
+    getRemainingBytes() {
+        return this.buffer.subarray(this.offset);
+    }
+    getOffsetAndAdvance(size) {
+        const result = this.offset;
+        this.offset += size;
+        return result;
+    }
+}
+exports.DataReader = DataReader;

package/dist-cjs/util/DataWriter.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataWriter = void 0;
+const ByteArray_js_1 = require("./ByteArray.js");
+const Number_js_1 = require("./Number.js");
+/** Writer that auto-increments its offset after each write. */
+// TODO: some research should be done to make sure this is most performant implementation.
+class DataWriter {
+    constructor(endian) {
+        this.length = 0;
+        this.chunks = new Array();
+        this.littleEndian = endian === ByteArray_js_1.Endian.Little;
+    }
+    writeUInt8(value) {
+        this.chunks.push(new ByteArray_js_1.ByteArray([(0, Number_js_1.toNumber)(value)]));
+        this.length += 1;
+    }
+    writeUInt16(value) {
+        const chunk = new ByteArray_js_1.ByteArray(2);
+        new DataView(chunk.buffer, 0, 2).setUint16(0, (0, Number_js_1.toNumber)(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 2;
+    }
+    writeUInt32(value) {
+        const chunk = new ByteArray_js_1.ByteArray(4);
+        new DataView(chunk.buffer, 0, 4).setUint32(0, (0, Number_js_1.toNumber)(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 4;
+    }
+    writeUInt64(value) {
+        const chunk = new ByteArray_js_1.ByteArray(8);
+        new DataView(chunk.buffer, 0, 8).setBigUint64(0, (0, Number_js_1.toBigInt)(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 8;
+    }
+    writeInt8(value) {
+        const chunk = new ByteArray_js_1.ByteArray(1);
+        new DataView(chunk.buffer, 0, 1).setInt8(0, (0, Number_js_1.toNumber)(value));
+        this.chunks.push(chunk);
+        this.length += 1;
+    }
+    writeInt16(value) {
+        const chunk = new ByteArray_js_1.ByteArray(2);
+        new DataView(chunk.buffer, 0, 2).setInt16(0, (0, Number_js_1.toNumber)(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 2;
+    }
+    writeInt32(value) {
+        const chunk = new ByteArray_js_1.ByteArray(4);
+        new DataView(chunk.buffer, 0, 4).setInt32(0, (0, Number_js_1.toNumber)(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 4;
+    }
+    writeInt64(value) {
+        const chunk = new ByteArray_js_1.ByteArray(8);
+        new DataView(chunk.buffer, 0, 8).setBigInt64(0, (0, Number_js_1.toBigInt)(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 8;
+    }
+    writeFloat(value) {
+        const chunk = new ByteArray_js_1.ByteArray(4);
+        new DataView(chunk.buffer, 0, 4).setFloat32(0, value, this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 4;
+    }
+    writeDouble(value) {
+        const chunk = new ByteArray_js_1.ByteArray(8);
+        new DataView(chunk.buffer, 0, 8).setFloat64(0, value, this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 8;
+    }
+    writeUtf8String(value) {
+        const bytes = ByteArray_js_1.ByteArray.fromString(value);
+        this.chunks.push(bytes);
+        this.length += bytes.byteLength;
+    }
+    writeByteArray(value) {
+        this.chunks.push(value);
+        this.length += value.byteLength;
+    }
+    toByteArray() {
+        if (this.chunks.length === 0)
+            return new ByteArray_js_1.ByteArray(0);
+        if (this.chunks.length === 1)
+            return this.chunks[0];
+        const result = new ByteArray_js_1.ByteArray(this.length);
+        let offset = 0;
+        this.chunks.forEach(chunck => {
+            result.set(chunck, offset);
+            offset += chunck.byteLength;
+        });
+        this.chunks.length = 0;
+        this.chunks.push(result);
+        return result;
+    }
+}
+exports.DataWriter = DataWriter;

package/dist-cjs/util/Number.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxValue = exports.minValue = exports.toBigInt = exports.toNumber = exports.FLOAT32_MAX = exports.FLOAT32_MIN = exports.INT64_MAX = exports.INT32_MAX = exports.INT16_MAX = exports.INT8_MAX = exports.INT64_MIN = exports.INT32_MIN = exports.INT16_MIN = exports.INT8_MIN = exports.UINT64_MAX = exports.UINT32_MAX = exports.UINT16_MAX = exports.UINT8_MAX = void 0;
+exports.UINT8_MAX = 0xFF;
+exports.UINT16_MAX = 0xFFFF;
+exports.UINT32_MAX = 0xFFFFFFFF;
+exports.UINT64_MAX = BigInt("18446744073709551615");
+exports.INT8_MIN = -128;
+exports.INT16_MIN = -32768;
+exports.INT32_MIN = -2147483648;
+exports.INT64_MIN = BigInt("-9223372036854775808");
+exports.INT8_MAX = 127;
+exports.INT16_MAX = 32767;
+exports.INT32_MAX = 2147483647;
+exports.INT64_MAX = BigInt("9223372036854775807");
+exports.FLOAT32_MIN = -340282346638528859811704183484516925440.0;
+exports.FLOAT32_MAX = 340282346638528859811704183484516925440.0;
+function toNumber(value) {
+    return typeof value === "bigint" ? Number(value) : value;
+}
+exports.toNumber = toNumber;
+function toBigInt(value) {
+    return typeof value === "number" ? BigInt(value) : value;
+}
+exports.toBigInt = toBigInt;
+function minValue(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return a < b ? a : b;
+}
+exports.minValue = minValue;
+function maxValue(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return a > b ? a : b;
+}
+exports.maxValue = maxValue;

package/dist-cjs/util/Type.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@project-chip/matter.js",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Matter protocol in pure js",
   "keywords": [
     "iot",
@@ -40,7 +40,8 @@
     "typescript": "^4.9.3"
   },
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "dist-cjs/**/*"
   ],
   "main": "dist-cjs/matter.js",
   "module": "dist/matter.js",