@project-chip/matter.js 0.0.0 → 0.0.2

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.0",
+  "version": "0.0.2",
   "description": "Matter protocol in pure js",
   "keywords": [
     "iot",
@@ -23,21 +23,27 @@
     "url": "https://github.com/project-chip/matter.js.git"
   },
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "npm run clean; tsc",
-    "test": "TZ=utc mocha"
+    "clean": "rm -rf dist; rm -rf dist-cjs",
+    "build": "npm run clean; tsc --project tsconfig.dist.json; tsc --project tsconfig.dist-cjs.json",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test-web": "karma start karma.conf.cjs"
   },
   "devDependencies": {
-    "@types/assert": "^1.5.6",
-    "@types/mocha": "^9.1.1",
-    "assert": "^2.0.0",
-    "mocha": "^10.0.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.5.5"
+    "@types/jasmine": "^4.3.0",
+    "jest": "^29.3.1",
+    "karma": "^6.4.1",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-coverage": "^2.2.0",
+    "karma-jasmine": "^5.1.0",
+    "karma-typescript": "^5.5.3",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.9.3"
   },
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "dist-cjs/**/*"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts"
+  "main": "dist-cjs/matter.js",
+  "module": "dist/matter.js",
+  "types": "dist/matter.d.ts"
 }

package/dist/index.js

@@ -1 +0,0 @@
-"use strict";