@matter/thread-br-client 0.0.1

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/discovery/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,kCAAqC;AAPrC;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/dtls/channel/DtlsChannel.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type Bytes, MatterError, type Transport } from "@matter/general";
+/** DTLS peer/wire/protocol failure (handshake give-up, malformed record, peer alert, ...). */
+export declare class DtlsError extends MatterError {
+}
+/**
+ * Public channel interface for an established DTLS 1.2 + EC-JPAKE session.
+ *
+ * Modeled on the matter.js {@link ConnectedChannel} contract (framed, fixed-peer,
+ * send/close/onClose plus an inbound {@link AsyncIterable}), but deliberately does
+ * NOT implement it: DTLS runs over UDP and delivers application data unreliably,
+ * so it cannot honor `ConnectedChannel.isReliable: true`. The CoAP layer consumes
+ * only this surface — it sends and receives application-data plaintexts, iterates
+ * inbound records, and closes the session. Handshake, key derivation, record
+ * framing, and transport binding are implementation details.
+ *
+ * Inbound plaintexts are delivered via async iteration with backpressure: the
+ * producer hands each plaintext to a waiting consumer, buffering only a bounded
+ * number of records when no consumer is pending. On close or fatal error the
+ * iterator drains any buffered records, then either ends or throws the stored
+ * {@link DtlsError} to the consumer.
+ *
+ * Single-consumer only: at most one iteration with one outstanding `next()` may
+ * be active at a time. A second concurrent `next()` throws rather than silently
+ * stranding the first.
+ */
+export interface DtlsChannel extends AsyncIterable<Bytes> {
+    /** Encrypt and transmit `bytes` as one DTLS application-data record. */
+    send(bytes: Bytes): Promise<void>;
+    /** Send close_notify (best-effort), tear down transport, end inbound iteration. */
+    close(): Promise<void>;
+    /** Register a listener for channel close/disconnect. */
+    onClose(listener: () => void): Transport.Listener;
+}
+//# sourceMappingURL=DtlsChannel.d.ts.map

package/dist/cjs/dtls/channel/DtlsChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DtlsChannel.d.ts","sourceRoot":"","sources":["../../../../src/dtls/channel/DtlsChannel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,KAAK,EAAyB,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjG,8FAA8F;AAC9F,qBAAa,SAAU,SAAQ,WAAW;CAAG;AAE7C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,WAAY,SAAQ,aAAa,CAAC,KAAK,CAAC;IACrD,wEAAwE;IACxE,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC,mFAAmF;IACnF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB,wDAAwD;IACxD,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,SAAS,CAAC,QAAQ,CAAC;CACrD"}

package/dist/cjs/dtls/channel/DtlsChannel.js

@@ -0,0 +1,32 @@
+"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 DtlsChannel_exports = {};
+__export(DtlsChannel_exports, {
+  DtlsError: () => DtlsError
+});
+module.exports = __toCommonJS(DtlsChannel_exports);
+var import_general = require("@matter/general");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class DtlsError extends import_general.MatterError {
+}
+//# sourceMappingURL=DtlsChannel.js.map

package/dist/cjs/dtls/channel/DtlsChannel.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/channel/DtlsChannel.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA+E;AAN/E;AAAA;AAAA;AAAA;AAAA;AASO,MAAM,kBAAkB,2BAAY;AAAC;",
+  "names": []
+}

package/dist/cjs/dtls/channel/DtlsConnectOpts.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Environment } from "@matter/general";
+/**
+ * Connection parameters consumed by {@link connectDtls}. The `random` and
+ * `ephemeralScalar` overrides exist for deterministic tests; production callers
+ * leave them unset and the channel wires in {@link Entropy}-backed defaults.
+ */
+export interface DtlsConnectOpts {
+    /** IPv6 (or IPv4) address of the peer's MeshCoP DTLS port. Link-local zone IDs (`%en0`) accepted. */
+    address: string;
+    /** UDP port (typically 49191 for the ot-cli simulator's MeshCoP service). */
+    port: number;
+    /** EC-JPAKE password (PSKc — 16 bytes for Thread MeshCoP). */
+    password: Uint8Array;
+    /** Override the IPv4/IPv6 binding hint; default inferred from `address`. */
+    type?: "udp4" | "udp6";
+    /** RFC 6347 §4.2.4 initial retransmit interval. Default 1000ms. */
+    initialRetransmitMs?: number;
+    /** RFC 6347 §4.2.4 retransmit cap (doubling stops here). Default 60000ms. */
+    maxRetransmitMs?: number;
+    /** Maximum retransmit attempts before giving up. Default 5 (~31s total at default initial). */
+    maxRetransmits?: number;
+    /** Path-MTU advisory. Default 1280 — the Thread mesh constraint. */
+    mtu?: number;
+    /** Connect timeout. Default 30000ms. */
+    connectTimeoutMs?: number;
+    /** Override `random()` for deterministic testing. Production: CSPRNG. */
+    random?: () => Uint8Array;
+    /** Override `ephemeralScalar()` for deterministic testing. Production: CSPRNG-backed. */
+    ephemeralScalar?: () => bigint;
+    /** Environment providing the {@link Network} used for the UDP transport and the {@link Crypto} entropy source. */
+    environment: Environment;
+}
+//# sourceMappingURL=DtlsConnectOpts.d.ts.map

package/dist/cjs/dtls/channel/DtlsConnectOpts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DtlsConnectOpts.d.ts","sourceRoot":"","sources":["../../../../src/dtls/channel/DtlsConnectOpts.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B,qGAAqG;IACrG,OAAO,EAAE,MAAM,CAAC;IAEhB,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAC;IAEb,8DAA8D;IAC9D,QAAQ,EAAE,UAAU,CAAC;IAErB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAEvB,mEAAmE;IACnE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,+FAA+F;IAC/F,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,UAAU,CAAC;IAE1B,yFAAyF;IACzF,eAAe,CAAC,EAAE,MAAM,MAAM,CAAC;IAE/B,kHAAkH;IAClH,WAAW,EAAE,WAAW,CAAC;CAC5B"}

package/dist/cjs/dtls/channel/DtlsConnectOpts.js

@@ -0,0 +1,22 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DtlsConnectOpts_exports = {};
+module.exports = __toCommonJS(DtlsConnectOpts_exports);
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=DtlsConnectOpts.js.map

package/dist/cjs/dtls/channel/DtlsConnectOpts.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/channel/DtlsConnectOpts.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/dtls/channel/DtlsRetransmitTimer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Per-flight DTLS 1.2 retransmit timer (RFC 6347 §4.2.4).
+ *
+ * On `armNewFlight()` the timer is scheduled at `initialMs`. On each fire it
+ * invokes `onRetransmit`, doubles the next interval (capped at `maxMs`), and
+ * increments the attempt counter. After `maxRetransmits` attempts the timer
+ * stops and `onGiveUp` is invoked instead. `cancel()` (e.g. when the next
+ * inbound flight implicitly acknowledges the previous one) is idempotent.
+ *
+ * Tests use MockTime to control timer advancement deterministically.
+ */
+export interface DtlsRetransmitTimerOpts {
+    /** Initial delay before the first retransmit fires. */
+    initialMs: number;
+    /** Cap on the doubling sequence — RFC 6347 §4.2.4 default 60_000ms. */
+    maxMs: number;
+    /** Maximum retransmits before invoking `onGiveUp`. */
+    maxRetransmits: number;
+    /** Fired each retransmit (caller re-emits the last flight). */
+    onRetransmit: () => void;
+    /** Fired once after `maxRetransmits` attempts have elapsed without acknowledgement. */
+    onGiveUp: () => void;
+}
+export declare class DtlsRetransmitTimer {
+    #private;
+    constructor(opts: DtlsRetransmitTimerOpts);
+    /**
+     * Arm or re-arm the timer for a freshly emitted flight, resetting the attempt
+     * counter and the doubling delay back to `initialMs`.
+     */
+    armNewFlight(): void;
+    /** Cancel any pending timer. Safe to call when not armed. */
+    cancel(): void;
+    isArmed(): boolean;
+    /** Visible for tests — current attempt count (0 before the first fire). */
+    get attempt(): number;
+}
+//# sourceMappingURL=DtlsRetransmitTimer.d.ts.map

package/dist/cjs/dtls/channel/DtlsRetransmitTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DtlsRetransmitTimer.d.ts","sourceRoot":"","sources":["../../../../src/dtls/channel/DtlsRetransmitTimer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,uBAAuB;IACpC,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,cAAc,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,uFAAuF;IACvF,QAAQ,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,qBAAa,mBAAmB;;IAW5B,YAAY,IAAI,EAAE,uBAAuB,EAoBxC;IAED;;;OAGG;IACH,YAAY,IAAI,IAAI,CAKnB;IAED,6DAA6D;IAC7D,MAAM,IAAI,IAAI,CAGb;IAED,OAAO,IAAI,OAAO,CAEjB;IAED,2EAA2E;IAC3E,IAAI,OAAO,IAAI,MAAM,CAEpB;CAiBJ"}

package/dist/cjs/dtls/channel/DtlsRetransmitTimer.js

@@ -0,0 +1,97 @@
+"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 DtlsRetransmitTimer_exports = {};
+__export(DtlsRetransmitTimer_exports, {
+  DtlsRetransmitTimer: () => DtlsRetransmitTimer
+});
+module.exports = __toCommonJS(DtlsRetransmitTimer_exports);
+var import_general = require("@matter/general");
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class DtlsRetransmitTimer {
+  #initialMs;
+  #maxMs;
+  #maxRetransmits;
+  #onRetransmit;
+  #onGiveUp;
+  #timer;
+  #attempt = 0;
+  #nextDelayMs;
+  constructor(opts) {
+    if (opts.initialMs <= 0) {
+      throw new import_general.ImplementationError(`DtlsRetransmitTimer initialMs must be > 0, got ${opts.initialMs}`);
+    }
+    if (opts.maxMs < opts.initialMs) {
+      throw new import_general.ImplementationError(
+        `DtlsRetransmitTimer maxMs ${opts.maxMs} must be >= initialMs ${opts.initialMs}`
+      );
+    }
+    if (opts.maxRetransmits < 1) {
+      throw new import_general.ImplementationError(
+        `DtlsRetransmitTimer maxRetransmits must be >= 1, got ${opts.maxRetransmits}`
+      );
+    }
+    this.#initialMs = opts.initialMs;
+    this.#maxMs = opts.maxMs;
+    this.#maxRetransmits = opts.maxRetransmits;
+    this.#onRetransmit = opts.onRetransmit;
+    this.#onGiveUp = opts.onGiveUp;
+    this.#nextDelayMs = opts.initialMs;
+  }
+  /**
+   * Arm or re-arm the timer for a freshly emitted flight, resetting the attempt
+   * counter and the doubling delay back to `initialMs`.
+   */
+  armNewFlight() {
+    this.cancel();
+    this.#attempt = 0;
+    this.#nextDelayMs = this.#initialMs;
+    this.#schedule();
+  }
+  /** Cancel any pending timer. Safe to call when not armed. */
+  cancel() {
+    this.#timer?.stop();
+    this.#timer = void 0;
+  }
+  isArmed() {
+    return this.#timer !== void 0;
+  }
+  /** Visible for tests — current attempt count (0 before the first fire). */
+  get attempt() {
+    return this.#attempt;
+  }
+  #schedule() {
+    const delay = this.#nextDelayMs;
+    this.#timer = import_general.Time.getTimer("dtls-retransmit", (0, import_general.Millis)(delay), () => {
+      this.#timer = void 0;
+      this.#attempt += 1;
+      if (this.#attempt > this.#maxRetransmits) {
+        this.#onGiveUp();
+        return;
+      }
+      this.#onRetransmit();
+      this.#nextDelayMs = Math.min(this.#nextDelayMs * 2, this.#maxMs);
+      this.#schedule();
+    }).start();
+  }
+}
+//# sourceMappingURL=DtlsRetransmitTimer.js.map

package/dist/cjs/dtls/channel/DtlsRetransmitTimer.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/dtls/channel/DtlsRetransmitTimer.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA8D;AAN9D;AAAA;AAAA;AAAA;AAAA;AAgCO,MAAM,oBAAoB;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET;AAAA,EACA,WAAW;AAAA,EACX;AAAA,EAEA,YAAY,MAA+B;AACvC,QAAI,KAAK,aAAa,GAAG;AACrB,YAAM,IAAI,mCAAoB,kDAAkD,KAAK,SAAS,EAAE;AAAA,IACpG;AACA,QAAI,KAAK,QAAQ,KAAK,WAAW;AAC7B,YAAM,IAAI;AAAA,QACN,6BAA6B,KAAK,KAAK,yBAAyB,KAAK,SAAS;AAAA,MAClF;AAAA,IACJ;AACA,QAAI,KAAK,iBAAiB,GAAG;AACzB,YAAM,IAAI;AAAA,QACN,wDAAwD,KAAK,cAAc;AAAA,MAC/E;AAAA,IACJ;AACA,SAAK,aAAa,KAAK;AACvB,SAAK,SAAS,KAAK;AACnB,SAAK,kBAAkB,KAAK;AAC5B,SAAK,gBAAgB,KAAK;AAC1B,SAAK,YAAY,KAAK;AACtB,SAAK,eAAe,KAAK;AAAA,EAC7B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,eAAqB;AACjB,SAAK,OAAO;AACZ,SAAK,WAAW;AAChB,SAAK,eAAe,KAAK;AACzB,SAAK,UAAU;AAAA,EACnB;AAAA;AAAA,EAGA,SAAe;AACX,SAAK,QAAQ,KAAK;AAClB,SAAK,SAAS;AAAA,EAClB;AAAA,EAEA,UAAmB;AACf,WAAO,KAAK,WAAW;AAAA,EAC3B;AAAA;AAAA,EAGA,IAAI,UAAkB;AAClB,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,YAAkB;AACd,UAAM,QAAQ,KAAK;AACnB,SAAK,SAAS,oBAAK,SAAS,uBAAmB,uBAAO,KAAK,GAAG,MAAM;AAChE,WAAK,SAAS;AACd,WAAK,YAAY;AACjB,UAAI,KAAK,WAAW,KAAK,iBAAiB;AACtC,aAAK,UAAU;AACf;AAAA,MACJ;AACA,WAAK,cAAc;AAEnB,WAAK,eAAe,KAAK,IAAI,KAAK,eAAe,GAAG,KAAK,MAAM;AAC/D,WAAK,UAAU;AAAA,IACnB,CAAC,EAAE,MAAM;AAAA,EACb;AACJ;",
+  "names": []
+}

package/dist/cjs/dtls/channel/NobleDtlsChannel.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2022-2026 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Bytes, type Transport } from "@matter/general";
+import { type DtlsChannel } from "./DtlsChannel.js";
+import type { DtlsConnectOpts } from "./DtlsConnectOpts.js";
+/**
+ * UDP-bound DTLS 1.2 + EC-JPAKE client. Drives a {@link DtlsClient} state machine
+ * over a matter.js {@link UdpSocket}, applies RFC 6347 §4.2.4 retransmit on the
+ * handshake flights, then exposes a plaintext {@link DtlsChannel} surface for
+ * application data (CoAP in Phase 4).
+ *
+ * Lifecycle: caller constructs with {@link DtlsConnectOpts}, awaits
+ * {@link connect()} (which throws on handshake failure / timeout / give-up),
+ * then uses {@link send} and inbound async iteration until {@link close}.
+ * `close()` is idempotent and will best-effort send a close_notify alert.
+ */
+export declare class NobleDtlsChannel implements DtlsChannel {
+    #private;
+    constructor(opts: DtlsConnectOpts);
+    /**
+     * Bind the UDP socket, run the handshake to "established". Throws on
+     * timeout, give-up, or any DTLS-level failure.
+     */
+    connect(): Promise<void>;
+    send(bytes: Bytes): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterator<Bytes>;
+    onClose(listener: () => void): Transport.Listener;
+    close(): Promise<void>;
+    /** True once the handshake reaches "established". */
+    isConnected(): boolean;
+}
+//# sourceMappingURL=NobleDtlsChannel.d.ts.map

package/dist/cjs/dtls/channel/NobleDtlsChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NobleDtlsChannel.d.ts","sourceRoot":"","sources":["../../../../src/dtls/channel/NobleDtlsChannel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACH,KAAK,EAcL,KAAK,SAAS,EAEjB,MAAM,iBAAiB,CAAC;AAMzB,OAAO,EAAE,KAAK,WAAW,EAAa,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAyD5D;;;;;;;;;;GAUG;AACH,qBAAa,gBAAiB,YAAW,WAAW;;IAsChD,YAAY,IAAI,EAAE,eAAe,EAGhC;IAED;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAqE7B;IAEK,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBtC;IAED,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,KAAK,CAAC,CA2B7C;IAED,OAAO,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,SAAS,CAAC,QAAQ,CAOhD;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAkD3B;IAED,qDAAqD;IACrD,WAAW,IAAI,OAAO,CAErB;CAwLJ"}