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

package/dist/cjs/log/FileLogger.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/log/FileLogger.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,sBAAqB;AAPrB;AAAA;AAAA;AAAA;AAAA;AAcA,eAAsB,iBAAiB,MAAc;AACjD,QAAM,aAAa,UAAM,sBAAK,MAAM,GAAG;AACvC,QAAM,SAAS,WAAW,kBAAkB;AAC5C,UAAQ;AAAA,IACJ;AAAA,IACA,MAAM,KAAK,WAAW,MAAM,EAAE,MAAM,SAAO,OAAO,QAAQ,MAAM,6BAA6B,GAAG,EAAE,CAAC;AAAA,EACvG;AAEA,SAAO,CAAC,QAAkB,iBAAyB;AAC/C,QAAI;AACA,aAAO,MAAM,GAAG,YAAY;AAAA,CAAI;AAAA,IACpC,SAAS,OAAO;AACZ,cAAQ,MAAM,gCAAgC,KAAK,EAAE;AAAA,IACzD;AAAA,EACJ;AACJ;",
+  "names": []
+}

package/dist/cjs/log/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./FileLogger.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/log/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/log/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,iBAAiB,CAAC"}

package/dist/cjs/log/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+module.exports = __toCommonJS(log_exports);
+__reExport(log_exports, require("./FileLogger.js"), module.exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=index.js.map

package/dist/cjs/log/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/log/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,wBAAc,4BANd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/net/NodeJsNetwork.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Network, NetworkInterface, NetworkInterfaceDetails, UdpChannel, UdpChannelOptions } from "#general";
+export declare class NodeJsNetwork extends Network {
+    static getMulticastInterfaceIpv4(netInterface: string): string | undefined;
+    static getMembershipMulticastInterfaces(netInterface: string | undefined, ipv4: boolean): (string | undefined)[];
+    static getNetInterfaceZoneIpv6(netInterface: string): string | undefined;
+    static getNetInterfaceForIp(ip: string): string | undefined;
+    private static readonly netInterfaces;
+    close(): Promise<void>;
+    private static getNetInterfaceForRemoteAddress;
+    private static getNetInterfaceZoneIpv6Internal;
+    /**
+     * Get all network interfaces.
+     * The optional configuration parameter allows to map interface names to types if this mapping is known.
+     * Each network interface which has no mapped type is returned as Ethernet for now.
+     *
+     * @param configuration - An array of objects with the name and type properties.
+     */
+    getNetInterfaces(configuration?: NetworkInterface[]): NetworkInterface[];
+    getIpMac(netInterface: string): NetworkInterfaceDetails | undefined;
+    createUdpChannel(options: UdpChannelOptions): Promise<UdpChannel>;
+}
+//# sourceMappingURL=NodeJsNetwork.d.ts.map

package/dist/cjs/net/NodeJsNetwork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeJsNetwork.d.ts","sourceRoot":"","sources":["../../../src/net/NodeJsNetwork.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAKH,OAAO,EAEP,gBAAgB,EAChB,uBAAuB,EAEvB,UAAU,EACV,iBAAiB,EACpB,MAAM,UAAU,CAAC;AAMlB,qBAAa,aAAc,SAAQ,OAAO;IACtC,MAAM,CAAC,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAW1E,MAAM,CAAC,gCAAgC,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE;IAwBhH,MAAM,CAAC,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAMxE,MAAM,CAAC,oBAAoB,CAAC,EAAE,EAAE,MAAM;IAMtC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAInC;IAEa,KAAK;IAIpB,OAAO,CAAC,MAAM,CAAC,+BAA+B;IAwB9C,OAAO,CAAC,MAAM,CAAC,+BAA+B;IAa9C;;;;;;OAMG;IACH,gBAAgB,CAAC,aAAa,GAAE,gBAAgB,EAAO,GAAG,gBAAgB,EAAE;IAmB5E,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS;IAQ1D,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;CAG7E"}

package/dist/cjs/net/NodeJsNetwork.js

@@ -0,0 +1,145 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NodeJsNetwork_exports = {};
+__export(NodeJsNetwork_exports, {
+  NodeJsNetwork: () => NodeJsNetwork
+});
+module.exports = __toCommonJS(NodeJsNetwork_exports);
+var import_general = require("#general");
+var import_os = require("os");
+var import_NodeJsUdpChannel = require("./NodeJsUdpChannel.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("NetworkNode");
+class NodeJsNetwork extends import_general.Network {
+  static getMulticastInterfaceIpv4(netInterface) {
+    const netInterfaceInfo = (0, import_os.networkInterfaces)()[netInterface];
+    if (netInterfaceInfo === void 0) throw new import_general.NetworkError(`Unknown interface: ${netInterface}`);
+    for (const { address, family } of netInterfaceInfo) {
+      if (family === "IPv4") {
+        return address;
+      }
+    }
+    return void 0;
+  }
+  static getMembershipMulticastInterfaces(netInterface, ipv4) {
+    if (ipv4) {
+      return [void 0];
+    } else {
+      let networkInterfaceEntries = Object.entries((0, import_os.networkInterfaces)());
+      if (netInterface !== void 0) {
+        networkInterfaceEntries = networkInterfaceEntries.filter(([name]) => name === netInterface);
+      }
+      const multicastInterfaces = networkInterfaceEntries.flatMap(([netInterface2, netInterfaceInfo]) => {
+        if (netInterfaceInfo === void 0) return [];
+        const zone = this.getNetInterfaceZoneIpv6Internal(netInterface2, netInterfaceInfo);
+        return zone === void 0 ? [] : [`::%${zone}`];
+      });
+      if (multicastInterfaces.length === 0) {
+        logger.warn(
+          `No IPv6 multicast interface found${netInterface !== void 0 ? ` for interface ${netInterface}` : ""}.`
+        );
+      }
+      return multicastInterfaces;
+    }
+  }
+  static getNetInterfaceZoneIpv6(netInterface) {
+    const netInterfaceInfo = (0, import_os.networkInterfaces)()[netInterface];
+    if (netInterfaceInfo === void 0) throw new import_general.NetworkError(`Unknown interface: ${netInterface}`);
+    return this.getNetInterfaceZoneIpv6Internal(netInterface, netInterfaceInfo);
+  }
+  static getNetInterfaceForIp(ip) {
+    return this.netInterfaces.get(ip);
+  }
+  static netInterfaces = new import_general.Cache(
+    "Network interface",
+    (ip) => this.getNetInterfaceForRemoteAddress(ip),
+    5 * 60 * 1e3
+  );
+  async close() {
+    await NodeJsNetwork.netInterfaces.close();
+  }
+  static getNetInterfaceForRemoteAddress(ip) {
+    if (ip.includes("%")) {
+      return ip.split("%")[1];
+    } else {
+      const interfaces = (0, import_os.networkInterfaces)();
+      for (const name in interfaces) {
+        const netInterfaces = interfaces[name];
+        for (const { address, netmask } of netInterfaces) {
+          if ((0, import_general.onSameNetwork)(ip, address, netmask)) {
+            return this.getNetInterfaceZoneIpv6Internal(name, netInterfaces);
+          }
+        }
+      }
+      if ((0, import_general.isIPv6)(ip)) {
+        if (ip.startsWith("fd")) {
+          return "";
+        }
+      }
+      return void 0;
+    }
+  }
+  static getNetInterfaceZoneIpv6Internal(netInterface, netInterfaceInfos) {
+    if (process.platform !== "win32") {
+      return netInterface;
+    }
+    if (netInterfaceInfos === void 0) return void 0;
+    return netInterfaceInfos.find(({ address, family }) => family === "IPv6" && address.startsWith("fe80::"))?.scopeid?.toString();
+  }
+  /**
+   * Get all network interfaces.
+   * The optional configuration parameter allows to map interface names to types if this mapping is known.
+   * Each network interface which has no mapped type is returned as Ethernet for now.
+   *
+   * @param configuration - An array of objects with the name and type properties.
+   */
+  getNetInterfaces(configuration = []) {
+    const result = new Array();
+    const interfaces = (0, import_os.networkInterfaces)();
+    for (const name in interfaces) {
+      const netInterfaces = interfaces[name];
+      if (netInterfaces.length === 0) continue;
+      if (netInterfaces[0].internal) continue;
+      let type = import_general.InterfaceType.Ethernet;
+      if (configuration.length > 0) {
+        const nameType = configuration.find(({ name: mapName }) => name === mapName);
+        if (nameType !== void 0 && nameType.type !== void 0) {
+          type = nameType.type;
+        }
+      }
+      result.push({ name, type });
+    }
+    return result;
+  }
+  getIpMac(netInterface) {
+    const netInterfaceInfo = (0, import_os.networkInterfaces)()[netInterface];
+    if (netInterfaceInfo === void 0) return void 0;
+    const ipV4 = netInterfaceInfo.filter(({ family }) => family === "IPv4").map(({ address }) => address);
+    const ipV6 = netInterfaceInfo.filter(({ family }) => family === "IPv6").map(({ address }) => address);
+    return { mac: netInterfaceInfo[0].mac, ipV4, ipV6 };
+  }
+  createUdpChannel(options) {
+    return import_NodeJsUdpChannel.NodeJsUdpChannel.create(options);
+  }
+}
+//# sourceMappingURL=NodeJsNetwork.js.map

package/dist/cjs/net/NodeJsNetwork.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/net/NodeJsNetwork.ts"],
+  "mappings": "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",
+  "names": ["netInterface"]
+}

package/dist/cjs/net/NodeJsUdpChannel.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ChannelType, UdpChannel, UdpChannelOptions } from "#general";
+import * as dgram from "dgram";
+export declare class NodeJsUdpChannel implements UdpChannel {
+    private readonly type;
+    private readonly socket;
+    private readonly netInterface?;
+    static create({ listeningPort, type, listeningAddress, netInterface, membershipAddresses, }: UdpChannelOptions): Promise<NodeJsUdpChannel>;
+    readonly maxPayloadSize: number;
+    constructor(type: "udp4" | "udp6", socket: dgram.Socket, netInterface?: string | undefined);
+    onData(listener: (netInterface: string, peerAddress: string, peerPort: number, data: Uint8Array) => void): {
+        close: () => Promise<void>;
+    };
+    send(host: string, port: number, data: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+    get port(): number;
+    supports(type: ChannelType, address?: string): boolean;
+}
+//# sourceMappingURL=NodeJsUdpChannel.d.ts.map

package/dist/cjs/net/NodeJsUdpChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeJsUdpChannel.d.ts","sourceRoot":"","sources":["../../../src/net/NodeJsUdpChannel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACH,WAAW,EAOX,UAAU,EACV,iBAAiB,EACpB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAiC/B,qBAAa,gBAAiB,YAAW,UAAU;IA6D3C,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;WA9DrB,MAAM,CAAC,EAChB,aAAa,EACb,IAAI,EACJ,gBAAgB,EAChB,YAAY,EACZ,mBAAmB,GACtB,EAAE,iBAAiB;IAmDpB,QAAQ,CAAC,cAAc,SAAwB;gBAG1B,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,MAAM,EAAE,KAAK,CAAC,MAAM,EACpB,YAAY,CAAC,EAAE,MAAM,YAAA;IAG1C,MAAM,CAAC,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,KAAK,IAAI;;;IAelG,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU;IAiBjD,KAAK;IAQX,IAAI,IAAI,WAEP;IAED,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM;CAiB/C"}

package/dist/cjs/net/NodeJsUdpChannel.js

@@ -0,0 +1,181 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NodeJsUdpChannel_exports = {};
+__export(NodeJsUdpChannel_exports, {
+  NodeJsUdpChannel: () => NodeJsUdpChannel
+});
+module.exports = __toCommonJS(NodeJsUdpChannel_exports);
+var import_general = require("#general");
+var import_protocol = require("#protocol");
+var dgram = __toESM(require("dgram"), 1);
+var import_NodeJsNetwork = require("./NodeJsNetwork.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("UdpChannelNode");
+function createDgramSocket(host, port, options) {
+  const socket = dgram.createSocket(options);
+  return new Promise((resolve, reject) => {
+    const handleBindError = (error) => {
+      try {
+        socket.close();
+      } catch (error2) {
+        logger.debug("Error on closing socket", error2);
+      }
+      reject(error);
+    };
+    socket.on("error", handleBindError);
+    socket.bind(port, host, () => {
+      const { address: localHost, port: localPort } = socket.address();
+      logger.debug(
+        "Socket created and bound ",
+        import_general.Diagnostic.dict({
+          remoteAddress: `${host}:${port}`,
+          localAddress: `${localHost}:${localPort}`
+        })
+      );
+      socket.removeListener("error", handleBindError);
+      socket.on("error", (error) => logger.error(error));
+      resolve(socket);
+    });
+  });
+}
+class NodeJsUdpChannel {
+  constructor(type, socket, netInterface) {
+    this.type = type;
+    this.socket = socket;
+    this.netInterface = netInterface;
+  }
+  static async create({
+    listeningPort,
+    type,
+    listeningAddress,
+    netInterface,
+    membershipAddresses
+  }) {
+    const socketOptions = { type, reuseAddr: true };
+    if (type === "udp6") {
+      socketOptions.ipv6Only = true;
+    }
+    const socket = await createDgramSocket(listeningAddress, listeningPort, socketOptions);
+    socket.setBroadcast(true);
+    let netInterfaceZone;
+    if (netInterface !== void 0) {
+      netInterfaceZone = import_NodeJsNetwork.NodeJsNetwork.getNetInterfaceZoneIpv6(netInterface);
+      let multicastInterface;
+      if (type === "udp4") {
+        multicastInterface = import_NodeJsNetwork.NodeJsNetwork.getMulticastInterfaceIpv4(netInterface);
+        if (multicastInterface === void 0) {
+          throw new import_general.NetworkError(`No IPv4 addresses on interface: ${netInterface}`);
+        }
+      } else {
+        if (netInterfaceZone === void 0) {
+          throw new import_general.NetworkError(`No IPv6 addresses on interface: ${netInterface}`);
+        }
+        multicastInterface = `::%${netInterfaceZone}`;
+      }
+      logger.debug(
+        "Initialize multicast",
+        import_general.Diagnostic.dict({
+          address: `${multicastInterface}:${listeningPort}`,
+          interface: netInterface,
+          type
+        })
+      );
+      socket.setMulticastInterface(multicastInterface);
+    }
+    if (membershipAddresses !== void 0) {
+      const multicastInterfaces = import_NodeJsNetwork.NodeJsNetwork.getMembershipMulticastInterfaces(netInterface, type === "udp4");
+      for (const address of membershipAddresses) {
+        for (const multicastInterface of multicastInterfaces) {
+          try {
+            socket.addMembership(address, multicastInterface);
+          } catch (error) {
+            logger.warn(
+              `Error adding membership for address ${address}${multicastInterface ? ` with interface ${multicastInterface}` : ""}: ${error}`
+            );
+          }
+        }
+      }
+    }
+    return new NodeJsUdpChannel(type, socket, netInterfaceZone);
+  }
+  maxPayloadSize = import_general.MAX_UDP_MESSAGE_SIZE;
+  onData(listener) {
+    const messageListener = (data, { address, port }) => {
+      const netInterface = this.netInterface ?? import_NodeJsNetwork.NodeJsNetwork.getNetInterfaceForIp(address);
+      if (netInterface === void 0) return;
+      listener(netInterface, address, port, data);
+    };
+    this.socket.on("message", messageListener);
+    return {
+      close: async () => {
+        this.socket.removeListener("message", messageListener);
+      }
+    };
+  }
+  async send(host, port, data) {
+    return new Promise((resolve, reject) => {
+      this.socket.send(data, port, host, (error) => {
+        if (error !== null) {
+          const netError = error instanceof Error && "code" in error && error.code === "EHOSTUNREACH" ? new import_protocol.RetransmissionLimitReachedError(error.message) : new import_general.NetworkError(error.message);
+          netError.stack = error.stack;
+          reject(netError);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  async close() {
+    try {
+      this.socket.close();
+    } catch (error) {
+      logger.debug("Error on closing socket", error);
+    }
+  }
+  get port() {
+    return this.socket.address().port;
+  }
+  supports(type, address) {
+    if (type !== import_general.ChannelType.UDP) {
+      return false;
+    }
+    if (address === void 0) {
+      return true;
+    }
+    if (this.type === "udp4") {
+      return (0, import_general.isIPv4)(address);
+    }
+    return (0, import_general.isIPv6)(address);
+  }
+}
+//# sourceMappingURL=NodeJsUdpChannel.js.map

package/dist/cjs/net/NodeJsUdpChannel.js.map

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

package/dist/cjs/net/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import "./register.js";
+export * from "./NodeJsNetwork.js";
+export * from "./NodeJsUdpChannel.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/net/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/net/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,eAAe,CAAC;AACvB,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}

package/dist/cjs/net/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var net_exports = {};
+module.exports = __toCommonJS(net_exports);
+var import_register = require("./register.js");
+__reExport(net_exports, require("./NodeJsNetwork.js"), module.exports);
+__reExport(net_exports, require("./NodeJsUdpChannel.js"), module.exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=index.js.map

package/dist/cjs/net/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/net/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAMA,sBAAO;AACP,wBAAc,+BAPd;AAQA,wBAAc,kCARd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/net/register.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=register.d.ts.map

package/dist/cjs/net/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../src/net/register.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/cjs/net/register.js

@@ -0,0 +1,16 @@
+"use strict";
+var import_general = require("#general");
+var import_NodeJsNetwork = require("./NodeJsNetwork.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+try {
+  import_general.Network.get();
+} catch (error) {
+  import_general.NoProviderError.accept(error);
+  import_general.Network.get = (0, import_general.singleton)(() => new import_NodeJsNetwork.NodeJsNetwork());
+  process.on("beforeExit", () => void import_general.Network.get().close());
+}
+//# sourceMappingURL=register.js.map

package/dist/cjs/net/register.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/net/register.ts"],
+  "mappings": ";AAMA,qBAAoD;AACpD,2BAA8B;AAP9B;AAAA;AAAA;AAAA;AAAA;AAUA,IAAI;AACA,yBAAQ,IAAI;AAChB,SAAS,OAAO;AACZ,iCAAgB,OAAO,KAAK;AAE5B,yBAAQ,UAAM,0BAAU,MAAM,IAAI,mCAAc,CAAC;AAGjD,UAAQ,GAAG,cAAc,MAAM,KAAK,uBAAQ,IAAI,EAAE,MAAM,CAAC;AAC7D;",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,11 @@
+{
+    "type": "commonjs",
+    "imports": {
+        "#general": "@matter/general",
+        "#types": "@matter/types",
+        "#clusters/*": "@matter/types/clusters/*",
+        "#node": "@matter/node",
+        "#protocol": "@matter/protocol",
+        "#*": "./*"
+    }
+}

package/dist/cjs/storage/StorageBackendDisk.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SupportedStorageTypes, SyncStorage } from "#general";
+export declare class StorageBackendDisk extends SyncStorage {
+    private readonly localStorage;
+    protected isInitialized: boolean;
+    constructor(path: string, clear?: boolean);
+    get initialized(): boolean;
+    initialize(): void;
+    close(): void;
+    clear(): void;
+    getContextBaseKey(contexts: string[], allowEmptyContext?: boolean): string;
+    buildStorageKey(contexts: string[], key: string): string;
+    get<T extends SupportedStorageTypes>(contexts: string[], key: string): T | undefined;
+    set(contexts: string[], key: string, value: SupportedStorageTypes): void;
+    set(contexts: string[], values: Record<string, SupportedStorageTypes>): void;
+    delete(contexts: string[], key: string): void;
+    /** Returns all keys of a storage context without keys of sub-contexts */
+    keys(contexts: string[]): string[];
+    values(contexts: string[]): Record<string, SupportedStorageTypes>;
+    contexts(contexts: string[]): string[];
+    clearAll(contexts: string[]): void;
+}
+//# sourceMappingURL=StorageBackendDisk.d.ts.map

package/dist/cjs/storage/StorageBackendDisk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageBackendDisk.d.ts","sourceRoot":"","sources":["../../../src/storage/StorageBackendDisk.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAA0B,qBAAqB,EAAE,WAAW,EAAU,MAAM,UAAU,CAAC;AAG9F,qBAAa,kBAAmB,SAAQ,WAAW;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IAC9B,SAAS,CAAC,aAAa,UAAS;gBAEpB,IAAI,EAAE,MAAM,EAAE,KAAK,UAAQ;IAMvC,IAAI,WAAW,YAEd;IAED,UAAU;IAIV,KAAK;IAIL,KAAK;IAIL,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,iBAAiB,UAAQ;IAY/D,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM;IAQ/C,GAAG,CAAC,CAAC,SAAS,qBAAqB,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAMpF,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,qBAAqB,GAAG,IAAI;IACxE,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,IAAI;IAe5E,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM;IAItC,yEAAyE;IACzE,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE;IAavB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE;IASzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE;IAkB3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE;CAS9B"}