@matter/general 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/esm/util/Construction.js

@@ -0,0 +1,397 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Logger } from "../log/Logger.js";
+import { ImplementationError } from "../MatterError.js";
+import { errorOf } from "./Error.js";
+import { CrashedDependenciesError, CrashedDependencyError, Lifecycle } from "./Lifecycle.js";
+import { Observable } from "./Observable.js";
+import { MaybePromise } from "./Promises.js";
+async function asyncNew(constructor, ...args) {
+  const subject = new constructor(...args);
+  if (subject.construction.status === Lifecycle.Status.Inactive) {
+    throw new ImplementationError(
+      `You cannot use asyncNew on ${constructor.name} because its construction is controlled by another component`
+    );
+  }
+  await subject.construction.ready;
+  return subject;
+}
+function Construction(subject, initializer) {
+  if (!initializer) {
+    assertDeferred(subject);
+  }
+  let initializerPromise;
+  let awaiterPromise;
+  let awaiterResolve;
+  let awaiterReject;
+  let closedPromise;
+  let closedResolve;
+  let closedReject;
+  let error;
+  let primaryCauseHandled = false;
+  let status = Lifecycle.Status.Inactive;
+  let change;
+  const self = {
+    [Symbol.toStringTag]: "AsyncConstruction",
+    get error() {
+      return error;
+    },
+    get status() {
+      return status;
+    },
+    get change() {
+      if (change === void 0) {
+        change = Observable();
+      }
+      return change;
+    },
+    get isErrorHandled() {
+      return primaryCauseHandled;
+    },
+    start(...args) {
+      if (status !== Lifecycle.Status.Inactive) {
+        throw new ImplementationError(`Cannot initialize ${subject} because it is already active`);
+      }
+      assertDeferred(subject);
+      status = Lifecycle.Status.Initializing;
+      try {
+        const initializeDeferred = () => subject[Construction.construct](...args);
+        invokeInitializer(initializeDeferred);
+      } catch (e) {
+        rejected(e);
+        return;
+      }
+    },
+    assert(description, dependency) {
+      Lifecycle.assertActive(status, description ?? subject.constructor.name);
+      if (arguments.length < 2) {
+        return;
+      }
+      try {
+        if (dependency === void 0) {
+          throw new ImplementationError(`Property is undefined`);
+        }
+      } catch (e) {
+        let error2;
+        if (e instanceof Error) {
+          error2 = e;
+        } else {
+          error2 = new ImplementationError(e?.toString() ?? "(unknown error)");
+        }
+        error2.message = `Cannot access ${description}: ${error2.message}`;
+        throw error2;
+      }
+      return dependency;
+    },
+    then(onfulfilled, onrejected) {
+      const handleRejection = onrejected ? () => onrejected?.(crashedError()) : void 0;
+      if (status === Lifecycle.Status.Inactive || status === Lifecycle.Status.Initializing) {
+        if (!awaiterPromise) {
+          awaiterPromise = new Promise((resolve, reject) => {
+            awaiterResolve = resolve;
+            awaiterReject = reject;
+          });
+        }
+        return awaiterPromise.then(onfulfilled, handleRejection);
+      }
+      const promise = error ? Promise.reject(crashedError()) : Promise.resolve(subject);
+      return promise.then(onfulfilled, handleRejection);
+    },
+    catch(onrejected) {
+      return this.then(void 0, onrejected);
+    },
+    onSuccess(actor) {
+      const onSuccess = () => {
+        const errorHandler = createErrorHandler("onSuccess");
+        try {
+          const result = actor();
+          if (MaybePromise.is(result)) {
+            return Promise.resolve(result).catch(errorHandler);
+          }
+        } catch (e) {
+          errorHandler(e);
+        }
+      };
+      this.then(onSuccess).catch((e) => {
+        CrashedDependencyError.accept(e);
+      });
+    },
+    onError(actor) {
+      const onError = (error2) => {
+        const errorHandler = createErrorHandler("onError");
+        try {
+          const result = actor(errorOf(error2));
+          if (MaybePromise.is(result)) {
+            return result.then(void 0, errorHandler);
+          }
+        } catch (e) {
+          errorHandler(e);
+        }
+      };
+      this.ready.catch(onError);
+    },
+    onCompletion(actor) {
+      const onCompletion = () => {
+        const errorHandler = createErrorHandler("onCompletion");
+        try {
+          actor();
+        } catch (e) {
+          errorHandler(e);
+        }
+      };
+      this.then(onCompletion, onCompletion);
+    },
+    close(destructor) {
+      const destructorError = createErrorHandler("destructor");
+      function destroyed() {
+        setStatus(Lifecycle.Status.Destroyed);
+        if (closedResolve) {
+          closedResolve();
+          closedResolve = closedReject = void 0;
+        }
+      }
+      const destruct = subject[Construction.destruct];
+      const invokeDestruct = destruct ? function invokeDestruct2() {
+        try {
+          const promise = destruct.bind(subject)();
+          if (promise) {
+            return promise.then(void 0, destructorError).then(destroyed);
+          }
+        } catch (e) {
+          destructorError(e);
+        }
+        destroyed();
+      } : destroyed;
+      const invokeDestructor = destructor ? function invokeDestructor2() {
+        try {
+          const promise = destructor();
+          if (promise) {
+            return promise.then(void 0, destructorError).then(invokeDestruct);
+          }
+        } catch (e) {
+          destructorError(e);
+        }
+        invokeDestruct();
+      } : invokeDestruct;
+      function beginDestruction() {
+        if (status === Lifecycle.Status.Destroying || status === Lifecycle.Status.Destroyed) {
+          return self.closed;
+        }
+        setStatus(Lifecycle.Status.Destroying);
+        return invokeDestructor();
+      }
+      if (status === Lifecycle.Status.Initializing) {
+        return this.then(beginDestruction, beginDestruction);
+      }
+      return beginDestruction();
+    },
+    finally(onfinally) {
+      return Promise.prototype.finally.call(this, onfinally);
+    },
+    setStatus(newStatus) {
+      if (this.status === newStatus) {
+        return;
+      }
+      switch (status) {
+        case newStatus:
+          return;
+        case Lifecycle.Status.Destroying:
+          if (newStatus !== Lifecycle.Status.Destroyed) {
+            throw new ImplementationError("Cannog change status because destruction is ongoing");
+          }
+          break;
+        case Lifecycle.Status.Destroyed:
+          throw new ImplementationError("Cannot change status because destruction is final");
+        case Lifecycle.Status.Initializing:
+          throw new ImplementationError("Cannot change status because initialization is ongoing");
+      }
+      switch (newStatus) {
+        case Lifecycle.Status.Inactive:
+          awaiterPromise = closedPromise = void 0;
+          primaryCauseHandled = false;
+          error = void 0;
+          break;
+        case Lifecycle.Status.Active:
+          awaiterPromise = closedPromise = void 0;
+          error = void 0;
+          break;
+        default:
+          break;
+      }
+      setStatus(newStatus);
+    },
+    crash(newError) {
+      error = newError;
+      setStatus(Lifecycle.Status.Crashed);
+    },
+    get ready() {
+      return {
+        [Symbol.toStringTag]: "AsyncConstruction#primary",
+        then(onfulfilled, onrejected) {
+          let rejectionHandler;
+          if (onrejected) {
+            primaryCauseHandled = true;
+            rejectionHandler = () => onrejected(errorOf(error));
+          }
+          return self.then(onfulfilled, rejectionHandler);
+        },
+        catch(onrejected) {
+          return this.then(void 0, onrejected);
+        },
+        finally(onfinally) {
+          return Promise.prototype.finally.call(this, onfinally);
+        }
+      };
+    },
+    get closed() {
+      if (closedPromise === void 0) {
+        closedPromise = new Promise((resolve, reject) => {
+          closedResolve = resolve;
+          closedReject = reject;
+        });
+      }
+      return {
+        [Symbol.toStringTag]: "AsyncConstruction#primary",
+        then(onfulfilled, onrejected) {
+          let rejectionHandler;
+          if (onrejected) {
+            primaryCauseHandled = true;
+            rejectionHandler = () => onrejected(errorOf(error));
+          }
+          return closedPromise.then(onfulfilled, rejectionHandler);
+        },
+        catch(onrejected) {
+          return this.then(void 0, onrejected);
+        },
+        finally(onfinally) {
+          return Promise.prototype.finally.call(this, onfinally);
+        }
+      };
+    }
+  };
+  if (initializer) {
+    invokeInitializer(initializer);
+  }
+  return self;
+  function invokeInitializer(initializer2) {
+    status = Lifecycle.Status.Initializing;
+    initializerPromise = initializer2();
+    if (MaybePromise.is(initializerPromise)) {
+      initializerPromise.then(resolved, rejected);
+    } else {
+      resolved();
+    }
+  }
+  function crashedError() {
+    if (!primaryCauseHandled && error) {
+      primaryCauseHandled = true;
+      return error;
+    }
+    let what;
+    if (subject.toString === Object.prototype.toString) {
+      what = subject.constructor.name;
+    } else {
+      what = subject.toString();
+    }
+    const crashError = new CrashedDependencyError(what, "unavailable due to initialization error");
+    crashError.subject = subject;
+    return crashError;
+  }
+  function setStatus(newStatus) {
+    if (status === newStatus) {
+      return;
+    }
+    status = newStatus;
+    if (change) {
+      change.emit(status, subject);
+    }
+  }
+  function resolved() {
+    if (status === Lifecycle.Status.Initializing) {
+      setStatus(Lifecycle.Status.Active);
+    }
+    if (awaiterResolve) {
+      const resolve = awaiterResolve;
+      awaiterResolve = awaiterReject = void 0;
+      resolve(subject);
+    }
+  }
+  function rejected(cause) {
+    if (status !== Lifecycle.Status.Destroying && status !== Lifecycle.Status.Destroyed) {
+      error = cause;
+      setStatus(Lifecycle.Status.Crashed);
+    }
+    if (awaiterReject) {
+      const reject = awaiterReject;
+      awaiterResolve = awaiterReject = void 0;
+      reject(crashedError());
+    }
+    if (closedReject) {
+      primaryCauseHandled = true;
+      const reject = closedReject;
+      closedResolve = closedReject = void 0;
+      reject(cause);
+    }
+    if (!primaryCauseHandled) {
+      unhandledError(cause);
+    }
+  }
+  function unhandledError(...args) {
+    const logger = Logger.get(subject.constructor.name);
+    logger.error(...args);
+  }
+  function createErrorHandler(name) {
+    return (e) => {
+      unhandledError(`Unhandled error in ${self} ${name}:`, e);
+    };
+  }
+}
+((Construction2) => {
+  function all(subjects, onError) {
+    if (onError === void 0) {
+      onError = (errors) => new CrashedDependenciesError(errors);
+    }
+    const subjectArray = [...subjects];
+    const uninitialized = subjectArray.filter(
+      (subject) => subject.construction.status === Lifecycle.Status.Initializing
+    );
+    if (uninitialized.length) {
+      return Promise.allSettled(uninitialized.map((backing) => backing.construction)).then(
+        () => (
+          // Recurse to ensure subjects added subsequent to initial "all" settle
+          all(subjects, onError)
+        )
+      );
+    }
+    const crashed = Object.values(subjectArray).filter(
+      (backing) => backing.construction.status === Lifecycle.Status.Crashed
+    );
+    if (crashed.length) {
+      let error;
+      try {
+        error = onError(crashed);
+      } catch (e) {
+        error = e;
+      }
+      if (error) {
+        return Promise.reject(error);
+      }
+    }
+  }
+  Construction2.all = all;
+  Construction2.construct = Symbol("construct");
+  Construction2.destruct = Symbol("destruct");
+})(Construction || (Construction = {}));
+function assertDeferred(subject) {
+  if (typeof subject?.[Construction.construct] !== "function") {
+    throw new ImplementationError(`No initializer defined for ${subject}`);
+  }
+}
+export {
+  Construction,
+  asyncNew
+};
+//# sourceMappingURL=Construction.js.map

package/dist/esm/util/Construction.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/util/Construction.ts"],
+  "mappings": "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",
+  "names": ["error", "invokeDestruct", "invokeDestructor", "initializer", "Construction"]
+}

package/dist/esm/util/DataReadQueue.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Promise-based blocking queue.
+ *
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Stream } from "./Stream.js";
+export declare class DataReadQueue<T> implements Stream<T> {
+    private readonly queue;
+    private pendingRead?;
+    private closed;
+    read(timeoutMs?: number): Promise<T>;
+    write(data: T): Promise<void>;
+    close(): void;
+}
+//# sourceMappingURL=DataReadQueue.d.ts.map

package/dist/esm/util/DataReadQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataReadQueue.d.ts","sourceRoot":"","sources":["../../../src/util/DataReadQueue.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EAA4C,MAAM,EAAE,MAAM,aAAa,CAAC;AAE/E,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,WAAW,CAAC,CAAyF;IAC7G,OAAO,CAAC,MAAM,CAAS;IAEjB,IAAI,CAAC,SAAS,SAAS,GAAG,OAAO,CAAC,CAAC,CAAC;IAkBpC,KAAK,CAAC,IAAI,EAAE,CAAC;IAWnB,KAAK;CAOR"}

package/dist/esm/util/DataReadQueue.js

@@ -0,0 +1,56 @@
+/**
+ * Promise-based blocking queue.
+ *
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { MatterFlowError } from "../MatterError.js";
+import { Time } from "../time/Time.js";
+import { createPromise } from "./Promises.js";
+import { EndOfStreamError, NoResponseTimeoutError } from "./Stream.js";
+class DataReadQueue {
+  queue = new Array();
+  pendingRead;
+  closed = false;
+  async read(timeoutMs = 6e4) {
+    const { promise, resolver, rejecter } = createPromise();
+    if (this.closed) throw new EndOfStreamError();
+    const data = this.queue.shift();
+    if (data !== void 0) {
+      return data;
+    }
+    if (this.pendingRead !== void 0) throw new MatterFlowError("Only one pending read is supported");
+    this.pendingRead = {
+      resolver,
+      rejecter,
+      timeoutTimer: Time.getTimer(
+        "Queue timeout",
+        timeoutMs,
+        () => rejecter(new NoResponseTimeoutError())
+      ).start()
+    };
+    return promise;
+  }
+  async write(data) {
+    if (this.closed) throw new EndOfStreamError();
+    if (this.pendingRead !== void 0) {
+      this.pendingRead.timeoutTimer?.stop();
+      this.pendingRead.resolver(data);
+      this.pendingRead = void 0;
+      return;
+    }
+    this.queue.push(data);
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.pendingRead === void 0) return;
+    this.pendingRead.timeoutTimer?.stop();
+    this.pendingRead.rejecter(new EndOfStreamError());
+  }
+}
+export {
+  DataReadQueue
+};
+//# sourceMappingURL=DataReadQueue.js.map

package/dist/esm/util/DataReadQueue.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/util/DataReadQueue.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,SAAS,uBAAuB;AAChC,SAAS,YAAmB;AAC5B,SAAS,qBAAqB;AAC9B,SAAS,kBAAkB,8BAAsC;AAE1D,MAAM,cAAsC;AAAA,EAC9B,QAAQ,IAAI,MAAS;AAAA,EAC9B;AAAA,EACA,SAAS;AAAA,EAEjB,MAAM,KAAK,YAAY,KAAoB;AACvC,UAAM,EAAE,SAAS,UAAU,SAAS,IAAI,cAAiB;AACzD,QAAI,KAAK,OAAQ,OAAM,IAAI,iBAAiB;AAC5C,UAAM,OAAO,KAAK,MAAM,MAAM;AAC9B,QAAI,SAAS,QAAW;AACpB,aAAO;AAAA,IACX;AACA,QAAI,KAAK,gBAAgB,OAAW,OAAM,IAAI,gBAAgB,oCAAoC;AAClG,SAAK,cAAc;AAAA,MACf;AAAA,MACA;AAAA,MACA,cAAc,KAAK;AAAA,QAAS;AAAA,QAAiB;AAAA,QAAW,MACpD,SAAS,IAAI,uBAAuB,CAAC;AAAA,MACzC,EAAE,MAAM;AAAA,IACZ;AACA,WAAO;AAAA,EACX;AAAA,EAEA,MAAM,MAAM,MAAS;AACjB,QAAI,KAAK,OAAQ,OAAM,IAAI,iBAAiB;AAC5C,QAAI,KAAK,gBAAgB,QAAW;AAChC,WAAK,YAAY,cAAc,KAAK;AACpC,WAAK,YAAY,SAAS,IAAI;AAC9B,WAAK,cAAc;AACnB;AAAA,IACJ;AACA,SAAK,MAAM,KAAK,IAAI;AAAA,EACxB;AAAA,EAEA,QAAQ;AACJ,QAAI,KAAK,OAAQ;AACjB,SAAK,SAAS;AACd,QAAI,KAAK,gBAAgB,OAAW;AACpC,SAAK,YAAY,cAAc,KAAK;AACpC,SAAK,YAAY,SAAS,IAAI,iBAAiB,CAAC;AAAA,EACpD;AACJ;",
+  "names": []
+}

package/dist/esm/util/DataReader.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Endian } from "./Bytes.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: Uint8Array, 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;
+    getLength(): number;
+    setOffset(offset: number): void;
+    private getOffsetAndAdvance;
+}
+//# sourceMappingURL=DataReader.d.ts.map

package/dist/esm/util/DataReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataReader.d.ts","sourceRoot":"","sources":["../../../src/util/DataReader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAS,MAAM,EAAE,MAAM,YAAY,CAAC;AAE3C,8DAA8D;AAC9D,qBAAa,UAAU,CAAC,CAAC,SAAS,MAAM;IAMhC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAL3B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAU;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,MAAM,CAAK;gBAGE,MAAM,EAAE,UAAU,EACnC,MAAM,EAAE,CAAC;IAMb,SAAS;IAIT,UAAU;IAIV,UAAU;IAIV,UAAU;IAIV,QAAQ;IAIR,SAAS;IAIT,SAAS;IAIT,SAAS;IAIT,SAAS;IAIT,UAAU;IAIV,cAAc,CAAC,MAAM,EAAE,MAAM;IAK7B,aAAa,CAAC,MAAM,EAAE,MAAM;IAK5B,sBAAsB;IAItB,iBAAiB;IAIjB,SAAS;IAIT,SAAS,CAAC,MAAM,EAAE,MAAM;IAOxB,OAAO,CAAC,mBAAmB;CAQ9B"}

package/dist/esm/util/DataReader.js

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes, Endian } from "./Bytes.js";
+class DataReader {
+  constructor(buffer, endian) {
+    this.buffer = buffer;
+    this.dataView = Bytes.dataViewOf(buffer);
+    this.littleEndian = endian === Endian.Little;
+  }
+  littleEndian;
+  dataView;
+  offset = 0;
+  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);
+    return this.buffer.subarray(offset, offset + length);
+  }
+  getRemainingBytesCount() {
+    return this.dataView.byteLength - this.offset;
+  }
+  getRemainingBytes() {
+    return this.buffer.subarray(this.offset);
+  }
+  getLength() {
+    return this.dataView.byteLength;
+  }
+  setOffset(offset) {
+    if (offset > this.dataView.byteLength) {
+      throw new Error(`Offset ${offset} is out of bounds.`);
+    }
+    this.offset = offset;
+  }
+  getOffsetAndAdvance(size) {
+    const result = this.offset;
+    this.offset += size;
+    if (this.offset > this.dataView.byteLength) {
+      this.offset = this.dataView.byteLength;
+    }
+    return result;
+  }
+}
+export {
+  DataReader
+};
+//# sourceMappingURL=DataReader.js.map

package/dist/esm/util/DataReader.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/util/DataReader.ts"],
+  "mappings": "AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,SAAS,OAAO,cAAc;AAGvB,MAAM,WAA6B;AAAA,EAKtC,YACqB,QACjB,QACF;AAFmB;AAGjB,SAAK,WAAW,MAAM,WAAW,MAAM;AACvC,SAAK,eAAe,WAAW,OAAO;AAAA,EAC1C;AAAA,EAViB;AAAA,EACA;AAAA,EACT,SAAS;AAAA,EAUjB,YAAY;AACR,WAAO,KAAK,SAAS,SAAS,KAAK,oBAAoB,CAAC,CAAC;AAAA,EAC7D;AAAA,EAEA,aAAa;AACT,WAAO,KAAK,SAAS,UAAU,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EACjF;AAAA,EAEA,aAAa;AACT,WAAO,KAAK,SAAS,UAAU,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EACjF;AAAA,EAEA,aAAa;AACT,WAAO,KAAK,SAAS,aAAa,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EACpF;AAAA,EAEA,WAAW;AACP,WAAO,KAAK,SAAS,QAAQ,KAAK,oBAAoB,CAAC,CAAC;AAAA,EAC5D;AAAA,EAEA,YAAY;AACR,WAAO,KAAK,SAAS,SAAS,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EAChF;AAAA,EAEA,YAAY;AACR,WAAO,KAAK,SAAS,SAAS,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EAChF;AAAA,EAEA,YAAY;AACR,WAAO,KAAK,SAAS,YAAY,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EACnF;AAAA,EAEA,YAAY;AACR,WAAO,KAAK,SAAS,WAAW,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EAClF;AAAA,EAEA,aAAa;AACT,WAAO,KAAK,SAAS,WAAW,KAAK,oBAAoB,CAAC,GAAG,KAAK,YAAY;AAAA,EAClF;AAAA,EAEA,eAAe,QAAgB;AAC3B,UAAM,SAAS,KAAK,oBAAoB,MAAM;AAC9C,WAAO,IAAI,YAAY,EAAE,OAAO,KAAK,OAAO,SAAS,QAAQ,SAAS,MAAM,CAAC;AAAA,EACjF;AAAA,EAEA,cAAc,QAAgB;AAC1B,UAAM,SAAS,KAAK,oBAAoB,MAAM;AAC9C,WAAO,KAAK,OAAO,SAAS,QAAQ,SAAS,MAAM;AAAA,EACvD;AAAA,EAEA,yBAAyB;AACrB,WAAO,KAAK,SAAS,aAAa,KAAK;AAAA,EAC3C;AAAA,EAEA,oBAAoB;AAChB,WAAO,KAAK,OAAO,SAAS,KAAK,MAAM;AAAA,EAC3C;AAAA,EAEA,YAAY;AACR,WAAO,KAAK,SAAS;AAAA,EACzB;AAAA,EAEA,UAAU,QAAgB;AACtB,QAAI,SAAS,KAAK,SAAS,YAAY;AACnC,YAAM,IAAI,MAAM,UAAU,MAAM,oBAAoB;AAAA,IACxD;AACA,SAAK,SAAS;AAAA,EAClB;AAAA,EAEQ,oBAAoB,MAAc;AACtC,UAAM,SAAS,KAAK;AACpB,SAAK,UAAU;AACf,QAAI,KAAK,SAAS,KAAK,SAAS,YAAY;AACxC,WAAK,SAAS,KAAK,SAAS;AAAA,IAChC;AACA,WAAO;AAAA,EACX;AACJ;",
+  "names": []
+}

package/dist/esm/util/DataWriter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Endian } from "./Bytes.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;
+    writeByteArray(value: Uint8Array): void;
+    toByteArray(): Uint8Array;
+}
+//# sourceMappingURL=DataWriter.d.ts.map

package/dist/esm/util/DataWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataWriter.d.ts","sourceRoot":"","sources":["../../../src/util/DataWriter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGpC,+DAA+D;AAE/D,qBAAa,UAAU,CAAC,CAAC,SAAS,MAAM;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAU;IACvC,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;gBAEtC,MAAM,EAAE,CAAC;IAIrB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAKjC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOlC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOlC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOlC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOhC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOjC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOjC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAOjC,UAAU,CAAC,KAAK,EAAE,MAAM;IAOxB,WAAW,CAAC,KAAK,EAAE,MAAM;IAOzB,cAAc,CAAC,KAAK,EAAE,UAAU;IAKhC,WAAW;CAed"}