@project-chip/matter.js 0.0.1 → 0.1.0

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,85 @@
+"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");
+const TlvAny_js_1 = require("./TlvAny.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) {
+                // Ignore unknown field by decoding it as raw TLV so we skip forward the proper length.
+                TlvAny_js_1.TlvAny.decodeTlvInternalValue(reader, elementTypeLength);
+                continue;
+            }
+            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,50 @@
+"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 === 0)
+        return new exports.ByteArray(0);
+    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,10 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Merge = void 0;
+const Merge = (a, b) => (Object.assign(Object.assign({}, a), b));
+exports.Merge = Merge;