@project-chip/matter.js 0.0.0 → 0.0.2

package/dist/tlv/TlvSchema.js

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Endian } from "../util/ByteArray.js";
+import { DataReader } from "../util/DataReader.js";
+import { DataWriter } from "../util/DataWriter.js";
+import { Schema } from "../schema/Schema.js";
+import { TlvCodec } from "./TlvCodec.js";
+export class TlvSchema extends 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) };
+    }
+}
+export 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;
+    }
+}
+export 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;
+    }
+}
+export class TlvByteArrayWriter {
+    constructor() {
+        this.writer = new DataWriter(Endian.Little);
+    }
+    writeTag(typeLength, tag) {
+        TlvCodec.writeTag(this.writer, typeLength, tag);
+    }
+    writePrimitive(typeLength, value) {
+        TlvCodec.writePrimitive(this.writer, typeLength, value);
+    }
+    toByteArray() {
+        return this.writer.toByteArray();
+    }
+}
+export class TlvByteArrayReader {
+    constructor(byteArray) {
+        this.reader = new DataReader(byteArray, Endian.Little);
+    }
+    readTagType() {
+        return TlvCodec.readTagType(this.reader);
+    }
+    readPrimitive(typeLength) {
+        return TlvCodec.readPrimitive(this.reader, typeLength);
+    }
+}

package/dist/tlv/TlvString.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvType, TlvTag, TlvTypeLength, TlvToPrimitive } from "./TlvCodec.js";
+import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+type LengthConstraints = {
+    minLength?: number;
+    maxLength?: number;
+    length?: number;
+};
+/**
+ * Schema to encode an byte string or an Utf8 string in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.2
+ */
+export declare class StringSchema<T extends TlvType.ByteString | TlvType.Utf8String> extends TlvSchema<TlvToPrimitive[T]> {
+    private type;
+    private readonly minLength;
+    private readonly maxLength;
+    constructor(type: T, minLength?: number, maxLength?: number);
+    encodeTlvInternal(writer: TlvWriter, value: TlvToPrimitive[T], tag?: TlvTag): void;
+    decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): TlvToPrimitive[T];
+    validate({ length }: TlvToPrimitive[T]): void;
+    bound({ minLength, maxLength, length }: LengthConstraints): StringSchema<T>;
+}
+/** ByteString TLV schema. */
+export declare const TlvByteString: StringSchema<TlvType.ByteString>;
+/** String TLV schema. */
+export declare const TlvString: StringSchema<TlvType.Utf8String>;
+/** String TLV schema. */
+export declare const TlvString32max: StringSchema<TlvType.Utf8String>;
+/** String TLV schema. */
+export declare const TlvString64max: StringSchema<TlvType.Utf8String>;
+/** String TLV schema. */
+export declare const TlvString256max: StringSchema<TlvType.Utf8String>;
+export {};

package/dist/tlv/TlvString.js

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvCodec } from "./TlvCodec.js";
+import { TlvSchema } from "./TlvSchema.js";
+import { maxValue, minValue } from "../util/Number.js";
+/**
+ * Schema to encode an byte string or an Utf8 string in TLV.
+ *
+ * @see {@link MatterCoreSpecificationV1_0} § A.11.2
+ */
+export class StringSchema extends 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.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 : maxValue(this.minLength, minLength), length !== null && length !== void 0 ? length : minValue(this.maxLength, maxLength));
+    }
+}
+/** ByteString TLV schema. */
+export const TlvByteString = new StringSchema(16 /* TlvType.ByteString */);
+/** String TLV schema. */
+export const TlvString = new StringSchema(12 /* TlvType.Utf8String */);
+/** String TLV schema. */
+export const TlvString32max = TlvString.bound({ maxLength: 32 });
+/** String TLV schema. */
+export const TlvString64max = TlvString.bound({ maxLength: 64 });
+/** String TLV schema. */
+export const TlvString256max = TlvString.bound({ maxLength: 256 });

package/dist/tlv/TlvVoid.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvTag, TlvTypeLength } from "./TlvCodec.js";
+import { TlvReader, TlvSchema, TlvStream, TlvWriter } from "./TlvSchema.js";
+/**
+ * Schema to encode void.
+ */
+export declare class VoidSchema extends TlvSchema<void> {
+    encodeTlvInternal(_writer: TlvWriter, _value: void, _tag?: TlvTag): void;
+    decodeTlv(_encoded: TlvStream): void;
+    decodeTlvInternalValue(_reader: TlvReader, _typeLength: TlvTypeLength): void;
+}
+/** Void TLV schema. */
+export declare const TlvVoid: VoidSchema;

package/dist/tlv/TlvVoid.js

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

package/dist/tlv/TlvWrapper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvTag, TlvTypeLength } from "./TlvCodec.js";
+import { TlvReader, TlvSchema, TlvWriter } from "./TlvSchema.js";
+export declare class TlvWrapper<O, T> extends TlvSchema<O> {
+    private readonly underlyingSchema;
+    private readonly wrap;
+    private readonly unwrap;
+    constructor(underlyingSchema: TlvSchema<T>, wrap: (object: O) => T, unwrap: (value: T) => O);
+    decodeTlvInternalValue(reader: TlvReader, typeLength: TlvTypeLength): O;
+    encodeTlvInternal(writer: TlvWriter, value: O, tag?: TlvTag | undefined): void;
+    validate(value: O): void;
+}

package/dist/tlv/TlvWrapper.js

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TlvSchema } from "./TlvSchema.js";
+export class TlvWrapper extends 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));
+    }
+}

package/dist/util/ByteArray.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+declare global {
+    interface Uint8Array {
+        /** Displays as an hex string. */
+        toHex(): string;
+        /** Gets a {@link DataView} on this array. */
+        getDataView(): DataView;
+        /** Tests the deep equality of the two arrays. */
+        equals(other: Uint8Array): boolean;
+    }
+    interface Uint8ArrayConstructor {
+        /** Gets an {@link ByteArray} from an hex string. */
+        fromHex(hexString: string): ByteArray;
+        /** Gets an {@link ByteArray} from an hex string. */
+        fromString(string: string): ByteArray;
+        /** Concats {@link ByteArray}s. */
+        concat(...arrays: Uint8Array[]): Uint8Array;
+    }
+}
+/** Array of bytes, alias of {@link Uint8Array}. */
+export type ByteArray = Uint8Array;
+export declare const ByteArray: Uint8ArrayConstructor;
+export declare enum Endian {
+    Little = 0,
+    Big = 1
+}

package/dist/util/ByteArray.js

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.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 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;
+};
+export const ByteArray = Uint8Array;
+export var Endian;
+(function (Endian) {
+    Endian[Endian["Little"] = 0] = "Little";
+    Endian[Endian["Big"] = 1] = "Big";
+})(Endian || (Endian = {}));

package/dist/util/DataReader.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray, Endian } from "./ByteArray.js";
+/** Reader that auto-increments its offset after each read. */
+export declare class DataReader<E extends Endian> {
+    private readonly buffer;
+    private readonly littleEndian;
+    private readonly dataView;
+    private offset;
+    constructor(buffer: ByteArray, endian: E);
+    readUInt8(): number;
+    readUInt16(): number;
+    readUInt32(): number;
+    readUInt64(): bigint;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt64(): bigint;
+    readFloat(): number;
+    readDouble(): number;
+    readUtf8String(length: number): string;
+    readByteArray(length: number): Uint8Array;
+    getRemainingBytesCount(): number;
+    getRemainingBytes(): Uint8Array;
+    private getOffsetAndAdvance;
+}

package/dist/util/DataReader.js

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Endian } from "./ByteArray.js";
+/** Reader that auto-increments its offset after each read. */
+export class DataReader {
+    constructor(buffer, endian) {
+        this.buffer = buffer;
+        this.offset = 0;
+        this.dataView = buffer.getDataView();
+        this.littleEndian = endian === 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;
+    }
+}

package/dist/util/DataWriter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray, Endian } from "./ByteArray.js";
+/** Writer that auto-increments its offset after each write. */
+export declare class DataWriter<E extends Endian> {
+    private readonly littleEndian;
+    private length;
+    private readonly chunks;
+    constructor(endian: E);
+    writeUInt8(value: number | bigint): void;
+    writeUInt16(value: number | bigint): void;
+    writeUInt32(value: number | bigint): void;
+    writeUInt64(value: number | bigint): void;
+    writeInt8(value: number | bigint): void;
+    writeInt16(value: number | bigint): void;
+    writeInt32(value: number | bigint): void;
+    writeInt64(value: number | bigint): void;
+    writeFloat(value: number): void;
+    writeDouble(value: number): void;
+    writeUtf8String(value: string): void;
+    writeByteArray(value: ByteArray): void;
+    toByteArray(): Uint8Array;
+}

package/dist/util/DataWriter.js

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ByteArray, Endian } from "./ByteArray.js";
+import { toBigInt, toNumber } from "./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.
+export class DataWriter {
+    constructor(endian) {
+        this.length = 0;
+        this.chunks = new Array();
+        this.littleEndian = endian === Endian.Little;
+    }
+    writeUInt8(value) {
+        this.chunks.push(new ByteArray([toNumber(value)]));
+        this.length += 1;
+    }
+    writeUInt16(value) {
+        const chunk = new ByteArray(2);
+        new DataView(chunk.buffer, 0, 2).setUint16(0, toNumber(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 2;
+    }
+    writeUInt32(value) {
+        const chunk = new ByteArray(4);
+        new DataView(chunk.buffer, 0, 4).setUint32(0, toNumber(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 4;
+    }
+    writeUInt64(value) {
+        const chunk = new ByteArray(8);
+        new DataView(chunk.buffer, 0, 8).setBigUint64(0, toBigInt(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 8;
+    }
+    writeInt8(value) {
+        const chunk = new ByteArray(1);
+        new DataView(chunk.buffer, 0, 1).setInt8(0, toNumber(value));
+        this.chunks.push(chunk);
+        this.length += 1;
+    }
+    writeInt16(value) {
+        const chunk = new ByteArray(2);
+        new DataView(chunk.buffer, 0, 2).setInt16(0, toNumber(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 2;
+    }
+    writeInt32(value) {
+        const chunk = new ByteArray(4);
+        new DataView(chunk.buffer, 0, 4).setInt32(0, toNumber(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 4;
+    }
+    writeInt64(value) {
+        const chunk = new ByteArray(8);
+        new DataView(chunk.buffer, 0, 8).setBigInt64(0, toBigInt(value), this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 8;
+    }
+    writeFloat(value) {
+        const chunk = new 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(8);
+        new DataView(chunk.buffer, 0, 8).setFloat64(0, value, this.littleEndian);
+        this.chunks.push(chunk);
+        this.length += 8;
+    }
+    writeUtf8String(value) {
+        const bytes = 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(0);
+        if (this.chunks.length === 1)
+            return this.chunks[0];
+        const result = new 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;
+    }
+}

package/dist/util/Number.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const UINT8_MAX = 255;
+export declare const UINT16_MAX = 65535;
+export declare const UINT32_MAX = 4294967295;
+export declare const UINT64_MAX: bigint;
+export declare const INT8_MIN = -128;
+export declare const INT16_MIN = -32768;
+export declare const INT32_MIN = -2147483648;
+export declare const INT64_MIN: bigint;
+export declare const INT8_MAX = 127;
+export declare const INT16_MAX = 32767;
+export declare const INT32_MAX = 2147483647;
+export declare const INT64_MAX: bigint;
+export declare const FLOAT32_MIN = -3.4028234663852886e+38;
+export declare const FLOAT32_MAX = 3.4028234663852886e+38;
+export declare function toNumber(value: bigint | number): number;
+export declare function toBigInt(value: bigint | number): bigint;
+export declare function minValue<T extends bigint | number>(a: T | undefined, b: T | undefined): T | undefined;
+export declare function maxValue<T extends bigint | number>(a: T | undefined, b: T | undefined): T | undefined;

package/dist/util/Number.js

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

package/dist/util/Type.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** Merges two types into one. */
+export type Merge<A, B> = A & B extends infer AB ? {
+    [K in keyof AB]: AB[K];
+} : never;

package/dist/util/Type.js

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist-cjs/matter.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2022 Project CHIP Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schema/BitmapSchema.js"), exports);
+__exportStar(require("./schema/Schema.js"), exports);
+__exportStar(require("./spec/Specifications.js"), exports);
+__exportStar(require("./util/Number.js"), exports);
+__exportStar(require("./util/ByteArray.js"), exports);
+__exportStar(require("./util/DataReader.js"), exports);
+__exportStar(require("./util/DataWriter.js"), exports);
+__exportStar(require("./tlv/TlvAny.js"), exports);
+__exportStar(require("./tlv/TlvArray.js"), exports);
+__exportStar(require("./tlv/TlvBoolean.js"), exports);
+__exportStar(require("./tlv/TlvSchema.js"), exports);
+__exportStar(require("./tlv/TlvNullable.js"), exports);
+__exportStar(require("./tlv/TlvObject.js"), exports);
+__exportStar(require("./tlv/TlvString.js"), exports);
+__exportStar(require("./tlv/TlvNumber.js"), exports);
+__exportStar(require("./tlv/TlvVoid.js"), exports);
+__exportStar(require("./tlv/TlvWrapper.js"), exports);