@itwin/presentation-hierarchies 2.0.0-alpha.12 → 2.0.0-alpha.13

package/lib/esm/hierarchies/HierarchySearch.d.ts

@@ -1,70 +1,52 @@
 import { HierarchyNodeIdentifier } from "./HierarchyNodeIdentifier.js";
-import { HierarchyNodeKey } from "./HierarchyNodeKey.js";
 import type { NonGroupingHierarchyNode } from "./HierarchyNode.js";
 import type { HierarchyNodeIdentifiersPath } from "./HierarchyNodeIdentifier.js";
 import type { GenericNodeKey, InstancesNodeKey } from "./HierarchyNodeKey.js";
 /** @public */
-export interface SearchPathRevealDepthInPath {
-    /**
-     * Index of the node in search path should be revealed in hierarchy by auto-expanding its ancestors.
-     *
-     * Use when you want to expand up to specific instance node and don't care about grouping nodes.
-     *
-     * **Use case example:**
-     *
-     * All nodes up to `Element1` should be expanded in the following hierarchy:
-     * - Node1
-     *   - GroupingNode1
-     *     - GroupingNode2
-     *       - Element1
-     *       - Element2
-     *
-     * Provide `{ path: [Node1, Element1], reveal: { depthInPath: 1 } }`
-     *
-     * **NOTE**: All nodes that are up to `depthInPath` will be expanded **except** search targets.
-     */
-    depthInPath: number;
-}
-/** @public */
-export interface SearchPathRevealDepthInHierarchy {
-    /**
-     * Considering the list of nodes from root to the target node, this is an index in that list, identifying the node that should be revealed in hierarchy by auto-expanding its ancestors.
-     *
-     * This should take into account the number of grouping nodes in hierarchy.
-     *
-     * **Use case example:**
-     *
-     * Only `Node1` and `GroupingNode1` should have `autoExpand` flag in the following hierarchy:
-     * - Node1
-     *   - GroupingNode1
-     *     - GroupingNode2
-     *       - Element1
-     *       - Element2
-     *
-     * Provide `{ path: [Node1, Element1], reveal: { depthInHierarchy: 2 } }`
-     *
-     * To get the correct depth use `HierarchyNode.parentKeys.length`.
-     *
-     * **NOTE**: All nodes that are up to `depthInHierarchy` will be expanded **except** search targets.
-     */
-    depthInHierarchy: number;
-}
-/** @public */
 export interface HierarchySearchPathOptions {
     /**
      * This option specifies the way `autoExpand` flag should be assigned to nodes in the searched hierarchy.
      * - If it's `false` or `undefined`, nodes have no 'autoExpand' flag.
      * - If it's `true`, then all nodes up to the search target will have `autoExpand` flag.
-     * - If it's an instance of `SearchPathRevealDepthInPath`, then all nodes up to `depthInPath` will have `autoExpand` flag.
-     * - If it's an instance of `SearchPathRevealDepthInHierarchy`, then all nodes up to `depthInHierarchy` will have `autoExpand` flag.
+     * - If it's a object with `groupingLevel` then `groupingLevel` determines the number of grouping levels to expand for
+     * the search target.
      */
-    reveal?: boolean | SearchPathRevealDepthInHierarchy | SearchPathRevealDepthInPath;
+    reveal?: boolean | {
+        /**
+         * Index of the node in search path should be revealed in hierarchy by auto-expanding its ancestors.
+         *
+         * Use when you want to expand up to specific instance node and don't care about grouping nodes.
+         *
+         * **Use case example:**
+         *
+         * All nodes up to `Element1` should be expanded in the following hierarchy:
+         * - Node1
+         *   - GroupingNode1
+         *     - GroupingNode2
+         *       - Element1
+         *       - Element2
+         *
+         * Provide `{ path: [Node1, Element1], reveal: { depthInPath: 1 } }`
+         *
+         * **NOTE**: All nodes that are up to `depthInPath` will be expanded **except** search targets.
+         */
+        depthInPath: number;
+    } | {
+        /**
+         * The number of grouping levels to expand for the search target. For example, if `groupingLevel` is set to `2`, then all grouping nodes up to the second level
+         * will have the `autoExpand` flag.
+         *
+         * **Note:** if search target has less grouping levels than specified by this attribute, then all grouping nodes up to the search target will have
+         * the `autoExpand` flag, but the search target itself won't have the `autoExpand` flag.
+         */
+        groupingLevel: number;
+    };
     /**
      * This option specifies whether or not search target should be expanded.
      * - If it's `false` or `undefined`, search target won't have 'autoExpand' flag.
      * - If it's `true`, search target will have `autoExpand` flag.
      *
-     * **NOTE**: this attribute does not set `autoExpand` flag on nodes up to the search target. For that use `reveal`.
+     * **Note:** this attribute does not set `autoExpand` flag on nodes up to the search target. For that use `reveal`.
      */
     autoExpand?: boolean;
 }
@@ -91,20 +73,164 @@ export declare namespace HierarchySearchPath {
      * - else if only one of the inputs is an object, return it,
      * - else if both inputs are falsy, return `false` or `undefined`,
      * - else:
-     *    - if only one of the inputs has `depthInHierarchy` set, return the other one,
-     *    - else return the one with greater `depthInPath` or `depthInHierarchy`.
+     *    - if only one of the inputs has `groupingLevel` set, return that one,
+     *    - else compare by matching reveal type (`groupingLevel` or `depthInPath`) and return the deeper one.
      *
      * @public
      */
     function mergeOptions(lhs: HierarchySearchPathOptions | undefined, rhs: HierarchySearchPathOptions | undefined): HierarchySearchPathOptions | undefined;
 }
+/**
+ * A tree structure representing hierarchy search paths. Each node in the tree corresponds
+ * to a hierarchy node identifier and may have children that represent deeper levels in the
+ * hierarchy.
+ *
+ * The `HierarchySearchTree.createBuilder` or `HierarchySearchTree.createFromPathsList` are
+ * typically used create this tree from a flat list of search paths.
+ *
+ * @public
+ */
+export interface HierarchySearchTree {
+    /** Identifier of the hierarchy node this tree entry represents. */
+    identifier: HierarchyNodeIdentifier;
+    /**
+     * When `true`, indicates that this node is a search target.
+     *
+     * Note: A `HierarchySearchTree` node is considered a search target if it has no children, even if `isTarget` is not explicitly set to `true`. This
+     * is because a node with no children represents the end of a search path.
+     */
+    isTarget?: boolean;
+    /** Provides options for handling this search tree entry, such as auto-expansion behavior. */
+    options?: {
+        /**
+         * - `true` to expand the node and its grouping nodes,
+         * - `{ groupingLevel: number }` to expand ancestor grouping nodes, e.g. for the following hierarchy:
+         *   ```
+         *   - Grouping node A
+         *     - Instance node A
+         *       - Grouping node B1
+         *         - Grouping node B2
+         *           - ...
+         *             - Grouping node Bn
+         *               - Instance node B
+         *   ```
+         *
+         *   For "Instance node B" search tree entry:
+         *   - `{ groupingLevel: 1 }` expands its first grouping node "Grouping node B1",
+         *   - `{ groupingLevel: 2 }` expands two levels to "Grouping node B2".
+         *   - `{ groupingLevel: Number.MAX_SAFE_INTEGER }` expands all grouping nodes of that instance node.
+         *
+         *   Note that there's a slight difference between `HierarchySearchTree.options.autoExpand` and
+         *   `HierarchySearchPath.options.reveal`. The latter option reveals the search target node by expanding its ancestors,
+         *   while the `HierarchySearchTree.options.autoExpand` also expands the target node itself.
+         */
+        autoExpand?: boolean | {
+            groupingLevel: number;
+        };
+    };
+    /** Child search tree entries representing the next level(s) in the hierarchy search paths. */
+    children?: HierarchySearchTree[];
+}
+/** @public */
+export declare namespace HierarchySearchTree {
+    /** @public */
+    type HierarchySearchTreeBuilderAcceptHandlerTreeEntry<TExtras extends Record<string, unknown>> = Readonly<Pick<HierarchySearchTree, "identifier" | "options"> & {
+        extras: TExtras;
+    }> & Pick<HierarchySearchTree, "isTarget">;
+    /** @public */
+    type HierarchySearchTreeBuilderAcceptHandlerTreeInput = Readonly<Pick<HierarchySearchTree, "identifier" | "isTarget" | "options"> & {
+        hasChildren: boolean;
+    }>;
+    /** @public */
+    interface HierarchySearchTreeBuilderAcceptHandler<TExtras extends Record<string, unknown>> {
+        /**
+         * Called when a new entry is added to the tree. Return `true` to accept the entry, `false` to reject it and all its children, if any.
+         */
+        onNewEntry?: (props: {
+            /** The parent entries of the new entry being added, from root to immediate parent. It's allowed to mutate these entries. */
+            parentEntries: Array<HierarchySearchTreeBuilderAcceptHandlerTreeEntry<TExtras>>;
+            /** The new entry being added to the tree. */
+            inputEntry: HierarchySearchTreeBuilderAcceptHandlerTreeInput;
+        }) => boolean;
+        /**
+         * Called when a new entry is added to the tree and accepted (either it's a new entry or it merges with an existing entry). This can be used to perform
+         * side effects such as assigning extra information to the tree entry.
+         */
+        onEntryHandled?: (props: {
+            /** The parent entries of the new entry being added, from root to immediate parent. It's allowed to mutate these entries. */
+            parentEntries: Array<HierarchySearchTreeBuilderAcceptHandlerTreeEntry<TExtras>>;
+            /** The tree entry that has been handled. It's allowed to mutate this entry. */
+            treeEntry: HierarchySearchTreeBuilderAcceptHandlerTreeEntry<TExtras>;
+            /** The input entry being added to the tree. */
+            inputEntry: HierarchySearchTreeBuilderAcceptHandlerTreeInput;
+        }) => void;
+    }
+    /** @public */
+    type HierarchySearchTreeBuilderAcceptProps<TAcceptHandlerExtras extends Record<string, unknown>> = ({
+        path: HierarchySearchPath;
+    } | {
+        tree: HierarchySearchTree;
+    }) & {
+        /** An optional handler for customizing the behavior of the builder when accepting new entries. */
+        handler?: HierarchySearchTreeBuilderAcceptHandler<TAcceptHandlerExtras>;
+    };
+    /**
+     * An utility that accepts hierarchy search paths or search trees one by one and builds a `HierarchySearchTree` structure based on them.
+     * @public
+     */
+    interface HierarchySearchTreeBuilder<TAcceptHandlerExtras extends Record<string, unknown>> {
+        /**
+         * Accepts a hierarchy search path or paths' tree and adds it to the builder's internal tree structure. Use `getTree()` to create
+         * a `HierarchySearchTree[]` from the added paths.
+         */
+        accept(props: HierarchySearchTreeBuilderAcceptProps<TAcceptHandlerExtras>): HierarchySearchTreeBuilder<TAcceptHandlerExtras>;
+        /**
+         * Create `HierarchySearchTree[]` from currently added search paths.
+         */
+        getTree(): HierarchySearchTree[];
+    }
+    /**
+     * Create a `HierarchySearchTree` builder utility that accepts hierarchy search paths or search trees one by one and builds
+     * a `HierarchySearchTree` structure based on them.
+     *
+     * Usage example:
+     *
+     * ```ts
+     * const builder = HierarchySearchTree.createBuilder();
+     * for (const path of searchPaths) {
+     *   builder.accept({ path });
+     * }
+     * const searchTree = builder.getTree();
+     * ```
+     *
+     * @public
+     */
+    export function createBuilder<TAcceptHandlerExtras extends Record<string, unknown> = Record<string, unknown>>(): HierarchySearchTreeBuilder<TAcceptHandlerExtras>;
+    /**
+     * Builds a list of `HierarchySearchTree` nodes from an iterable of search paths. Shared
+     * path prefixes are merged so that each unique hierarchy node identifier appears only once
+     * per level. The resulting trees carry `isTarget`, `options`, and `children` attributes
+     * derived from the paths and their options (`autoExpand`, `reveal`).
+     *
+     * @public
+     */
+    export function createFromPathsList(paths: Iterable<HierarchySearchPath>): Promise<HierarchySearchTree[]>;
+    /**
+     * Merges two `HierarchySearchTree` option objects. For the `autoExpand` attribute,
+     * `true` takes precedence over `{ groupingLevel }`, and when both sides are
+     * `{ groupingLevel }` objects the larger value wins.
+     * @public
+     */
+    export function mergeOptions(lhs: HierarchySearchTree["options"] | undefined, rhs: HierarchySearchTree["options"] | undefined): HierarchySearchTree["options"] | undefined;
+    export {};
+}
 /**
  * Creates a set of utilities for making it easier to search the given hierarchy
  * level.
  *
  * @public
  */
-export declare function createHierarchySearchHelper(rootLevelSearchProps: HierarchySearchPath[] | undefined, parentNode: Pick<NonGroupingHierarchyNode, "search"> | undefined): {
+export declare function createHierarchySearchHelper(rootLevelSearchProps: HierarchySearchTree[] | undefined, parentNode: Pick<NonGroupingHierarchyNode, "search"> | undefined): {
     /** Returns a flag indicating if the hierarchy level is filtered. */
     hasSearch: boolean;
     /**
@@ -129,41 +255,21 @@ export declare function createHierarchySearchHelper(rootLevelSearchProps: Hierar
      * `nodeKey` prop can be used to check the whole identifier.
      *
      * There are multiple overloads of `createChildNodeProps`: depending on props type it returns different values:
-     * - `parentKeys` is defined and `pathMatcher` or `nodeKey` is provided - returns undefined **or** `search` and `autoExpand` prop from `HierarchyNode`;
-     * - `parentKeys` is undefined - does not return `HierarchyNode.autoExpand` option;
-     * - props have `asyncPathMatcher` - returns either Promise or the regular return value based on whether or not `asyncPathMatcher` returns a promise.
+     * - `asyncPathMatcher` is provided - returns either Promise or the regular return value based on whether or not `asyncPathMatcher` returns a `Promise`.
+     * - `pathMatcher` or only `nodeKey` is provided - returns undefined **or** `search` and `autoExpand` prop from `HierarchyNode`;
      */
     createChildNodeProps: {
         (props: {
-            parentKeys?: undefined;
-            nodeKey: InstancesNodeKey | GenericNodeKey;
-        }): Pick<NonGroupingHierarchyNode, "search"> | undefined;
-        (props: {
-            parentKeys?: undefined;
-            pathMatcher: (identifier: HierarchyNodeIdentifier) => boolean;
-        }): Pick<NonGroupingHierarchyNode, "search"> | undefined;
-        (props: {
-            parentKeys?: undefined;
-            asyncPathMatcher: (identifier: HierarchyNodeIdentifier) => boolean | Promise<boolean>;
-        }): Promise<Pick<NonGroupingHierarchyNode, "search"> | undefined> | Pick<NonGroupingHierarchyNode, "search"> | undefined;
-        (props: {
-            parentKeys: HierarchyNodeKey[];
             nodeKey: InstancesNodeKey | GenericNodeKey;
         }): Pick<NonGroupingHierarchyNode, "search" | "autoExpand"> | undefined;
         (props: {
-            parentKeys: HierarchyNodeKey[];
+            nodeKey: InstancesNodeKey | GenericNodeKey;
             pathMatcher: (identifier: HierarchyNodeIdentifier) => boolean;
         }): Pick<NonGroupingHierarchyNode, "search" | "autoExpand"> | undefined;
         (props: {
-            parentKeys: HierarchyNodeKey[];
+            nodeKey: InstancesNodeKey | GenericNodeKey;
             asyncPathMatcher: (identifier: HierarchyNodeIdentifier) => boolean | Promise<boolean>;
         }): Promise<Pick<NonGroupingHierarchyNode, "search" | "autoExpand"> | undefined> | Pick<NonGroupingHierarchyNode, "search" | "autoExpand"> | undefined;
     };
 };
-/** @internal */
-export declare function shouldAutoExpandBasedOnReveal({ reveal, nodePositionInPath, nodePositionInHierarchy, }: {
-    reveal: HierarchySearchPathOptions["reveal"];
-    nodePositionInPath: number;
-    nodePositionInHierarchy: number;
-}): boolean;
 //# sourceMappingURL=HierarchySearch.d.ts.map

package/lib/esm/hierarchies/HierarchySearch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HierarchySearch.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchySearch.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9E,cAAc;AACd,MAAM,WAAW,2BAA2B;IAC1C;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,cAAc;AACd,MAAM,WAAW,gCAAgC;IAC/C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,cAAc;AACd,MAAM,WAAW,0BAA0B;IACzC;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,gCAAgC,GAAG,2BAA2B,CAAC;IAClF;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAuCD;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,4BAA4B,GAAG;IAAE,IAAI,EAAE,4BAA4B,CAAC;IAAC,OAAO,CAAC,EAAE,0BAA0B,CAAA;CAAE,CAAC;AAC9I,cAAc;AAEd,yBAAiB,mBAAmB,CAAC;IACnC;;;OAGG;IACH,SAAgB,SAAS,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,EAAE,4BAA4B,CAAC,CAKjH;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,YAAY,CAC1B,GAAG,EAAE,0BAA0B,GAAG,SAAS,EAC3C,GAAG,EAAE,0BAA0B,GAAG,SAAS,GAC1C,0BAA0B,GAAG,SAAS,CASxC;CACF;AAwBD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,oBAAoB,EAAE,mBAAmB,EAAE,GAAG,SAAS,EACvD,UAAU,EAAE,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GAAG,SAAS;IAiI9D,oEAAoE;;IAEpE;;;;;OAKG;;IAEH;;;OAGG;;IAUH;;;;;;;;;;;;;OAaG;;gBA3FgC;YACnC,UAAU,CAAC,EAAE,SAAS,CAAC;YACvB,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAAC;SAC5C,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GAAG,SAAS;gBACnB;YACnC,UAAU,CAAC,EAAE,SAAS,CAAC;YACvB,WAAW,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,CAAC;SAC/D,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GAAG,SAAS;gBACnB;YACnC,UAAU,CAAC,EAAE,SAAS,CAAC;YACvB,gBAAgB,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;SACvF,GAAG,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GAAG,SAAS;gBACnF;YACnC,UAAU,EAAE,gBAAgB,EAAE,CAAC;YAC/B,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAAC;SAC5C,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS;gBAClC;YACnC,UAAU,EAAE,gBAAgB,EAAE,CAAC;YAC/B,WAAW,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,CAAC;SAC/D,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS;gBAClC;YACnC,UAAU,EAAE,gBAAgB,EAAE,CAAC;YAC/B,gBAAgB,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;SACvF,GAAG,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS;;EAuEvJ;AA0DD,gBAAgB;AAChB,wBAAgB,6BAA6B,CAAC,EAC5C,MAAM,EACN,kBAAkB,EAClB,uBAAuB,GACxB,EAAE;IACD,MAAM,EAAE,0BAA0B,CAAC,QAAQ,CAAC,CAAC;IAC7C,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uBAAuB,EAAE,MAAM,CAAC;CACjC,GAAG,OAAO,CAWV"}
+{"version":3,"file":"HierarchySearch.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchySearch.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAIvE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,8BAA8B,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9E,cAAc;AACd,MAAM,WAAW,0BAA0B;IACzC;;;;;;OAMG;IACH,MAAM,CAAC,EACH,OAAO,GACP;QACE;;;;;;;;;;;;;;;;;WAiBG;QACH,WAAW,EAAE,MAAM,CAAC;KACrB,GACD;QACE;;;;;;WAMG;QACH,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IACN;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,4BAA4B,GAAG;IAAE,IAAI,EAAE,4BAA4B,CAAC;IAAC,OAAO,CAAC,EAAE,0BAA0B,CAAA;CAAE,CAAC;AAC9I,cAAc;AAEd,yBAAiB,mBAAmB,CAAC;IACnC;;;OAGG;IACH,SAAgB,SAAS,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,EAAE,4BAA4B,CAAC,CAKjH;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,YAAY,CAC1B,GAAG,EAAE,0BAA0B,GAAG,SAAS,EAC3C,GAAG,EAAE,0BAA0B,GAAG,SAAS,GAC1C,0BAA0B,GAAG,SAAS,CASxC;CA2BF;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,mEAAmE;IACnE,UAAU,EAAE,uBAAuB,CAAC;IAEpC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,6FAA6F;IAC7F,OAAO,CAAC,EAAE;QACR;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,UAAU,CAAC,EAAE,OAAO,GAAG;YAAE,aAAa,EAAE,MAAM,CAAA;SAAE,CAAC;KAClD,CAAC;IAEF,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,mBAAmB,EAAE,CAAC;CAClC;AAED,cAAc;AACd,yBAAiB,mBAAmB,CAAC;IACnC,cAAc;IACd,KAAK,gDAAgD,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,QAAQ,CACvG,IAAI,CAAC,mBAAmB,EAAE,YAAY,GAAG,SAAS,CAAC,GAAG;QACpD,MAAM,EAAE,OAAO,CAAC;KACjB,CACF,GACC,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,CAAC;IACxC,cAAc;IACd,KAAK,gDAAgD,GAAG,QAAQ,CAAC,IAAI,CAAC,mBAAmB,EAAE,YAAY,GAAG,UAAU,GAAG,SAAS,CAAC,GAAG;QAAE,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC9J,cAAc;IACd,UAAU,uCAAuC,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QACvF;;WAEG;QACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE;YACnB,4HAA4H;YAC5H,aAAa,EAAE,KAAK,CAAC,gDAAgD,CAAC,OAAO,CAAC,CAAC,CAAC;YAChF,6CAA6C;YAC7C,UAAU,EAAE,gDAAgD,CAAC;SAC9D,KAAK,OAAO,CAAC;QACd;;;WAGG;QACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE;YACvB,4HAA4H;YAC5H,aAAa,EAAE,KAAK,CAAC,gDAAgD,CAAC,OAAO,CAAC,CAAC,CAAC;YAChF,+EAA+E;YAC/E,SAAS,EAAE,gDAAgD,CAAC,OAAO,CAAC,CAAC;YACrE,+CAA+C;YAC/C,UAAU,EAAE,gDAAgD,CAAC;SAC9D,KAAK,IAAI,CAAC;KACZ;IACD,cAAc;IACd,KAAK,qCAAqC,CAAC,oBAAoB,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAC/F;QAAE,IAAI,EAAE,mBAAmB,CAAA;KAAE,GAC7B;QAAE,IAAI,EAAE,mBAAmB,CAAA;KAAE,CAChC,GAAG;QACF,kGAAkG;QAClG,OAAO,CAAC,EAAE,uCAAuC,CAAC,oBAAoB,CAAC,CAAC;KACzE,CAAC;IACF;;;OAGG;IACH,UAAU,0BAA0B,CAAC,oBAAoB,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QACvF;;;WAGG;QACH,MAAM,CAAC,KAAK,EAAE,qCAAqC,CAAC,oBAAoB,CAAC,GAAG,0BAA0B,CAAC,oBAAoB,CAAC,CAAC;QAC7H;;WAEG;QACH,OAAO,IAAI,mBAAmB,EAAE,CAAC;KAClC;IAED;;;;;;;;;;;;;;;OAeG;IACH,MAAM,UAAU,aAAa,CAC3B,oBAAoB,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC3E,0BAA0B,CAAC,oBAAoB,CAAC,CA6MpD;IAED;;;;;;;OAOG;IACH,gBAAsB,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,mBAAmB,CAAC,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAQ9G;IAED;;;;;OAKG;IACH,MAAM,UAAU,YAAY,CAC1B,GAAG,EAAE,mBAAmB,CAAC,SAAS,CAAC,GAAG,SAAS,EAC/C,GAAG,EAAE,mBAAmB,CAAC,SAAS,CAAC,GAAG,SAAS,GAC9C,mBAAmB,CAAC,SAAS,CAAC,GAAG,SAAS,CAY5C;;CAcF;AAwBD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,oBAAoB,EAAE,mBAAmB,EAAE,GAAG,SAAS,EACvD,UAAU,EAAE,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GAAG,SAAS;IAsG9D,oEAAoE;;IAEpE;;;;;OAKG;;IAEH;;;OAGG;;IAOH;;;;;;;;;;;;OAYG;;gBApEgC;YAAE,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAAA;SAAE,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS;gBACpH;YACnC,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAAC;YAC3C,WAAW,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,CAAC;SAC/D,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS;gBAClC;YACnC,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAAC;YAC3C,gBAAgB,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;SACvF,GAAG,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,wBAAwB,EAAE,QAAQ,GAAG,YAAY,CAAC,GAAG,SAAS;;EA+DvJ"}