@matter/nodejs-shell 0.11.0-alpha.0-20241007-547af42a8

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,192 @@
+# matter.js Node Shell
+
+This project provides a light-weight node.js implementation of a Matter shell application like the chip-tool from the official Matter-SDK.
+
+> This package supports all Node.js LTS versions starting with 18.x
+
+## Install
+
+If you want to install just the shell app then you can do so by running:
+
+```
+npm install @matter/nodejs-shell
+```
+
+## Run
+
+There are three ways to start matter-node-shell. The `nodenum` parameter provides a unique identifier for the matter-node-shell process mainly to allocate a unique port number. If `nodenum` is not passed, it will default to `0`.
+The shell currently just supports Controller side and so the port is not used and the node is always by default a "controller".
+
+```
+npm shell <nodenum>
+```
+
+There are other parameters available to enable BLE and define the HCI device to use. See `npm shell -- --help` for more details.
+
+## General usage
+
+The shell offers and interactive prompt that can execute commands. If you just enter the command name that has sub commands (with or without followed by "help"), it will display the command options. If you enter the command name followed by the options, it will execute the command, with "help" after the command name it will show the detailed help for this command.
+
+e.g. `commission` or `commission help` will display the commissioning command options
+
+### help
+
+Display a list of all top-level commands supported and a brief description.
+
+```
+matter-node> help
+  commission                               Handle device commissioning
+  config                                   Manage global configuration
+  session                                  Manage session
+  nodes                                    Manage nodes
+  subscribe [node-id]                      Subscribe to all events and attributes of a node
+  identify [time] [node-id] [endpoint-id]  Trigger Identify command with given time (default 10s). Execute on one node or endpoint, else all onoff clusters will be controlled
+  discover                                 Handle device discovery
+  attributes                               Read and Write attributes
+  events                                   Read events
+  commands                                 Invoke commands
+  tlv                                      TLV decoding tools
+  exit                                     Exit
+```
+
+### Help for commands
+
+For every command help can be requested by using the command name, or by adding with `--help` as parameter to any command text.
+
+For instance `config --help` will display all node configuration for the persistent store of the shell.
+
+```
+> config
+  config loglevel             Manage Console and File LogLevels
+  config logfile              Manage Logfile path
+  config ble-hci              Manage BLE HCI ID (Linux)
+  config wifi-credentials     Manage Wi-Fi credentials used in commissioning process
+  config thread-credentials   Manage Thread credentials used in commissioning process
+
+Done
+```
+
+### Logging
+
+By default the Shell logs messages to the console. The log level can be changed using the `config loglevel` command. The log level can be set to `error`, `warn`, `info`, `debug` or `trace`. The console default is "info".
+
+Additionally the Shell can log to a file. The log file path can be set using the `config logfile` command or as commandline parameter (which will then be persisted in the configuration). The log file always contain the logs in "debug" level.
+
+### Commission a device
+
+The shell supports discovery and also commissioning of devices. The commissioning process is based on the Matter SDK and uses the same commissioning process as the chip-tool. The commissioning process is started by the `commission pair` command.
+
+In order to pair a device you need to specify the pairing-code which is printed on the device QR-Code as parameter pairing-code: `commission pair --pairing-code 123456789`. This is the easiest way for all production devices.
+For development devices that use the matter standard discriminator and pin code the parameter con be omitted or more details can be provided as parameters (see `commission pair --help` for more details).
+
+If the device should be commissioned via BLE because it is not yet in the IP network you can add the `--ble` parameter. This will start the BLE advertisement and the device can be paired via BLE. BLE is only available when the shell was started with the `--ble` parameter!
+When commissioning a device via BLE you also need to setup wifi or thread credentials (based on the device type) that are then used in the commissioning process. This can be done using the `config wifi-credentials` or `config thread-credentials` commands.
+IMPORTANT: These credentials are stored unencrypted in the filesystem!
+
+You can also define the node id to pair the device by providing this ID as parameter `commission pair 5000`.
+
+You can commission multiple nodes to the controller.
+
+After a successfull commissioning the shell outputs the device name and some information and automatically described to the node and logs potential updates.
+
+### List commissioned nodes
+
+The list of nodes can be listed using `nodes list` command. This will list all nodes that are currently commissioned to the controller and provides some information stored in the controller like name, node-id and a copy of the Basic Information cluster details and latest MDNS discovery data.
+
+### Connect to a node
+
+When fresh starting the shell it do not connect to the commissioned nodes automatically.
+
+Using `nodes connect` the shell tries to connect to all commissioned nodes. Alternatively you can provide a node-id to connect to a specific node (`nodes connect 5000`).
+
+Additional parameters to the connect command are the subscription delays (min/max). So if you want to make sure you get data subscribed use `nodes connect 5000 <min> <max>` with values in seconds.
+
+### Log a Node structure
+
+To see the full node structure of a node you can use the `nodes log` command and provide the node-id as parameter (`nodes log 5000`).
+
+### Commissioning related node operations
+
+To open a commissioning window on a node to allow an additional pairing use `commission open-enhanced-window <node-id>`. When the command was successful the shell outputs the pairing code and a QR code to scan with the relevant pairing App.
+
+To unpair a node use `commission unpair <node-id>`. This will remove the node from the controller and also remove the node from the persistent storage.
+
+### Interact with the node using Attributes, Events and Commands
+
+The shell supports reading and writing attributes (top level command `attributes` or `a` as alias), reading events (`events`/`e`) and invoking commands (`commands`/`c`) on the node. Below these top level commands the full list of the officially defined clusters is available to be used. See the help for the relevant cluster for more details.
+
+For reading attributes also a bulk read for all attributes is supported and with the `by-id` variant you can read and attribute from any cluster including custom clusters.
+Attribute reads are done locally (when connected with a subscription and attribute is subscribable) by default. For remote reads (always from the node) add the `--remote` parameter. Unknown attributes or attributes from unknown clusters are always read remotely.
+
+Writing attributes and executing commands (when the request requires data) these can be provided as JSON when it is no simple type. The shell will try to parse the JSON and send the data to the node. Binary data and Numbers >56bit needs to be provided as strings in this JSON and are automatically converted.
+For convenience reasons any number in the value to write or invoke data can be provided as hex string by prefixing it with `0x` (e.g. `"0x1234"`) and is then also converted automatically.
+When sending complex JSON content ideally use single quotes around the json because double quotes are used to define the JSON content.
+
+Some examples:
+
+-   `attributes basicinformation read all 5000 0` reads all attributes from the Basic Information cluster from node 5000 endpoint 0 (reads values locally when connected with subscription, else remote)
+-   `attributes basicinformation read all 5000 0 --remote` reads all attributes from the Basic Information cluster from node 5000 endpoint 0 always from remote (also when connected with a subscription)
+-   `attributes basicinformation read nodelabel 5000 0` reads the attribute "nodelabel" from the Basic Information cluster from node 5000 endpoint 0
+-   `attributes basicinformation read 0x5 5000 0` reads the attribute "nodelabel" (aliased with it's hex attribute id) from the Basic Information cluster from node 5000 endpoint 0
+-   `attributes by-id 0x28 read 0x5 5000 0` also reads the attribute "nodelabel" from the Basic Information cluster from node 5000 endpoint 0, but as generic read from the cluster with id 0x28 (also the decimal value 40 can be used)
+-   `attributes basicinformation write nodelabel "My Node" 5000 0` writes the value "My Node" to the attribute "nodelabel" from the Basic Information cluster from node 5000 endpoint 0. Instead of nodelabel also 0x5 as alias can be used.
+-   `attributes binding write binding '[{"node": "4568118954124746267" , "cluster": 6 , "endpoint": 1 }]' 5000 1` writes the binding array to the Binding cluster from node 5000 endpoint 1 to create a binding for node 4568118954124746267 to cluster 6 on endpoint 1. Note that the 64bit Node-id (4568118954124746267) needs to be provided as string because it is too big for a number.
+-   `attributes binding write binding '[{"node": "4568118954124746267" , "cluster": "0x6" , "endpoint": 1 }]' 5000 1` writes the same binding array as abobe but uses a hex string for the cluster id in the json data
+-   `events basicinformation startup 5000 0` reads the details from the startup event from the Basic Information cluster from node 5000 endpoint 0
+-   `commands onoff toggle 5000 1` executes the "toggle" command on the OnOff cluster from node 5000 endpoint 1
+-   `commands onoff offwitheffect '{"effectIdentifier":0,"effectVariant":0}' 5000 1` executes the "offwitheffect" command on the OnOff cluster from node 5000 endpoint 1 with the given JSON data
+
+### exit
+
+Exit the shell terminal.
+
+```
+> exit
+Goodbye
+```
+
+# Running multiple instances
+
+The matter shell app uses the `node-localstorage` package to persistently store configuration data of each node on disk. In order to run multiple nodes on one machine, start each node with their own `nodenum` so each will create and use their own `.matter-shell-#` directory and use different ports for communication where `#` is the `nodenum` passed from the commandline.
+
+```
+# From matter-node-shell top-level
+npm shell 1
+
+# In different terminal
+npm shell 2
+```
+
+To delete node state, i.e. factory reset, just delete the `.matter-shell-#` directory of the node:
+
+```
+rm -fr .matter-shell-2
+```
+
+The contents of the `.matter-shell-#` directory are human-readable, where each field in the key/value store is a separate file in ascii format:
+
+```
+$ ls .matter-shell-1
+0.MatterController.fabric			0.SessionManager.resumptionRecords
+0.MatterController.fabricCommissioned		Node.discriminator
+0.MatterController.operationalIpServerAddress	Node.ip
+0.RootCertificateManager.nextCertificateId	Node.longDiscriminator
+0.RootCertificateManager.rootCertBytes		Node.pin
+0.RootCertificateManager.rootCertId		Node.port
+0.RootCertificateManager.rootKeyIdentifier	Node.shortDiscriminator
+0.RootCertificateManager.rootKeyPair
+
+$ more .matter-shell-1/Node.ip
+"fe80::148d:9bd8:5006:243%en0"
+```
+
+```
+          █
+          █
+      ▄   █   ▄
+      ▀▀█████▀▀
+    ▀█▄       ▄█▀
+      ▀█▄   ▄█▀
+   ▄██▀▀█   █▀▀██▄
+  ▀▀    █   █    ▀▀
+```

package/dist/cjs/MatterNode.js

@@ -0,0 +1,115 @@
+"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 MatterNode_exports = {};
+__export(MatterNode_exports, {
+  MatterNode: () => MatterNode
+});
+module.exports = __toCommonJS(MatterNode_exports);
+var import_general = require("@matter/general");
+var import_nodejs = require("@matter/nodejs");
+var import_matter = require("@project-chip/matter.js");
+var import_datatype = require("@project-chip/matter.js/datatype");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("Node");
+class MatterNode {
+  constructor(nodeNum, netInterface) {
+    this.nodeNum = nodeNum;
+    this.netInterface = netInterface;
+  }
+  storageLocation;
+  storage;
+  storageManager;
+  storageContext;
+  commissioningController;
+  matterController;
+  async initialize(resetStorage) {
+    this.storageLocation = `.matter-shell-${this.nodeNum}`;
+    this.storage = new import_nodejs.StorageBackendDisk(this.storageLocation, false);
+    logger.info(`Storage location: ${this.storageLocation} (Directory)`);
+    this.storageManager = new import_general.StorageManager(this.storage);
+    await this.storageManager.initialize();
+    this.storageContext = this.storageManager.createContext("Node");
+    if (resetStorage) {
+      this.storage.clearAll([]);
+    }
+  }
+  get Store() {
+    if (!this.storageContext) {
+      throw new Error("Storage uninitialized");
+    }
+    return this.storageContext;
+  }
+  async close() {
+    await this.matterController?.close();
+    this.closeStorage();
+  }
+  closeStorage() {
+    try {
+      this.storage?.close();
+      process.exit(0);
+    } catch {
+      process.exit(1);
+    }
+  }
+  async start() {
+    if (this.storageManager === void 0) {
+      throw new Error("StorageManager not initialized");
+    }
+    if (this.matterController !== void 0) {
+      return;
+    }
+    logger.info(`matter.js shell controller started for node ${this.nodeNum}`);
+    this.matterController = new import_matter.MatterServer(this.storageManager, { mdnsInterface: this.netInterface });
+    this.commissioningController = new import_matter.CommissioningController({
+      autoConnect: false
+    });
+    await this.matterController.addCommissioningController(this.commissioningController);
+    await this.matterController.start();
+  }
+  async connectAndGetNodes(nodeIdStr, connectOptions) {
+    await this.start();
+    const nodeId = nodeIdStr !== void 0 ? (0, import_datatype.NodeId)(BigInt(nodeIdStr)) : void 0;
+    if (this.commissioningController === void 0) {
+      throw new Error("CommissioningController not initialized");
+    }
+    let nodes;
+    if (nodeId === void 0) {
+      nodes = await this.commissioningController.connect(connectOptions);
+    } else {
+      nodes = [await this.commissioningController.connectNode((0, import_datatype.NodeId)(nodeId), connectOptions)];
+    }
+    return nodes;
+  }
+  async iterateNodeDevices(nodes, callback, endpointId) {
+    for (const node of nodes) {
+      let devices = node.getDevices();
+      if (endpointId !== void 0) {
+        devices = devices.filter((device) => device.number === endpointId);
+      }
+      for (const device of devices) {
+        await callback(device, node);
+      }
+    }
+  }
+}
+//# sourceMappingURL=MatterNode.js.map

package/dist/cjs/MatterNode.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/MatterNode.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,qBAAuD;AACvD,oBAAmC;AACnC,oBAAsD;AACtD,sBAAuB;AAVvB;AAAA;AAAA;AAAA;AAAA;AAcA,MAAM,SAAS,sBAAO,IAAI,MAAM;AAEzB,MAAM,WAAW;AAAA,EASpB,YACqB,SACA,cACnB;AAFmB;AACA;AAAA,EAClB;AAAA,EAXK;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAER;AAAA,EACQ;AAAA,EAOR,MAAM,WAAW,cAAuB;AAQpC,SAAK,kBAAkB,iBAAiB,KAAK,OAAO;AACpD,SAAK,UAAU,IAAI,iCAAmB,KAAK,iBAAiB,KAAK;AACjE,WAAO,KAAK,qBAAqB,KAAK,eAAe,cAAc;AACnE,SAAK,iBAAiB,IAAI,8BAAe,KAAK,OAAO;AACrD,UAAM,KAAK,eAAe,WAAW;AACrC,SAAK,iBAAiB,KAAK,eAAe,cAAc,MAAM;AAC9D,QAAI,cAAc;AACd,WAAK,QAAQ,SAAS,CAAC,CAAC;AAAA,IAC5B;AAAA,EACJ;AAAA,EAEA,IAAI,QAAQ;AACR,QAAI,CAAC,KAAK,gBAAgB;AACtB,YAAM,IAAI,MAAM,uBAAuB;AAAA,IAC3C;AACA,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,MAAM,QAAQ;AACV,UAAM,KAAK,kBAAkB,MAAM;AACnC,SAAK,aAAa;AAAA,EACtB;AAAA,EAEA,eAAe;AACX,QAAI;AACA,WAAK,SAAS,MAAM;AACpB,cAAQ,KAAK,CAAC;AAAA,IAClB,QAAQ;AACJ,cAAQ,KAAK,CAAC;AAAA,IAClB;AAAA,EACJ;AAAA,EAEA,MAAM,QAAQ;AACV,QAAI,KAAK,mBAAmB,QAAW;AACnC,YAAM,IAAI,MAAM,gCAAgC;AAAA,IACpD;AACA,QAAI,KAAK,qBAAqB,QAAW;AACrC;AAAA,IACJ;AACA,WAAO,KAAK,+CAA+C,KAAK,OAAO,EAAE;AAezE,SAAK,mBAAmB,IAAI,2BAAa,KAAK,gBAAgB,EAAE,eAAe,KAAK,aAAa,CAAC;AAClG,SAAK,0BAA0B,IAAI,sCAAwB;AAAA,MACvD,aAAa;AAAA,IACjB,CAAC;AACD,UAAM,KAAK,iBAAiB,2BAA2B,KAAK,uBAAuB;AASnF,UAAM,KAAK,iBAAiB,MAAM;AAAA,EACtC;AAAA,EAEA,MAAM,mBAAmB,WAAoB,gBAAqD;AAC9F,UAAM,KAAK,MAAM;AACjB,UAAM,SAAS,cAAc,aAAY,wBAAO,OAAO,SAAS,CAAC,IAAI;AAErE,QAAI,KAAK,4BAA4B,QAAW;AAC5C,YAAM,IAAI,MAAM,yCAAyC;AAAA,IAC7D;AACA,QAAI;AACJ,QAAI,WAAW,QAAW;AACtB,cAAQ,MAAM,KAAK,wBAAwB,QAAQ,cAAc;AAAA,IACrE,OAAO;AACH,cAAQ,CAAC,MAAM,KAAK,wBAAwB,gBAAY,wBAAO,MAAM,GAAG,cAAc,CAAC;AAAA,IAC3F;AACA,WAAO;AAAA,EACX;AAAA,EAEA,MAAM,mBACF,OACA,UACA,YACF;AACE,eAAW,QAAQ,OAAO;AACtB,UAAI,UAAU,KAAK,WAAW;AAC9B,UAAI,eAAe,QAAW;AAC1B,kBAAU,QAAQ,OAAO,YAAU,OAAO,WAAW,UAAU;AAAA,MACnE;AAEA,iBAAW,UAAU,SAAS;AAC1B,cAAM,SAAS,QAAQ,IAAI;AAAA,MAC/B;AAAA,IACJ;AAAA,EACJ;AACJ;",
+  "names": []
+}