@limble/limble-tree 1.0.0-alpha.2 → 1.0.0-beta.2

package/esm2020/lib/core/tree-node-base.mjs

@@ -1,4 +1,5 @@
 import { filter, Subject } from "rxjs";
+import { hasProperty } from "../../shared/has-property";
 import { TreeError } from "../errors";
 import { GraftEvent } from "../events/relational/graft-event";
 import { PruneEvent } from "../events/relational/prune-event";
@@ -37,6 +38,17 @@ export class TreeNodeBase {
     getBranch(index) {
         return this._branches[index];
     }
+    handleUserlandError(error) {
+        const message = hasProperty(error, "message")
+            ? error.message
+            : "Unknown error";
+        throw new TreeError(`Failed to grow branch: ${message}`, {
+            // This cast to `any` is due to an issue in typescript that has been
+            // resolved at least by version 4.9.5. When we upgrade our typescript
+            // version we can remove the cast.
+            cause: error
+        });
+    }
     isDestroyed() {
         return this.destroyed;
     }
@@ -66,4 +78,4 @@ export class TreeNodeBase {
         this._branches.splice(index, 0, child);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-node-base.js","sourceRoot":"","sources":["../../../../../projects/limble-tree/src/lib/core/tree-node-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { filter, Observable, Subject, Subscription } from \"rxjs\";\nimport { NodeComponent } from \"../components/node-component.interface\";\nimport { TreeError } from \"../errors\";\nimport { GraftEvent } from \"../events/relational/graft-event\";\nimport { PruneEvent } from \"../events/relational/prune-event\";\nimport { TreeEvent } from \"../structure/tree-event.interface\";\nimport { TreeNode } from \"../structure/tree-node.interface\";\nimport { TreePlot } from \"../structure/tree-plot\";\nimport { Relationship } from \"./relationship.interface\";\nimport { TreeBranch } from \"./tree-branch/tree-branch\";\n\nexport class TreeNodeBase<UserlandComponent>\n   implements Partial<TreeNode<TreeBranch<UserlandComponent>, NodeComponent>>\n{\n   private readonly _branches: Array<TreeBranch<UserlandComponent>>;\n   private readonly events$: Subject<TreeEvent>;\n   private destroyed: boolean = false;\n   private readonly subscriptions: Array<Subscription>;\n\n   public constructor() {\n      this._branches = [];\n      this.events$ = new Subject();\n      this.subscriptions = [\n         this.graftsToSelf().subscribe((event) => {\n            this.registerChildRelationship(event.child(), event.index());\n         }),\n         this.prunesToSelf().subscribe((event) => {\n            this.deregisterChildRelationship(event.child());\n         })\n      ];\n   }\n\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return [...this._branches];\n   }\n\n   public destroy(): void {\n      this.branches().forEach((branch) => {\n         branch.destroy();\n      });\n      this.subscriptions.forEach((sub) => {\n         sub.unsubscribe();\n      });\n      this.destroyed = true;\n   }\n\n   public dispatch(event: TreeEvent): void {\n      this.events$.next(event);\n   }\n\n   public events(): Observable<TreeEvent> {\n      return this.events$;\n   }\n\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this._branches[index];\n   }\n\n   public isDestroyed(): boolean {\n      return this.destroyed;\n   }\n\n   public plot(): TreePlot {\n      return new Map(\n         this.branches().map((branch, index) => [index, branch.plot()])\n      );\n   }\n\n   public traverse(\n      callback: (\n         node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      ) => void\n   ): void {\n      this.branches().forEach((branch) => {\n         branch.traverse(callback);\n      });\n   }\n\n   private deregisterChildRelationship(\n      child: TreeBranch<UserlandComponent>\n   ): void {\n      const index = this.branches().findIndex((branch) => branch === child);\n      this._branches.splice(index, 1);\n   }\n\n   private graftsToSelf(): Observable<\n      GraftEvent<Relationship<UserlandComponent>>\n   > {\n      return this.events().pipe(\n         filter(\n            (event): event is GraftEvent<Relationship<UserlandComponent>> =>\n               event instanceof GraftEvent\n         ),\n         filter((event) => event.parent().events() === this.events$)\n      );\n   }\n\n   private prunesToSelf(): Observable<\n      PruneEvent<Relationship<UserlandComponent>>\n   > {\n      return this.events().pipe(\n         filter(\n            (event): event is PruneEvent<Relationship<UserlandComponent>> =>\n               event instanceof PruneEvent\n         ),\n         filter((event) => event.parent().events() === this.events$)\n      );\n   }\n\n   private registerChildRelationship(\n      child: TreeBranch<UserlandComponent>,\n      index: number\n   ): void {\n      const branches = this.branches();\n      if (index < 0 || index > branches.length) {\n         throw new TreeError(\n            `Can't register child at index ${index}. Out of range.`\n         );\n      }\n      this._branches.splice(index, 0, child);\n   }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-node-base.js","sourceRoot":"","sources":["../../../../../projects/limble-tree/src/lib/core/tree-node-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { filter, Observable, Subject, Subscription } from \"rxjs\";\nimport { hasProperty } from \"../../shared/has-property\";\nimport { NodeComponent } from \"../components/node-component.interface\";\nimport { TreeError } from \"../errors\";\nimport { GraftEvent } from \"../events/relational/graft-event\";\nimport { PruneEvent } from \"../events/relational/prune-event\";\nimport { TreeEvent } from \"../structure/tree-event.interface\";\nimport { TreeNode } from \"../structure/tree-node.interface\";\nimport { TreePlot } from \"../structure/tree-plot\";\nimport { Relationship } from \"./relationship.interface\";\nimport { TreeBranch } from \"./tree-branch/tree-branch\";\n\nexport class TreeNodeBase<UserlandComponent>\n   implements Partial<TreeNode<TreeBranch<UserlandComponent>, NodeComponent>>\n{\n   private readonly _branches: Array<TreeBranch<UserlandComponent>>;\n   private readonly events$: Subject<TreeEvent>;\n   private destroyed: boolean = false;\n   private readonly subscriptions: Array<Subscription>;\n\n   public constructor() {\n      this._branches = [];\n      this.events$ = new Subject();\n      this.subscriptions = [\n         this.graftsToSelf().subscribe((event) => {\n            this.registerChildRelationship(event.child(), event.index());\n         }),\n         this.prunesToSelf().subscribe((event) => {\n            this.deregisterChildRelationship(event.child());\n         })\n      ];\n   }\n\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return [...this._branches];\n   }\n\n   public destroy(): void {\n      this.branches().forEach((branch) => {\n         branch.destroy();\n      });\n      this.subscriptions.forEach((sub) => {\n         sub.unsubscribe();\n      });\n      this.destroyed = true;\n   }\n\n   public dispatch(event: TreeEvent): void {\n      this.events$.next(event);\n   }\n\n   public events(): Observable<TreeEvent> {\n      return this.events$;\n   }\n\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this._branches[index];\n   }\n\n   public handleUserlandError(error: unknown): never {\n      const message = hasProperty(error, \"message\")\n         ? error.message\n         : \"Unknown error\";\n      throw new TreeError(`Failed to grow branch: ${message}`, {\n         // This cast to `any` is due to an issue in typescript that has been\n         // resolved at least by version 4.9.5. When we upgrade our typescript\n         // version we can remove the cast.\n         cause: error as any\n      });\n   }\n\n   public isDestroyed(): boolean {\n      return this.destroyed;\n   }\n\n   public plot(): TreePlot {\n      return new Map(\n         this.branches().map((branch, index) => [index, branch.plot()])\n      );\n   }\n\n   public traverse(\n      callback: (\n         node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      ) => void\n   ): void {\n      this.branches().forEach((branch) => {\n         branch.traverse(callback);\n      });\n   }\n\n   private deregisterChildRelationship(\n      child: TreeBranch<UserlandComponent>\n   ): void {\n      const index = this.branches().findIndex((branch) => branch === child);\n      this._branches.splice(index, 1);\n   }\n\n   private graftsToSelf(): Observable<\n      GraftEvent<Relationship<UserlandComponent>>\n   > {\n      return this.events().pipe(\n         filter(\n            (event): event is GraftEvent<Relationship<UserlandComponent>> =>\n               event instanceof GraftEvent\n         ),\n         filter((event) => event.parent().events() === this.events$)\n      );\n   }\n\n   private prunesToSelf(): Observable<\n      PruneEvent<Relationship<UserlandComponent>>\n   > {\n      return this.events().pipe(\n         filter(\n            (event): event is PruneEvent<Relationship<UserlandComponent>> =>\n               event instanceof PruneEvent\n         ),\n         filter((event) => event.parent().events() === this.events$)\n      );\n   }\n\n   private registerChildRelationship(\n      child: TreeBranch<UserlandComponent>,\n      index: number\n   ): void {\n      const branches = this.branches();\n      if (index < 0 || index > branches.length) {\n         throw new TreeError(\n            `Can't register child at index ${index}. Out of range.`\n         );\n      }\n      this._branches.splice(index, 0, child);\n   }\n}\n"]}

package/esm2020/lib/core/tree-root/tree-root.mjs

@@ -3,8 +3,13 @@ import { TreeNodeBase } from "../tree-node-base";
 import { dropzoneRenderer } from "../../extras/drag-and-drop/dropzone-renderer";
 import { config } from "../configuration/configuration";
 import { TreeError } from "../../errors";
-import { DestructionEvent } from "../../events/general";
+import { DestructionEvent } from "../../events";
 import { RootController } from "./root-controller";
+/**
+ * Represents the base of the tree. It renders a very simple container for child
+ * branches. It has methods for creating and accessing those branches. It emits
+ * events when things happen in the tree.
+ */
 export class TreeRoot {
     constructor(viewContainerRef) {
         this.viewContainerRef = viewContainerRef;
@@ -12,9 +17,19 @@ export class TreeRoot {
         this.rootController = new RootController(this, viewContainerRef);
         this.detectChanges();
     }
+    /** @returns All child branches as an array of TreeBranch instances */
     branches() {
         return this.treeNodeBase.branches();
     }
+    /**
+     * Recursively destroys all branches of the tree, as well as itself.
+     *
+     * @remarks
+     * This releases all resources held or consumed by the tree.
+     *
+     * It is important to call this method when a tree is discarded, otherwise
+     * the tree will remain in memory and continue to consume resources.
+     */
     destroy() {
         if (this.isDestroyed()) {
             throw new TreeError("Cannot destroy a destroyed tree root");
@@ -26,60 +41,153 @@ export class TreeRoot {
         config.delete(this);
         this.dispatch(new DestructionEvent(this));
     }
+    /** Run Angular change detection on the root of the tree */
     detectChanges() {
         this.rootController.detectChanges();
     }
+    /**
+     * Emits the specified TreeEvent.
+     *
+     * @remarks
+     * Caution: It is not recommended to manually emit TreeEvents that are already
+     * provided by the library. For example, it is not recommended to emit a
+     * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,
+     * and emitting them manually may cause unexpected behavior. Instead, we
+     * recommend implementing the TreeEvent interface with your own custom events
+     * and dispatching those.
+     *
+     * @param event - The TreeEvent that will be emitted.
+     */
     dispatch(event) {
         this.treeNodeBase.dispatch(event);
     }
+    /**
+     * @returns
+     * An observable that emits TreeEvents whenever an event is dispatched
+     * in the root or any of its descendant branches.
+     */
     events() {
         return this.treeNodeBase.events();
     }
+    /**
+     * @returns
+     * The child branch at the specified index, or undefined if there is
+     * no child branch at the specified index.
+     */
     getBranch(index) {
         return this.treeNodeBase.getBranch(index);
     }
+    /** @returns The ViewContainerRef in which child branches are rendered */
     getBranchesContainer() {
         if (this.isDestroyed()) {
             throw new TreeError("Cannot get branches container from a destroyed tree root");
         }
         return this.rootController.getBranchesContainer();
     }
+    /**
+     * Retrieves the RootComponent.
+     *
+     * @remarks
+     * The RootComponent holds the BranchesContainer, as well as a single Dropzone
+     * for drag-and-drop operations.
+     *
+     * @returns The instance of RootComponent that is rendered by this class.
+     */
     getComponentInstance() {
         if (this.isDestroyed()) {
             throw new TreeError("Cannot get component instance from a destroyed tree root");
         }
         return this.rootController.getComponentInstance();
     }
+    /** @returns The Host View in which the RootComponent is rendered */
     getHostView() {
         if (this.isDestroyed()) {
             throw new TreeError("Cannot get component host view from a destroyed tree root");
         }
         return this.rootController.getHostView();
     }
+    /** @returns The RootComponent as a native HTML Element */
     getNativeElement() {
         if (this.isDestroyed()) {
             throw new TreeError("Cannot get native element from a destroyed tree root");
         }
         return this.rootController.getNativeElement();
     }
+    /**
+     * Appends a new child branch to this branch. The child branch will render
+     * the specified component according to the (optional) configuration parameter.
+     *
+     * @param component - The component to render in the new child branch.
+     * @param options - Configuration options for the new child branch.
+     *
+     * @returns
+     * The newly-created child branch.
+     */
     grow(component, options) {
         if (this.isDestroyed()) {
             throw new TreeError("Cannot grow a branch on a destroyed tree root");
         }
-        return new TreeBranch(this, { component, ...options });
+        try {
+            return new TreeBranch(this, { component, ...options });
+        }
+        catch (error) {
+            this.handleUserlandError(error);
+        }
     }
+    /** @returns `true` if the tree is destroyed, `false` otherwise */
     isDestroyed() {
         return this.treeNodeBase.isDestroyed();
     }
+    /**
+     * Provides a model describing the shape of the tree.
+     *
+     * @returns A multi-dimensional Map which describes the shape of the tree.
+     *
+     * @example
+     * For example, an empty tree will return an empty Map. A tree with a single
+     * branch will return a Map with a single entry, where the key is the index
+     * of the branch (zero) and the value is an empty Map. A Tree like this:
+     *
+     * ```
+     *         ---Branch-------Branch
+     *        /
+     * Root-------Branch
+     *        \
+     *         ---Branch
+     * ```
+     * Will return a Map of matching shape:
+     * ```
+     * Map {
+     *    0: Map { 0: Map {}},
+     *    1: Map {},
+     *    2: Map {}
+     * }
+     * ```
+     */
     plot() {
         return this.treeNodeBase.plot();
     }
+    /** @returns Itself */
     root() {
         return this;
     }
+    /**
+     * Traverses the tree in depth-first pre-order, executing the provided
+     * callback function on each node. Traversal includes the Root.
+     *
+     * @param callback - A function to execute on each node.
+     */
     traverse(callback) {
         callback(this);
         this.treeNodeBase.traverse(callback);
     }
+    handleUserlandError(error) {
+        // When an error occurs in a userland component during a tree operation,
+        // it can cause undefined, bizarre behavior in the tree. To prevent this,
+        // we destroy the tree and throw an error instead. This helps protect
+        // the end-user's data from corruption.
+        this.destroy();
+        this.treeNodeBase.handleUserlandError(error);
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-root.js","sourceRoot":"","sources":["../../../../../../projects/limble-tree/src/lib/core/tree-root/tree-root.ts"],"names":[],"mappings":"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","sourcesContent":["import { TreePlot } from \"../../structure/tree-plot\";\nimport { Observable } from \"rxjs\";\nimport { TreeEvent } from \"../../structure/tree-event.interface\";\nimport { TreeBranch } from \"../tree-branch/tree-branch\";\nimport { Type, ViewContainerRef, ViewRef } from \"@angular/core\";\nimport { RootComponent } from \"../../components/root/root.component\";\nimport { TreeNodeBase } from \"../tree-node-base\";\nimport { NodeComponent } from \"../../components/node-component.interface\";\nimport { BranchOptions } from \"../branch-options.interface\";\nimport { dropzoneRenderer } from \"../../extras/drag-and-drop/dropzone-renderer\";\nimport { config } from \"../configuration/configuration\";\nimport { TreeError } from \"../../errors\";\nimport { DestructionEvent } from \"../../events/general\";\nimport { TreeNode } from \"../../structure\";\nimport { RootController } from \"./root-controller\";\n\nexport class TreeRoot<UserlandComponent>\n   implements TreeNode<TreeBranch<UserlandComponent>, RootComponent>\n{\n   private readonly rootController: RootController<UserlandComponent>;\n   private readonly treeNodeBase: TreeNodeBase<UserlandComponent>;\n\n   public constructor(private readonly viewContainerRef: ViewContainerRef) {\n      this.treeNodeBase = new TreeNodeBase();\n      this.rootController = new RootController(this, viewContainerRef);\n      this.detectChanges();\n   }\n\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return this.treeNodeBase.branches();\n   }\n\n   public destroy(): void {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot destroy a destroyed tree root\");\n      }\n      dropzoneRenderer.clearTreeFromRegistry(this);\n      this.treeNodeBase.destroy();\n      this.rootController.destroy();\n      this.viewContainerRef.clear();\n      config.delete(this);\n      this.dispatch(new DestructionEvent(this));\n   }\n\n   public detectChanges(): void {\n      this.rootController.detectChanges();\n   }\n\n   public dispatch(event: TreeEvent): void {\n      this.treeNodeBase.dispatch(event);\n   }\n\n   public events(): Observable<TreeEvent> {\n      return this.treeNodeBase.events();\n   }\n\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this.treeNodeBase.getBranch(index);\n   }\n\n   public getBranchesContainer(): ViewContainerRef | undefined {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get branches container from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getBranchesContainer();\n   }\n\n   public getComponentInstance(): RootComponent {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component instance from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getComponentInstance();\n   }\n\n   public getHostView(): ViewRef {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component host view from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getHostView();\n   }\n\n   public getNativeElement(): HTMLElement {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get native element from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getNativeElement();\n   }\n\n   public grow(\n      component: Type<UserlandComponent>,\n      options?: BranchOptions<UserlandComponent>\n   ): TreeBranch<UserlandComponent> {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot grow a branch on a destroyed tree root\");\n      }\n      return new TreeBranch(this, { component, ...options });\n   }\n\n   public isDestroyed(): boolean {\n      return this.treeNodeBase.isDestroyed();\n   }\n\n   public plot(): TreePlot {\n      return this.treeNodeBase.plot();\n   }\n\n   public root(): this {\n      return this;\n   }\n\n   public traverse(\n      callback: (\n         node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      ) => void\n   ): void {\n      callback(this);\n      this.treeNodeBase.traverse(callback);\n   }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-root.js","sourceRoot":"","sources":["../../../../../../projects/limble-tree/src/lib/core/tree-root/tree-root.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Observable } from \"rxjs\";\nimport { TreeBranch } from \"../tree-branch/tree-branch\";\nimport type { Type, ViewContainerRef, ViewRef } from \"@angular/core\";\nimport { RootComponent } from \"../../components/root/root.component\";\nimport { TreeNodeBase } from \"../tree-node-base\";\nimport type { NodeComponent } from \"../../components/node-component.interface\";\nimport type { BranchOptions } from \"../branch-options.interface\";\nimport { dropzoneRenderer } from \"../../extras/drag-and-drop/dropzone-renderer\";\nimport { config } from \"../configuration/configuration\";\nimport { TreeError } from \"../../errors\";\nimport { DestructionEvent } from \"../../events\";\nimport type { TreeNode, TreePlot, TreeEvent } from \"../../structure\";\nimport { RootController } from \"./root-controller\";\n\n/**\n * Represents the base of the tree. It renders a very simple container for child\n * branches. It has methods for creating and accessing those branches. It emits\n * events when things happen in the tree.\n */\nexport class TreeRoot<UserlandComponent>\n   implements TreeNode<TreeBranch<UserlandComponent>, RootComponent>\n{\n   private readonly rootController: RootController<UserlandComponent>;\n   private readonly treeNodeBase: TreeNodeBase<UserlandComponent>;\n\n   public constructor(private readonly viewContainerRef: ViewContainerRef) {\n      this.treeNodeBase = new TreeNodeBase();\n      this.rootController = new RootController(this, viewContainerRef);\n      this.detectChanges();\n   }\n\n   /** @returns All child branches as an array of TreeBranch instances */\n   public branches(): Array<TreeBranch<UserlandComponent>> {\n      return this.treeNodeBase.branches();\n   }\n\n   /**\n    * Recursively destroys all branches of the tree, as well as itself.\n    *\n    * @remarks\n    * This releases all resources held or consumed by the tree.\n    *\n    * It is important to call this method when a tree is discarded, otherwise\n    * the tree will remain in memory and continue to consume resources.\n    */\n   public destroy(): void {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot destroy a destroyed tree root\");\n      }\n      dropzoneRenderer.clearTreeFromRegistry(this);\n      this.treeNodeBase.destroy();\n      this.rootController.destroy();\n      this.viewContainerRef.clear();\n      config.delete(this);\n      this.dispatch(new DestructionEvent(this));\n   }\n\n   /** Run Angular change detection on the root of the tree */\n   public detectChanges(): void {\n      this.rootController.detectChanges();\n   }\n\n   /**\n    * Emits the specified TreeEvent.\n    *\n    * @remarks\n    * Caution: It is not recommended to manually emit TreeEvents that are already\n    * provided by the library. For example, it is not recommended to emit a\n    * `GraftEvent`, `DestructionEvent`, etc. These events may be used by the tree,\n    * and emitting them manually may cause unexpected behavior. Instead, we\n    * recommend implementing the TreeEvent interface with your own custom events\n    * and dispatching those.\n    *\n    * @param event - The TreeEvent that will be emitted.\n    */\n   public dispatch(event: TreeEvent): void {\n      this.treeNodeBase.dispatch(event);\n   }\n\n   /**\n    * @returns\n    * An observable that emits TreeEvents whenever an event is dispatched\n    * in the root or any of its descendant branches.\n    */\n   public events(): Observable<TreeEvent> {\n      return this.treeNodeBase.events();\n   }\n\n   /**\n    * @returns\n    * The child branch at the specified index, or undefined if there is\n    * no child branch at the specified index.\n    */\n   public getBranch(index: number): TreeBranch<UserlandComponent> | undefined {\n      return this.treeNodeBase.getBranch(index);\n   }\n\n   /** @returns The ViewContainerRef in which child branches are rendered */\n   public getBranchesContainer(): ViewContainerRef | undefined {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get branches container from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getBranchesContainer();\n   }\n\n   /**\n    * Retrieves the RootComponent.\n    *\n    * @remarks\n    * The RootComponent holds the BranchesContainer, as well as a single Dropzone\n    * for drag-and-drop operations.\n    *\n    * @returns The instance of RootComponent that is rendered by this class.\n    */\n   public getComponentInstance(): RootComponent {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component instance from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getComponentInstance();\n   }\n\n   /** @returns The Host View in which the RootComponent is rendered */\n   public getHostView(): ViewRef {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get component host view from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getHostView();\n   }\n\n   /** @returns The RootComponent as a native HTML Element */\n   public getNativeElement(): HTMLElement {\n      if (this.isDestroyed()) {\n         throw new TreeError(\n            \"Cannot get native element from a destroyed tree root\"\n         );\n      }\n      return this.rootController.getNativeElement();\n   }\n\n   /**\n    * Appends a new child branch to this branch. The child branch will render\n    * the specified component according to the (optional) configuration parameter.\n    *\n    * @param component - The component to render in the new child branch.\n    * @param options - Configuration options for the new child branch.\n    *\n    * @returns\n    * The newly-created child branch.\n    */\n   public grow(\n      component: Type<UserlandComponent>,\n      options?: BranchOptions<UserlandComponent>\n   ): TreeBranch<UserlandComponent> {\n      if (this.isDestroyed()) {\n         throw new TreeError(\"Cannot grow a branch on a destroyed tree root\");\n      }\n      try {\n         return new TreeBranch(this, { component, ...options });\n      } catch (error) {\n         this.handleUserlandError(error);\n      }\n   }\n\n   /** @returns `true` if the tree is destroyed, `false` otherwise */\n   public isDestroyed(): boolean {\n      return this.treeNodeBase.isDestroyed();\n   }\n\n   /**\n    * Provides a model describing the shape of the tree.\n    *\n    * @returns A multi-dimensional Map which describes the shape of the tree.\n    *\n    * @example\n    * For example, an empty tree will return an empty Map. A tree with a single\n    * branch will return a Map with a single entry, where the key is the index\n    * of the branch (zero) and the value is an empty Map. A Tree like this:\n    *\n    * ```\n    *         ---Branch-------Branch\n    *        /\n    * Root-------Branch\n    *        \\\n    *         ---Branch\n    * ```\n    * Will return a Map of matching shape:\n    * ```\n    * Map {\n    *    0: Map { 0: Map {}},\n    *    1: Map {},\n    *    2: Map {}\n    * }\n    * ```\n    */\n   public plot(): TreePlot {\n      return this.treeNodeBase.plot();\n   }\n\n   /** @returns Itself */\n   public root(): this {\n      return this;\n   }\n\n   /**\n    * Traverses the tree in depth-first pre-order, executing the provided\n    * callback function on each node. Traversal includes the Root.\n    *\n    * @param callback - A function to execute on each node.\n    */\n   public traverse(\n      callback: (\n         node: TreeNode<TreeBranch<UserlandComponent>, NodeComponent>\n      ) => void\n   ): void {\n      callback(this);\n      this.treeNodeBase.traverse(callback);\n   }\n\n   private handleUserlandError(error: unknown): never {\n      // When an error occurs in a userland component during a tree operation,\n      // it can cause undefined, bizarre behavior in the tree. To prevent this,\n      // we destroy the tree and throw an error instead. This helps protect\n      // the end-user's data from corruption.\n      this.destroy();\n      this.treeNodeBase.handleUserlandError(error);\n   }\n}\n"]}

package/esm2020/lib/core/tree-service/tree.service.mjs

@@ -2,7 +2,13 @@ import { Injectable } from "@angular/core";
 import { config } from "../configuration/configuration";
 import { TreeRoot } from "../tree-root/tree-root";
 import * as i0 from "@angular/core";
+/** Responsible for the creation of new trees. */
 export class TreeService {
+    /**
+     * Creates a new, empty tree structure inside the provided container.
+     *
+     * @returns A `TreeRoot` representing the base of the new tree.
+     */
     createEmptyTree(container, options = {}) {
         container.clear();
         const root = new TreeRoot(container);
@@ -16,4 +22,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
             type: Injectable,
             args: [{ providedIn: "root" }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9jb3JlL3RyZWUtc2VydmljZS90cmVlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBb0IsTUFBTSxlQUFlLENBQUM7QUFDN0QsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXhELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFHbEQsTUFBTSxPQUFPLFdBQVc7SUFDZCxlQUFlLENBQ25CLFNBQTJCLEVBQzNCLFVBQXVCLEVBQUU7UUFFekIsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ2xCLE1BQU0sSUFBSSxHQUFHLElBQUksUUFBUSxDQUFZLFNBQVMsQ0FBQyxDQUFDO1FBQ2hELE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ2hDLE9BQU8sSUFBSSxDQUFDO0lBQ2YsQ0FBQzs7eUdBVFMsV0FBVzs2R0FBWCxXQUFXLGNBREUsTUFBTTs0RkFDbkIsV0FBVztrQkFEdkIsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCBWaWV3Q29udGFpbmVyUmVmIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IGNvbmZpZyB9IGZyb20gXCIuLi9jb25maWd1cmF0aW9uL2NvbmZpZ3VyYXRpb25cIjtcbmltcG9ydCB7IFRyZWVPcHRpb25zIH0gZnJvbSBcIi4uL2NvbmZpZ3VyYXRpb24vdHJlZS1vcHRpb25zLmludGVyZmFjZVwiO1xuaW1wb3J0IHsgVHJlZVJvb3QgfSBmcm9tIFwiLi4vdHJlZS1yb290L3RyZWUtcm9vdFwiO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46IFwicm9vdFwiIH0pXG5leHBvcnQgY2xhc3MgVHJlZVNlcnZpY2Uge1xuICAgcHVibGljIGNyZWF0ZUVtcHR5VHJlZTxDb21wb25lbnQ+KFxuICAgICAgY29udGFpbmVyOiBWaWV3Q29udGFpbmVyUmVmLFxuICAgICAgb3B0aW9uczogVHJlZU9wdGlvbnMgPSB7fVxuICAgKTogVHJlZVJvb3Q8Q29tcG9uZW50PiB7XG4gICAgICBjb250YWluZXIuY2xlYXIoKTtcbiAgICAgIGNvbnN0IHJvb3QgPSBuZXcgVHJlZVJvb3Q8Q29tcG9uZW50Pihjb250YWluZXIpO1xuICAgICAgY29uZmlnLnNldENvbmZpZyhyb290LCBvcHRpb25zKTtcbiAgICAgIHJldHVybiByb290O1xuICAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9jb3JlL3RyZWUtc2VydmljZS90cmVlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBeUIsTUFBTSxlQUFlLENBQUM7QUFDbEUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXhELE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFFbEQsaURBQWlEO0FBRWpELE1BQU0sT0FBTyxXQUFXO0lBQ3JCOzs7O09BSUc7SUFDSSxlQUFlLENBQ25CLFNBQTJCLEVBQzNCLFVBQXVCLEVBQUU7UUFFekIsU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ2xCLE1BQU0sSUFBSSxHQUFHLElBQUksUUFBUSxDQUFZLFNBQVMsQ0FBQyxDQUFDO1FBQ2hELE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ2hDLE9BQU8sSUFBSSxDQUFDO0lBQ2YsQ0FBQzs7eUdBZFMsV0FBVzs2R0FBWCxXQUFXLGNBREUsTUFBTTs0RkFDbkIsV0FBVztrQkFEdkIsVUFBVTttQkFBQyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlLCB0eXBlIFZpZXdDb250YWluZXJSZWYgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgY29uZmlnIH0gZnJvbSBcIi4uL2NvbmZpZ3VyYXRpb24vY29uZmlndXJhdGlvblwiO1xuaW1wb3J0IHR5cGUgeyBUcmVlT3B0aW9ucyB9IGZyb20gXCIuLi9jb25maWd1cmF0aW9uL3RyZWUtb3B0aW9ucy5pbnRlcmZhY2VcIjtcbmltcG9ydCB7IFRyZWVSb290IH0gZnJvbSBcIi4uL3RyZWUtcm9vdC90cmVlLXJvb3RcIjtcblxuLyoqIFJlc3BvbnNpYmxlIGZvciB0aGUgY3JlYXRpb24gb2YgbmV3IHRyZWVzLiAqL1xuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiBcInJvb3RcIiB9KVxuZXhwb3J0IGNsYXNzIFRyZWVTZXJ2aWNlIHtcbiAgIC8qKlxuICAgICogQ3JlYXRlcyBhIG5ldywgZW1wdHkgdHJlZSBzdHJ1Y3R1cmUgaW5zaWRlIHRoZSBwcm92aWRlZCBjb250YWluZXIuXG4gICAgKlxuICAgICogQHJldHVybnMgQSBgVHJlZVJvb3RgIHJlcHJlc2VudGluZyB0aGUgYmFzZSBvZiB0aGUgbmV3IHRyZWUuXG4gICAgKi9cbiAgIHB1YmxpYyBjcmVhdGVFbXB0eVRyZWU8Q29tcG9uZW50PihcbiAgICAgIGNvbnRhaW5lcjogVmlld0NvbnRhaW5lclJlZixcbiAgICAgIG9wdGlvbnM6IFRyZWVPcHRpb25zID0ge31cbiAgICk6IFRyZWVSb290PENvbXBvbmVudD4ge1xuICAgICAgY29udGFpbmVyLmNsZWFyKCk7XG4gICAgICBjb25zdCByb290ID0gbmV3IFRyZWVSb290PENvbXBvbmVudD4oY29udGFpbmVyKTtcbiAgICAgIGNvbmZpZy5zZXRDb25maWcocm9vdCwgb3B0aW9ucyk7XG4gICAgICByZXR1cm4gcm9vdDtcbiAgIH1cbn1cbiJdfQ==

package/esm2020/lib/events/drag/drag-end-event.mjs

@@ -1,3 +1,4 @@
+/** Emitted when a drag-and-drop operation has completed */
 export class DragEndEvent {
     constructor(source, endpoints) {
         this._source = source;
@@ -6,23 +7,24 @@ export class DragEndEvent {
         this._newParent = endpoints.newParent;
         this._newIndex = endpoints.newIndex;
     }
-    type() {
-        return "drag end";
-    }
-    source() {
-        return this._source;
-    }
+    /** @returns The new index of the dropped branch */
     newIndex() {
         return this._newIndex;
     }
+    /** @returns The new parent of the dropped branch */
     newParent() {
         return this._newParent;
     }
+    /** @returns The index of the dropped branch before it was dragged */
     oldIndex() {
         return this._oldIndex;
     }
+    /** @returns The parent of the dropped branch before it was dragged */
     oldParent() {
         return this._oldParent;
     }
+    source() {
+        return this._source;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/events/drag/drag-start-event.mjs

@@ -1,12 +1,10 @@
+/** Emitted when a TreeBranch begins being dragged */
 export class DragStartEvent {
     constructor(source) {
         this._source = source;
     }
-    type() {
-        return "drag start";
-    }
     source() {
         return this._source;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1zdGFydC1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvZXZlbnRzL2RyYWcvZHJhZy1zdGFydC1ldmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLE9BQU8sY0FBYztJQUd4QixZQUFtQixNQUFvQjtRQUNwQyxJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQztJQUN6QixDQUFDO0lBRU0sSUFBSTtRQUNSLE9BQU8sWUFBWSxDQUFDO0lBQ3ZCLENBQUM7SUFFTSxNQUFNO1FBQ1YsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3ZCLENBQUM7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV2ZW50Q29uZHVpdCB9IGZyb20gXCIuLi8uLi9zdHJ1Y3R1cmUvZXZlbnQtY29uZHVpdC5pbnRlcmZhY2VcIjtcbmltcG9ydCB7IFRyZWVFdmVudCB9IGZyb20gXCIuLi8uLi9zdHJ1Y3R1cmUvdHJlZS1ldmVudC5pbnRlcmZhY2VcIjtcblxuZXhwb3J0IGNsYXNzIERyYWdTdGFydEV2ZW50IGltcGxlbWVudHMgVHJlZUV2ZW50IHtcbiAgIHByaXZhdGUgcmVhZG9ubHkgX3NvdXJjZTogRXZlbnRDb25kdWl0O1xuXG4gICBwdWJsaWMgY29uc3RydWN0b3Ioc291cmNlOiBFdmVudENvbmR1aXQpIHtcbiAgICAgIHRoaXMuX3NvdXJjZSA9IHNvdXJjZTtcbiAgIH1cblxuICAgcHVibGljIHR5cGUoKTogXCJkcmFnIHN0YXJ0XCIge1xuICAgICAgcmV0dXJuIFwiZHJhZyBzdGFydFwiO1xuICAgfVxuXG4gICBwdWJsaWMgc291cmNlKCk6IEV2ZW50Q29uZHVpdCB7XG4gICAgICByZXR1cm4gdGhpcy5fc291cmNlO1xuICAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1zdGFydC1ldmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvZXZlbnRzL2RyYWcvZHJhZy1zdGFydC1ldmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxxREFBcUQ7QUFDckQsTUFBTSxPQUFPLGNBQWM7SUFHeEIsWUFBbUIsTUFBd0M7UUFDeEQsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7SUFDekIsQ0FBQztJQUVNLE1BQU07UUFDVixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdkIsQ0FBQztDQUNIIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBOb2RlQ29tcG9uZW50IH0gZnJvbSBcIi4uLy4uL2NvbXBvbmVudHMvbm9kZS1jb21wb25lbnQuaW50ZXJmYWNlXCI7XG5pbXBvcnQgdHlwZSB7IFRyZWVOb2RlIH0gZnJvbSBcIi4uLy4uL3N0cnVjdHVyZVwiO1xuaW1wb3J0IHR5cGUgeyBUcmVlRXZlbnQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL3RyZWUtZXZlbnQuaW50ZXJmYWNlXCI7XG5cbi8qKiBFbWl0dGVkIHdoZW4gYSBUcmVlQnJhbmNoIGJlZ2lucyBiZWluZyBkcmFnZ2VkICovXG5leHBvcnQgY2xhc3MgRHJhZ1N0YXJ0RXZlbnQgaW1wbGVtZW50cyBUcmVlRXZlbnQge1xuICAgcHJpdmF0ZSByZWFkb25seSBfc291cmNlOiBUcmVlTm9kZTx1bmtub3duLCBOb2RlQ29tcG9uZW50PjtcblxuICAgcHVibGljIGNvbnN0cnVjdG9yKHNvdXJjZTogVHJlZU5vZGU8dW5rbm93biwgTm9kZUNvbXBvbmVudD4pIHtcbiAgICAgIHRoaXMuX3NvdXJjZSA9IHNvdXJjZTtcbiAgIH1cblxuICAgcHVibGljIHNvdXJjZSgpOiBUcmVlTm9kZTx1bmtub3duLCBOb2RlQ29tcG9uZW50PiB7XG4gICAgICByZXR1cm4gdGhpcy5fc291cmNlO1xuICAgfVxufVxuIl19

package/esm2020/lib/events/drag/drop-event.mjs

@@ -1,12 +1,10 @@
+/** Emitted when a TreeBranch is dropped into a valid Dropzone */
 export class DropEvent {
     constructor(source, parent, index) {
         this._source = source;
         this._parent = parent;
         this._index = index;
     }
-    type() {
-        return "drag end";
-    }
     source() {
         return this._source;
     }
@@ -17,4 +15,4 @@ export class DropEvent {
         return this._parent;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/events/general/destruction-event.mjs

@@ -1,12 +1,10 @@
+/** Emitted when a node is destroyed */
 export class DestructionEvent {
     constructor(source) {
         this._source = source;
     }
-    type() {
-        return "destruction";
-    }
     source() {
         return this._source;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJ1Y3Rpb24tZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V2ZW50cy9nZW5lcmFsL2Rlc3RydWN0aW9uLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyxnQkFBZ0I7SUFHMUIsWUFBbUIsTUFBb0I7UUFDcEMsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7SUFDekIsQ0FBQztJQUVNLElBQUk7UUFDUixPQUFPLGFBQWEsQ0FBQztJQUN4QixDQUFDO0lBRU0sTUFBTTtRQUNWLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN2QixDQUFDO0NBQ0giLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFdmVudENvbmR1aXQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL2V2ZW50LWNvbmR1aXQuaW50ZXJmYWNlXCI7XG5pbXBvcnQgeyBUcmVlRXZlbnQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL3RyZWUtZXZlbnQuaW50ZXJmYWNlXCI7XG5cbmV4cG9ydCBjbGFzcyBEZXN0cnVjdGlvbkV2ZW50IGltcGxlbWVudHMgVHJlZUV2ZW50IHtcbiAgIHByaXZhdGUgcmVhZG9ubHkgX3NvdXJjZTogRXZlbnRDb25kdWl0O1xuXG4gICBwdWJsaWMgY29uc3RydWN0b3Ioc291cmNlOiBFdmVudENvbmR1aXQpIHtcbiAgICAgIHRoaXMuX3NvdXJjZSA9IHNvdXJjZTtcbiAgIH1cblxuICAgcHVibGljIHR5cGUoKTogXCJkZXN0cnVjdGlvblwiIHtcbiAgICAgIHJldHVybiBcImRlc3RydWN0aW9uXCI7XG4gICB9XG5cbiAgIHB1YmxpYyBzb3VyY2UoKTogRXZlbnRDb25kdWl0IHtcbiAgICAgIHJldHVybiB0aGlzLl9zb3VyY2U7XG4gICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVzdHJ1Y3Rpb24tZXZlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V2ZW50cy9nZW5lcmFsL2Rlc3RydWN0aW9uLWV2ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLHVDQUF1QztBQUN2QyxNQUFNLE9BQU8sZ0JBQWdCO0lBRzFCLFlBQW1CLE1BQXdDO1FBQ3hELElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDO0lBQ3pCLENBQUM7SUFFTSxNQUFNO1FBQ1YsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3ZCLENBQUM7Q0FDSCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTm9kZUNvbXBvbmVudCB9IGZyb20gXCIuLi8uLi9jb21wb25lbnRzL25vZGUtY29tcG9uZW50LmludGVyZmFjZVwiO1xuaW1wb3J0IHR5cGUgeyBUcmVlTm9kZSwgVHJlZUV2ZW50IH0gZnJvbSBcIi4uLy4uL3N0cnVjdHVyZVwiO1xuXG4vKiogRW1pdHRlZCB3aGVuIGEgbm9kZSBpcyBkZXN0cm95ZWQgKi9cbmV4cG9ydCBjbGFzcyBEZXN0cnVjdGlvbkV2ZW50IGltcGxlbWVudHMgVHJlZUV2ZW50IHtcbiAgIHByaXZhdGUgcmVhZG9ubHkgX3NvdXJjZTogVHJlZU5vZGU8dW5rbm93biwgTm9kZUNvbXBvbmVudD47XG5cbiAgIHB1YmxpYyBjb25zdHJ1Y3Rvcihzb3VyY2U6IFRyZWVOb2RlPHVua25vd24sIE5vZGVDb21wb25lbnQ+KSB7XG4gICAgICB0aGlzLl9zb3VyY2UgPSBzb3VyY2U7XG4gICB9XG5cbiAgIHB1YmxpYyBzb3VyY2UoKTogVHJlZU5vZGU8dW5rbm93biwgTm9kZUNvbXBvbmVudD4ge1xuICAgICAgcmV0dXJuIHRoaXMuX3NvdXJjZTtcbiAgIH1cbn1cbiJdfQ==

package/esm2020/lib/events/relational/graft-event.mjs

@@ -1,3 +1,4 @@
+/** Emits when a branch is grafted to another tree node */
 export class GraftEvent {
     constructor(source, relationship) {
         this._source = source;
@@ -8,9 +9,6 @@ export class GraftEvent {
     child() {
         return this._child;
     }
-    type() {
-        return "graft";
-    }
     index() {
         return this._index;
     }
@@ -21,4 +19,4 @@ export class GraftEvent {
         return this._source;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/events/relational/prune-event.mjs

@@ -1,3 +1,4 @@
+/** Emitted when a branch is pruned from its parent branch */
 export class PruneEvent {
     constructor(source, relationship) {
         this._source = source;
@@ -8,9 +9,6 @@ export class PruneEvent {
     child() {
         return this._child;
     }
-    type() {
-        return "prune";
-    }
     index() {
         return this._index;
     }
@@ -21,4 +19,4 @@ export class PruneEvent {
         return this._source;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/events/relational/relational-tree-event.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsYXRpb25hbC10cmVlLWV2ZW50LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvZXZlbnRzL3JlbGF0aW9uYWwvcmVsYXRpb25hbC10cmVlLWV2ZW50LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHJlZUV2ZW50IH0gZnJvbSBcIi4uLy4uL3N0cnVjdHVyZS90cmVlLWV2ZW50LmludGVyZmFjZVwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIFJlbGF0aW9uYWxUcmVlRXZlbnQ8UGFyZW50LCBDaGlsZD4gZXh0ZW5kcyBUcmVlRXZlbnQge1xuICAgcGFyZW50OiAoKSA9PiBQYXJlbnQ7XG4gICBjaGlsZDogKCkgPT4gQ2hpbGQ7XG4gICBpbmRleDogKCkgPT4gbnVtYmVyO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsYXRpb25hbC10cmVlLWV2ZW50LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvZXZlbnRzL3JlbGF0aW9uYWwvcmVsYXRpb25hbC10cmVlLWV2ZW50LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBUcmVlRXZlbnQgfSBmcm9tIFwiLi4vLi4vc3RydWN0dXJlL3RyZWUtZXZlbnQuaW50ZXJmYWNlXCI7XG5cbi8qKiBBIFRyZWVFdmVudCB3aGljaCBpbnZvbHZlcyBhIHBhcmVudC9jaGlsZCByZWxhdGlvbnNoaXAgKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmVsYXRpb25hbFRyZWVFdmVudDxQYXJlbnQsIENoaWxkPiBleHRlbmRzIFRyZWVFdmVudCB7XG4gICAvKiogQHJldHVybnMgVGhlIHBhcmVudCBicmFuY2ggb2YgdGhlIHJlbGF0aW9uc2hpcCAqL1xuICAgcGFyZW50OiAoKSA9PiBQYXJlbnQ7XG4gICAvKiogQHJldHVybnMgVGhlIGNoaWxkIGJyYW5jaCBvZiB0aGUgcmVsYXRpb25zaGlwICovXG4gICBjaGlsZDogKCkgPT4gQ2hpbGQ7XG4gICAvKiogQHJldHVybnMgVGhlIGluZGV4IGxvY2F0aW9uIG9mIHRoZSBjaGlsZCAqL1xuICAgaW5kZXg6ICgpID0+IG51bWJlcjtcbn1cbiJdfQ==

package/esm2020/lib/extras/collapse/collapse.module.mjs

@@ -1,6 +1,7 @@
 import { NgModule } from "@angular/core";
 import { TreeCollapseService } from "./collapse.service";
 import * as i0 from "@angular/core";
+/** A module containing the entities which provide collapse functionality */
 export class TreeCollapseModule {
 }
 TreeCollapseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -12,4 +13,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
                     providers: [TreeCollapseService]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGFwc2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9leHRyYXMvY29sbGFwc2UvY29sbGFwc2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBS3pELE1BQU0sT0FBTyxrQkFBa0I7O2dIQUFsQixrQkFBa0I7aUhBQWxCLGtCQUFrQjtpSEFBbEIsa0JBQWtCLGFBRmpCLENBQUMsbUJBQW1CLENBQUM7NEZBRXRCLGtCQUFrQjtrQkFIOUIsUUFBUTttQkFBQztvQkFDUCxTQUFTLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztpQkFDbEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBUcmVlQ29sbGFwc2VTZXJ2aWNlIH0gZnJvbSBcIi4vY29sbGFwc2Uuc2VydmljZVwiO1xuXG5ATmdNb2R1bGUoe1xuICAgcHJvdmlkZXJzOiBbVHJlZUNvbGxhcHNlU2VydmljZV1cbn0pXG5leHBvcnQgY2xhc3MgVHJlZUNvbGxhcHNlTW9kdWxlIHt9XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGFwc2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbGltYmxlLXRyZWUvc3JjL2xpYi9leHRyYXMvY29sbGFwc2UvY29sbGFwc2UubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBRXpELDRFQUE0RTtBQUk1RSxNQUFNLE9BQU8sa0JBQWtCOztnSEFBbEIsa0JBQWtCO2lIQUFsQixrQkFBa0I7aUhBQWxCLGtCQUFrQixhQUZqQixDQUFDLG1CQUFtQixDQUFDOzRGQUV0QixrQkFBa0I7a0JBSDlCLFFBQVE7bUJBQUM7b0JBQ1AsU0FBUyxFQUFFLENBQUMsbUJBQW1CLENBQUM7aUJBQ2xDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgVHJlZUNvbGxhcHNlU2VydmljZSB9IGZyb20gXCIuL2NvbGxhcHNlLnNlcnZpY2VcIjtcblxuLyoqIEEgbW9kdWxlIGNvbnRhaW5pbmcgdGhlIGVudGl0aWVzIHdoaWNoIHByb3ZpZGUgY29sbGFwc2UgZnVuY3Rpb25hbGl0eSAqL1xuQE5nTW9kdWxlKHtcbiAgIHByb3ZpZGVyczogW1RyZWVDb2xsYXBzZVNlcnZpY2VdXG59KVxuZXhwb3J0IGNsYXNzIFRyZWVDb2xsYXBzZU1vZHVsZSB7fVxuIl19

package/esm2020/lib/extras/collapse/collapse.service.mjs

@@ -1,13 +1,38 @@
 import { Injectable } from "@angular/core";
 import { treeCollapser } from "./collapse";
 import * as i0 from "@angular/core";
+/** A service that collapses and expands tree branches */
 export class TreeCollapseService {
+    /**
+     * Causes a TreeBranch to collapse, temporarily pruning all of its children
+     * from the tree.
+     *
+     * @param treeBranch - The branch to collapse.
+     */
     collapse(treeBranch) {
         treeCollapser.collapse(treeBranch);
     }
+    /**
+     * Causes a TreeBranch to expand, restoring all of its children which were
+     * previously pruned by a call to `collapse()`.
+     *
+     * @param treeBranch - The branch to expand.
+     */
     expand(treeBranch) {
         treeCollapser.expand(treeBranch);
     }
+    /**
+     * Determines whether a TreeBranch currently has any children which are
+     * pruned from the tree due to a call to  the `collapse()` method.
+     *
+     * @remarks
+     * Child branches which are pruned manually from the tree, rather than
+     * through the `collapse()` method, will not be considered.
+     *
+     * @param treeBranch - The branch to check.
+     *
+     * @returns `true` if the branch is currently collapsed; `false` if it is not.
+     */
     isCollapsed(treeBranch) {
         return treeCollapser.isCollapsed(treeBranch);
     }
@@ -17,4 +42,4 @@ TreeCollapseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0",
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeCollapseService, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGFwc2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xpbWJsZS10cmVlL3NyYy9saWIvZXh0cmFzL2NvbGxhcHNlL2NvbGxhcHNlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sWUFBWSxDQUFDOztBQUczQyxNQUFNLE9BQU8sbUJBQW1CO0lBQ3RCLFFBQVEsQ0FBSSxVQUF5QjtRQUN6QyxhQUFhLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFTSxNQUFNLENBQUksVUFBeUI7UUFDdkMsYUFBYSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBRU0sV0FBVyxDQUFJLFVBQXlCO1FBQzVDLE9BQU8sYUFBYSxDQUFDLFdBQVcsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUNoRCxDQUFDOztpSEFYUyxtQkFBbUI7cUhBQW5CLG1CQUFtQjs0RkFBbkIsbUJBQW1CO2tCQUQvQixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBUcmVlQnJhbmNoIH0gZnJvbSBcIi4uLy4uL2NvcmVcIjtcbmltcG9ydCB7IHRyZWVDb2xsYXBzZXIgfSBmcm9tIFwiLi9jb2xsYXBzZVwiO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgVHJlZUNvbGxhcHNlU2VydmljZSB7XG4gICBwdWJsaWMgY29sbGFwc2U8VD4odHJlZUJyYW5jaDogVHJlZUJyYW5jaDxUPik6IHZvaWQge1xuICAgICAgdHJlZUNvbGxhcHNlci5jb2xsYXBzZSh0cmVlQnJhbmNoKTtcbiAgIH1cblxuICAgcHVibGljIGV4cGFuZDxUPih0cmVlQnJhbmNoOiBUcmVlQnJhbmNoPFQ+KTogdm9pZCB7XG4gICAgICB0cmVlQ29sbGFwc2VyLmV4cGFuZCh0cmVlQnJhbmNoKTtcbiAgIH1cblxuICAgcHVibGljIGlzQ29sbGFwc2VkPFQ+KHRyZWVCcmFuY2g6IFRyZWVCcmFuY2g8VD4pOiBib29sZWFuIHtcbiAgICAgIHJldHVybiB0cmVlQ29sbGFwc2VyLmlzQ29sbGFwc2VkKHRyZWVCcmFuY2gpO1xuICAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/extras/drag-and-drop/drag-and-drop.module.mjs

@@ -3,6 +3,10 @@ import { TreeDragAndDropService } from "./drag-and-drop.service";
 import { DraggableDirective } from "./draggable.directive";
 import { DragoverNoChangeDetectDirective } from "./dragover-no-change-detect";
 import * as i0 from "@angular/core";
+/**
+ * An Angular module containing all of the entities which provide Drag-And-Drop
+ * functionality.
+ */
 export class TreeDragAndDropModule {
 }
 TreeDragAndDropModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: TreeDragAndDropModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
@@ -16,4 +20,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
                     exports: [DraggableDirective, DragoverNoChangeDetectDirective]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V4dHJhcy9kcmFnLWFuZC1kcm9wL2RyYWctYW5kLWRyb3AubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDakUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDM0QsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7O0FBTzlFLE1BQU0sT0FBTyxxQkFBcUI7O21IQUFyQixxQkFBcUI7b0hBQXJCLHFCQUFxQixZQUpyQixrQkFBa0IsRUFBRSwrQkFBK0IsYUFFbkQsa0JBQWtCLEVBQUUsK0JBQStCO29IQUVuRCxxQkFBcUIsYUFIcEIsQ0FBQyxzQkFBc0IsQ0FBQzs0RkFHekIscUJBQXFCO2tCQUxqQyxRQUFRO21CQUFDO29CQUNQLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLCtCQUErQixDQUFDO29CQUM5RCxTQUFTLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDbkMsT0FBTyxFQUFFLENBQUMsa0JBQWtCLEVBQUUsK0JBQStCLENBQUM7aUJBQ2hFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgVHJlZURyYWdBbmREcm9wU2VydmljZSB9IGZyb20gXCIuL2RyYWctYW5kLWRyb3Auc2VydmljZVwiO1xuaW1wb3J0IHsgRHJhZ2dhYmxlRGlyZWN0aXZlIH0gZnJvbSBcIi4vZHJhZ2dhYmxlLmRpcmVjdGl2ZVwiO1xuaW1wb3J0IHsgRHJhZ292ZXJOb0NoYW5nZURldGVjdERpcmVjdGl2ZSB9IGZyb20gXCIuL2RyYWdvdmVyLW5vLWNoYW5nZS1kZXRlY3RcIjtcblxuQE5nTW9kdWxlKHtcbiAgIGltcG9ydHM6IFtEcmFnZ2FibGVEaXJlY3RpdmUsIERyYWdvdmVyTm9DaGFuZ2VEZXRlY3REaXJlY3RpdmVdLFxuICAgcHJvdmlkZXJzOiBbVHJlZURyYWdBbmREcm9wU2VydmljZV0sXG4gICBleHBvcnRzOiBbRHJhZ2dhYmxlRGlyZWN0aXZlLCBEcmFnb3Zlck5vQ2hhbmdlRGV0ZWN0RGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBUcmVlRHJhZ0FuZERyb3BNb2R1bGUge31cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9saW1ibGUtdHJlZS9zcmMvbGliL2V4dHJhcy9kcmFnLWFuZC1kcm9wL2RyYWctYW5kLWRyb3AubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDakUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDM0QsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sNkJBQTZCLENBQUM7O0FBRTlFOzs7R0FHRztBQU1ILE1BQU0sT0FBTyxxQkFBcUI7O21IQUFyQixxQkFBcUI7b0hBQXJCLHFCQUFxQixZQUpyQixrQkFBa0IsRUFBRSwrQkFBK0IsYUFFbkQsa0JBQWtCLEVBQUUsK0JBQStCO29IQUVuRCxxQkFBcUIsYUFIcEIsQ0FBQyxzQkFBc0IsQ0FBQzs0RkFHekIscUJBQXFCO2tCQUxqQyxRQUFRO21CQUFDO29CQUNQLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLCtCQUErQixDQUFDO29CQUM5RCxTQUFTLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDbkMsT0FBTyxFQUFFLENBQUMsa0JBQWtCLEVBQUUsK0JBQStCLENBQUM7aUJBQ2hFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgVHJlZURyYWdBbmREcm9wU2VydmljZSB9IGZyb20gXCIuL2RyYWctYW5kLWRyb3Auc2VydmljZVwiO1xuaW1wb3J0IHsgRHJhZ2dhYmxlRGlyZWN0aXZlIH0gZnJvbSBcIi4vZHJhZ2dhYmxlLmRpcmVjdGl2ZVwiO1xuaW1wb3J0IHsgRHJhZ292ZXJOb0NoYW5nZURldGVjdERpcmVjdGl2ZSB9IGZyb20gXCIuL2RyYWdvdmVyLW5vLWNoYW5nZS1kZXRlY3RcIjtcblxuLyoqXG4gKiBBbiBBbmd1bGFyIG1vZHVsZSBjb250YWluaW5nIGFsbCBvZiB0aGUgZW50aXRpZXMgd2hpY2ggcHJvdmlkZSBEcmFnLUFuZC1Ecm9wXG4gKiBmdW5jdGlvbmFsaXR5LlxuICovXG5ATmdNb2R1bGUoe1xuICAgaW1wb3J0czogW0RyYWdnYWJsZURpcmVjdGl2ZSwgRHJhZ292ZXJOb0NoYW5nZURldGVjdERpcmVjdGl2ZV0sXG4gICBwcm92aWRlcnM6IFtUcmVlRHJhZ0FuZERyb3BTZXJ2aWNlXSxcbiAgIGV4cG9ydHM6IFtEcmFnZ2FibGVEaXJlY3RpdmUsIERyYWdvdmVyTm9DaGFuZ2VEZXRlY3REaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIFRyZWVEcmFnQW5kRHJvcE1vZHVsZSB7fVxuIl19