@ixfx/components 0.4.3 → 0.5.0

package/dist/index.js

@@ -1,52 +1,54 @@
 import { n as buildHighlightTargets, r as clearHighlights, t as applyHighlights } from "./highlight-B-eQrhhb.js";
 import { n as tickledStyles, r as TickledController, t as tickledItemStyles } from "./tickled-styles-fNDdqf6l.js";
 import { t as themeFallbacks } from "./fallbacks-pNMOMx38.js";
-import { n as safeCustomElement, t as __decorate } from "./decorate-DdjvVHS-.js";
+import { n as safeCustomElement, t as __decorate } from "./decorate-VRK8rslU.js";
 import { a as svgToDataUri, i as registerIcon, n as hasIcon, r as iconBus, t as getIcon } from "./registry-CkW7q09Q.js";
-import { t as IxfxIconElement } from "./icon-Ndo40kNO.js";
+import { t as IxfxIconElement } from "./icon-B22XVlCt.js";
 import { AcTextElement } from "./ac-text.js";
-import { a as createFuzzySearch, i as createAcCompletionProvider, n as IncrSearchTreeController, r as createIncrSearch, t as createElementIncrSearch } from "./incr-search-CeERfijK.js";
-import { i as ICON_CLOSE, n as ICON_CHECK, r as ICON_CHEVRON_DOWN, t as ICON_CARET_RIGHT } from "./defaults-C3b9OWJD.js";
+import { a as createFuzzySearch, i as createAcCompletionProvider, n as IncrSearchTreeController, r as createIncrSearch, t as createElementIncrSearch } from "./incr-search-2pz21xtR.js";
+import { i as ICON_CLOSE, n as ICON_CHECK, r as ICON_CHEVRON_DOWN, t as ICON_CARET_RIGHT } from "./defaults-DcE8RQJc.js";
 import "./icons.js";
 import { t as prominenceStyles } from "./prominence-DlFShic3.js";
-import { n as buttonStyles, t as ButtonElement } from "./button-C3fLMKUv.js";
+import { n as buttonStyles, t as ButtonElement } from "./button-DxYee1ZH.js";
 import { t as popupSurfaceStyles } from "./popup-DiWMxsWj.js";
-import "./menu-item-BrIuORYD.js";
+import "./menu-item-NUKwJ4s5.js";
 import { Checkbox } from "./checkbox.js";
-import { _ as isEqualValueDefault, a as PlotDataSeries, c as parseColourScaleAttr, d as QueueMutable, f as isPrimitive, g as isEqualDefault, h as defaultComparer, i as PlotMultiAxis, l as readBaseColour, m as __exportAll, n as PlotSingleAxis, o as applyAgeModification, p as toStringAbbreviate, r as PlotHistogram, s as computeColour, t as PlotXyAxis, u as last, v as isEqualValueIgnoreOrder } from "./xy-axis-no0OL_O1.js";
-import { C as resultThrow, T as throwIfFailed, d as scaler, h as without, n as clamper, p as containsDuplicateInstances, y as nullUndefTest } from "./dist-CA13FvMn.js";
-import { n as ColourPicker, t as ColourPickerPopup } from "./colour-picker-0sgAha1T.js";
+import { n as ColourPicker, t as ColourPickerPopup } from "./colour-picker-C3Ag4uh-.js";
 import { LabelledRangeInput } from "./labelled-range-input.js";
-import { t as collectDataResult } from "./data-provider-DgI909FP.js";
-import { i as TreeDataModel, n as TreeListElement, r as TreeBaseElement, t as TreeController } from "./tree-D84RUgFC.js";
+import { t as collectDataResult } from "./data-provider-35TyWclX.js";
+import { i as TreeDataModel, n as TreeListElement, r as TreeBaseElement, t as TreeController } from "./tree-BnvzhsAw.js";
 import { NarrowedTextElement } from "./narrowed-text.js";
 import { CrumbNavigationElement } from "./crumbs.js";
 import { DataDisplayComponent } from "./data-display.js";
 import { EditableLabel } from "./editable-label.js";
-import { t as resolveStep } from "./keyboard-CimiEskD.js";
+import { t as resolveAxisStep } from "./keyboard-B5xD7Fz-.js";
+import { t as WheelNudgeMixin } from "./wheel-nudge-BlSCe_hD.js";
 import { PanelElement } from "./panel.js";
-import { t as IxfxHexEditorElement } from "./hex-editor-WZrjRtvL.js";
-import { t as RadialInputElement } from "./radial-input-DZ7eQCcM.js";
+import { t as IxfxHexEditorElement } from "./hex-editor-Bk6rxhfg.js";
+import { t as RadialInputElement } from "./radial-input-DxCrt_NE.js";
 import { LabelledRadialInput } from "./labelled-radial-input.js";
 import { LedElement } from "./led.js";
-import { t as menu_exports } from "./menu-vjoiHZ13.js";
+import { t as menu_exports } from "./menu-g6yd7ddN.js";
 import { MillerBaseElement, MillerListElement, MillerTreeController } from "./miller.js";
+import { a as TooltipElement, c as computeColour, i as PlotMultiAxis, l as parseColourScaleAttr, n as PlotSingleAxis, o as PlotDataSeries, r as PlotHistogram, s as applyAgeModification, t as PlotXyAxis, u as readBaseColour } from "./xy-axis-CxHC8z5E.js";
 import { PolarPad } from "./polar-pad.js";
 import { t as tooltipValueStyles } from "./tooltip-CJt3WLmN.js";
 import { RangeInput } from "./range-input.js";
 import { RangeElement } from "./range.js";
 import { SelectHorizontalElement } from "./selecthorizontal.js";
+import { t as SliderInputElement } from "./slider-input-DFpG23bS.js";
 import { SnapContainer } from "./snap-container.js";
 import { SplitLayoutElement } from "./split-layout.js";
 import { SwipeElement } from "./swipe.js";
-import { TabListElement } from "./tabs.js";
-import { a as resolveCssVars, i as attachTimelineInteractions, n as TimelineTrackTabElement, o as resolveGrid, r as timelineStyles, s as TimelineController, t as IxfxTimelineElement } from "./timeline-2OFtN4Ta.js";
+import { t as TabListElement } from "./tab-list-DhkVhRQc.js";
+import { a as resolveCssVars, i as attachTimelineInteractions, n as TimelineTrackTabElement, o as resolveGrid, r as timelineStyles, s as TimelineController, t as IxfxTimelineElement } from "./timeline-B2fgDL4U.js";
 import { XyPad } from "./xy-pad.js";
-import { LitElement, css, html, nothing } from "lit";
+import { LitElement, css, html, nothing, render } from "lit";
 import { eventOptions, property, query, queryAssignedElements, state } from "lit/decorators.js";
 import { unsafeHTML } from "lit/directives/unsafe-html.js";
+import { Trees } from "@ixfx/collections";
+import { clamper, scaler } from "@ixfx/numbers";
 import { repeat } from "lit/directives/repeat.js";
-import { classMap } from "lit/directives/class-map.js";
 import { keyed } from "lit/directives/keyed.js";
 //#region src/common/data-controller.ts
 function isAsyncIterable(v) {
@@ -451,7 +453,6 @@ let AcTokenElement = class AcTokenElement extends LitElement {
 				e.preventDefault();
 				this.#closePopup();
 				this._selectedTokenIndex = void 0;
-				break;
 		}
 	}
 	#onPaste;
@@ -569,9 +570,10 @@ let AcTokenElement = class AcTokenElement extends LitElement {
 		});
 	}
 	#renderChip(item, index) {
+		const isSelected = this._selectedTokenIndex === index;
 		return html`
       <span
-        class="token-chip ${this._selectedTokenIndex === index ? `selected` : ``}"
+        class="token-chip ${isSelected ? `selected` : ``}"
         title=${item.subLabel ?? nothing}
         @pointerdown=${(e) => this.#onChipPointerDown(e, index)}
       >
@@ -999,9 +1001,11 @@ let RadioGroup = class RadioGroup extends LitElement {
       min-width: min-content;
       box-sizing: border-box;
       /* Default to looking like a cohesive control group */
-      background: var(--surface-3, transparent);
+      background: var(--surface-4, transparent);
+      background: oklch(from var(--surface-4) l calc(c*0.2) h / 0.4);
+
       border: var(--border, none);
-      border-radius: var(--radius-m, 4px);
+      border-radius: var(--radius-xl, 8px);
     }
 
     * {
@@ -1031,6 +1035,7 @@ let RadioGroup = class RadioGroup extends LitElement {
       gap: var(--item-spacing, 0);
       overflow: hidden;
       border-radius: inherit;
+      justify-content: center;
     }
 
     .radio-group.horizontal {
@@ -1072,13 +1077,13 @@ let RadioGroup = class RadioGroup extends LitElement {
 
     .radio-item:hover:not([disabled]) {
       opacity: 0.9;
-      background: var(--surface-4, rgba(255,255,255,0.05));
+      background: color-mix(in oklch, var(--surface-4) 80%, transparent);
     }
 
     .radio-item.selected {
       font-weight: bold;
       color: var(--color-fg-accent, var(--surface-2-text));
-      background: var(--surface-6, rgba(255,255,255,0.1));
+      background: var(--surface-5, rgba(255,255,255,0.1));
     }
 
     .radio-item[disabled] {
@@ -1540,2757 +1545,28 @@ let SplitButton = class SplitButton extends ButtonElement {
         align-items: stretch;
       }
     `
-		];
-	}
-};
-__decorate([property({ attribute: false })], SplitButton.prototype, "registry", void 0);
-__decorate([property({ attribute: false })], SplitButton.prototype, "keyboardManager", void 0);
-__decorate([property({ type: String })], SplitButton.prototype, "mode", void 0);
-__decorate([property({
-	type: String,
-	attribute: `default-value`
-})], SplitButton.prototype, "defaultValue", void 0);
-__decorate([property({ attribute: false })], SplitButton.prototype, "itemsProvider", void 0);
-__decorate([property({ attribute: false })], SplitButton.prototype, "items", void 0);
-__decorate([query(`ixfx-menu-trigger`)], SplitButton.prototype, "_menuTrigger", void 0);
-__decorate([state()], SplitButton.prototype, "_compact", void 0);
-__decorate([state()], SplitButton.prototype, "_selectedCommand", void 0);
-__decorate([state()], SplitButton.prototype, "_selectedLabel", void 0);
-__decorate([state()], SplitButton.prototype, "_selectedIcon", void 0);
-__decorate([state()], SplitButton.prototype, "_switcherItems", void 0);
-__decorate([state()], SplitButton.prototype, "_dynamicItems", void 0);
-__decorate([state()], SplitButton.prototype, "_loadingItems", void 0);
-__decorate([state()], SplitButton.prototype, "_menuHasItems", void 0);
-SplitButton = __decorate([safeCustomElement(`ixfx-split-button`)], SplitButton);
-//#endregion
-//#region node_modules/.pnpm/@ixfx+collections@0.56.13/node_modules/@ixfx/collections/dist/StackMutable-B9Qm32K8.js
-const trimStack = (opts, stack, toAdd) => {
-	const potentialLength = stack.length + toAdd.length;
-	const policy = opts.discardPolicy ?? `additions`;
-	const capacity = opts.capacity ?? potentialLength;
-	const toRemove = potentialLength - capacity;
-	if (opts.debug) console.log(`Stack.push: stackLen: ${stack.length} potentialLen: ${potentialLength} toRemove: ${toRemove} policy: ${policy}`);
-	switch (policy) {
-		case `additions`:
-			if (opts.debug) console.log(`Stack.push:DiscardAdditions: stackLen: ${stack.length} slice: ${potentialLength - capacity} toAddLen: ${toAdd.length}`);
-			if (stack.length === opts.capacity) return stack;
-			else return [...stack, ...toAdd.slice(0, toAdd.length - toRemove)];
-		case `newer`: {
-			if (toAdd.length >= capacity) return toAdd.slice(toAdd.length - capacity);
-			const keepFromOld = capacity - toAdd.length;
-			return [...stack.slice(0, keepFromOld), ...toAdd];
-		}
-		case `older`: return [...stack, ...toAdd].slice(toRemove);
-		default: throw new Error(`Unknown discard policy ${policy}`);
-	}
-};
-const push = (opts, stack, ...toAdd) => {
-	const potentialLength = stack.length + toAdd.length;
-	return opts.capacity && potentialLength > opts.capacity ? trimStack(opts, stack, toAdd) : [...stack, ...toAdd];
-};
-const pop = (opts, stack) => {
-	if (stack.length === 0) throw new Error(`Stack is empty`);
-	return stack.slice(0, -1);
-};
-/**
-* Peek at the top of the stack (end of array)
-*
-* @typeParam V - Type of stored items
-* @param {StackOpts} opts
-* @param {V[]} stack
-* @returns {(V | undefined)}
-*/
-const peek = (opts, stack) => stack.at(-1);
-const isEmpty = (opts, stack) => stack.length === 0;
-const isFull = (opts, stack) => {
-	if (opts.capacity) return stack.length >= opts.capacity;
-	return false;
-};
-/**
-* Creates a stack. Mutable. Use {@link StackImmutable} for an immutable alternative.
-*
-* @example Basic usage
-* ```js
-* // Create
-* const s = new StackMutable();
-* // Add one or more items
-* s.push(1, 2, 3, 4);
-*
-* // See what's on top
-* s.peek;  // 4
-*
-* // Remove the top-most, and return it
-* s.pop();   // 4
-*
-* // Now there's a new top-most element
-* s.peek;  // 3
-* ```
-*/
-var StackMutable = class {
-	opts;
-	data;
-	/**
-	* Create a new StackMutable.
-	* 
-	* @param opts Options
-	* @param data Initial data to use
-	*/
-	constructor(opts = {}, data = []) {
-		this.opts = opts;
-		this.data = data;
-	}
-	/**
-	* Push data onto the stack.
-	* If `toAdd` is empty, nothing happens
-	* @param toAdd Data to add
-	* @returns Length of stack
-	*/
-	push(...toAdd) {
-		if (toAdd.length === 0) return this.data.length;
-		this.data = push(this.opts, this.data, ...toAdd);
-		return this.data.length;
-	}
-	/**
-	* Iterate from bottom to top. Note that `forEachFromTop` iterates from top to bottom, so this is the reverse.
-	* @param fn
-	*/
-	forEach(fn) {
-		this.data.forEach(fn);
-	}
-	/**
-	* Iterate from top to bottom. Note that `forEach` iterates from bottom to top, so this is the reverse.
-	* @param fn 
-	*/
-	forEachFromTop(fn) {
-		[...this.data].reverse().forEach(fn);
-	}
-	/**
-	* Pop the top-most item from the stack, and return it. If the stack is empty, returns _undefined_.
-	* @returns 
-	*/
-	pop() {
-		const v = peek(this.opts, this.data);
-		this.data = pop(this.opts, this.data);
-		return v;
-	}
-	/**
-	* Returns _true_ if the stack is empty, _false_ otherwise.
-	*/
-	get isEmpty() {
-		return isEmpty(this.opts, this.data);
-	}
-	/**
-	* Returns _true_ if the stack is full, _false_ otherwise. Note that a stack is only full if a `maxSize` option was provided at construction time.
-	*/
-	get isFull() {
-		return isFull(this.opts, this.data);
-	}
-	/**
-	* Returns the top-most item on the stack, without modifying the stack. If the stack is empty, returns _undefined_.
-	*/
-	get peek() {
-		return peek(this.opts, this.data);
-	}
-	/**
-	* Returns the number of items currently on the stack.
-	*/
-	get length() {
-		return this.data.length;
-	}
-};
-//#endregion
-//#region node_modules/.pnpm/@ixfx+collections@0.56.13/node_modules/@ixfx/collections/dist/tree-C6jGRTgK.js
-const compare$1 = (a, b, eq = isEqualValueIgnoreOrder, parent) => {
-	const valueEqual = valueOrIdentityEqual(a, b, eq);
-	const childrenCompare = compareChildren(a, b, eq);
-	const diff = {
-		valueChanged: !valueEqual,
-		a,
-		b,
-		added: childrenCompare.added,
-		removed: childrenCompare.removed,
-		childChanged: false
-	};
-	const diffNode = {
-		value: diff,
-		childrenStore: [],
-		parent
-	};
-	const childrenDiff = childrenCompare.identical.map((c) => compare$1(c[0], c[1], eq, diffNode));
-	const someChildChange = hasChange(diff) || childrenDiff.some((v) => hasChange(v.value));
-	setChildren(diffNode, childrenDiff);
-	diffNode.toString = () => toString$1(diffNode, 0);
-	diffNode.value.childChanged = someChildChange;
-	throwTreeTest(diffNode);
-	return diffNode;
-};
-const hasChange = (vv) => {
-	if (vv === void 0) return false;
-	if (vv.valueChanged) return true;
-	if (vv.childChanged) return true;
-	if (vv.added.length > 0) return true;
-	if (vv.removed.length > 0) return true;
-	return false;
-};
-const compareChildren = (a, b, eq = isEqualValueIgnoreOrder) => {
-	const childrenOfA = [...a.children()];
-	const childrenOfB = [...b.children()];
-	const identical = [];
-	const removed = [];
-	for (const childA of childrenOfA) {
-		let foundIndex = -1;
-		for (const [index, childOfB] of childrenOfB.entries()) if (valueOrIdentityEqual(childA, childOfB, eq)) {
-			identical.push([childA, childOfB]);
-			foundIndex = index;
-			break;
-		}
-		if (foundIndex === -1) removed.push(childA);
-		else childrenOfB.splice(foundIndex, 1);
-	}
-	return {
-		added: [...childrenOfB],
-		identical,
-		removed
-	};
-};
-const valueOrIdentityEqual = (a, b, eq) => {
-	if (a.getIdentity() === b.getIdentity()) return true;
-	if (eq(a.getValue(), b.getValue())) return true;
-	return false;
-};
-const toStringSingle = (n) => {
-	return JSON.stringify(n.getValue());
-};
-const toString$1 = (n, indent = 0) => {
-	if (n === void 0) return `(undefined)`;
-	let t = toStringDiff(n.value, indent);
-	for (const c of n.childrenStore) t += toString$1(c, indent + 2);
-	return t;
-};
-const toStringDiff = (n, indent) => {
-	const spaces = ` `.repeat(indent);
-	if (n === void 0) return `${spaces}(undefined)`;
-	const t = [];
-	t.push(`a: ${toStringSingle(n.a)} b: ${toStringSingle(n.b)}`);
-	if (n.valueChanged) t.push(`Value changed. Child changed: ${n.childChanged}`);
-	else t.push(`Value unchanged. Child changed: ${n.childChanged}`);
-	if (n.added.length > 0) {
-		t.push(`Added:`);
-		for (const c of n.added) t.push(` - ` + toStringSingle(c));
-	}
-	if (n.removed.length > 0) {
-		t.push(`Removed: ${n.removed.length}`);
-		for (const c of n.removed) t.push(` - ` + toStringSingle(c));
-	}
-	t.push(`----\n`);
-	return t.map((line) => spaces + line).join(`\n`);
-};
-var tree_mutable_exports = /* @__PURE__ */ __exportAll({
-	add: () => add,
-	addValue: () => addValue,
-	asDynamicTraversable: () => asDynamicTraversable$1,
-	breadthFirst: () => breadthFirst$2,
-	children: () => children$2,
-	childrenLength: () => childrenLength$1,
-	childrenValues: () => childrenValues,
-	compare: () => compare,
-	computeMaxDepth: () => computeMaxDepth,
-	createNode: () => createNode$1,
-	depthFirst: () => depthFirst$3,
-	findAnyChildByValue: () => findAnyChildByValue$2,
-	findChildByValue: () => findChildByValue$1,
-	findParentsValue: () => findParentsValue,
-	followValue: () => followValue$1,
-	fromPlainObject: () => fromPlainObject,
-	getRoot: () => getRoot,
-	hasAnyChild: () => hasAnyChild$1,
-	hasAnyParent: () => hasAnyParent$1,
-	hasChild: () => hasChild$1,
-	hasParent: () => hasParent$1,
-	nodeDepth: () => nodeDepth,
-	parents: () => parents$1,
-	parentsValues: () => parentsValues,
-	queryByValue: () => queryByValue,
-	queryParentsValue: () => queryParentsValue,
-	remove: () => remove$1,
-	removeValuelessNodesFromChild: () => removeValuelessNodesFromChild,
-	root: () => root$2,
-	rootWrapped: () => rootWrapped$1,
-	setChildren: () => setChildren,
-	siblings: () => siblings$2,
-	stripParentage: () => stripParentage,
-	throwTreeTest: () => throwTreeTest,
-	toStringDeep: () => toStringDeep$4,
-	treeTest: () => treeTest,
-	value: () => value,
-	wrap: () => wrap$1
-});
-/**
-* Compares two nodes.
-*
-* By default uses `isEqualValueIgnoreOrder` to compare nodes. This means
-* values of nodes will be compared, ignoring the order of fields.
-* @param a
-* @param b
-* @param eq Comparison function. Uses `isEqualValueIgnoreOrder` by default.
-* @returns Compare results
-*/
-function compare(a, b, eq) {
-	return compare$1(asDynamicTraversable$1(a), asDynamicTraversable$1(b), eq);
-}
-/**
-* Converts {@link Trees.TreeNode} to {@link Trees.SimplifiedNode}, removing the 'parent' fields.
-* This can be useful because if you have the whole tree, the parent field
-* is redundant and because it makes circular references can make dumping to console etc more troublesome.
-*
-* Recursive: strips parentage of all children and so on too.
-* @param node
-*/
-function stripParentage(node) {
-	return {
-		value: node.value,
-		childrenStore: node.childrenStore.map((c) => stripParentage(c))
-	};
-}
-const unwrapped = (node) => `wraps` in node ? node.wraps : node;
-const wrapped = (node) => `wraps` in node ? node : wrap$1(node);
-/**
-* Wraps node `n` for a more object-oriented means of access.
-* It will wrap child nodes on demand. For this reason, WrappedNode object
-* identity is not stable
-* @param n Node to wrap
-*/
-function wrap$1(n) {
-	return {
-		*children() {
-			for (const c of n.childrenStore) yield wrap$1(c);
-		},
-		getValue: () => n.value,
-		getIdentity: () => n,
-		*queryValue(value) {
-			for (const v of queryByValue(value, unwrapped(n))) yield wrap$1(v);
-		},
-		*queryParentsValue(child, value, eq) {
-			for (const v of queryParentsValue(unwrapped(child), value, eq)) yield wrap$1(v);
-		},
-		*parentsValues(child) {
-			yield* parentsValues(unwrapped(child));
-		},
-		findParentsValue(child, value, eq) {
-			const n = findParentsValue(child, value, eq);
-			if (n !== void 0) return wrap$1(n);
-		},
-		getParent: () => n.parent === void 0 ? void 0 : wrap$1(n.parent),
-		hasParent: (parent) => {
-			return hasParent$1(n, unwrapped(parent));
-		},
-		hasAnyParent: (parent) => {
-			return hasAnyParent$1(n, unwrapped(parent));
-		},
-		hasChild: (child) => {
-			return hasChild$1(unwrapped(child), n);
-		},
-		hasAnyChild: (child) => {
-			return hasAnyChild$1(unwrapped(child), n);
-		},
-		remove: () => {
-			remove$1(n);
-		},
-		addValue: (value) => {
-			return wrap$1(addValue(value, n));
-		},
-		add: (child) => {
-			add(unwrapped(child), n);
-			return wrapped(child);
-		},
-		wraps: n
-	};
-}
-/**
-* Removes `child` from the tree structure it is in.
-* It removes `child` from its parent. Any sub-children of `child` still remain connected.
-* @param child
-*/
-function remove$1(child) {
-	const p = child.parent;
-	if (p === void 0) return false;
-	child.parent = void 0;
-	const count = p.childrenStore.length;
-	p.childrenStore = without(p.childrenStore, child);
-	return count !== p.childrenStore.length;
-}
-/**
-* Starting from a child node, work backwards, removing it and ancestors that have no value
-*
-* If `child` is an only child, it will recursively call the same function on the parent.
-* @param child Child to start from
-*/
-function removeValuelessNodesFromChild(child) {
-	if (typeof child.value !== `undefined`) return false;
-	const parent = child.parent;
-	if (!parent) return false;
-	const sibs = [...siblings$2(child)];
-	remove$1(child);
-	if (sibs.length === 0) return removeValuelessNodesFromChild(parent);
-	return true;
-}
-/**
-* Enumeate all siblings of `child`. This won't include `child` itself.
-* If `child` is not part of a tree (ie has no parent) no values are yielded.
-*/
-function* siblings$2(child, eq = isEqualDefault) {
-	const parent = child.parent;
-	if (typeof parent === `undefined`) return;
-	for (const c of parent.childrenStore) {
-		if (eq(c, child)) continue;
-		yield c;
-	}
-}
-/**
-* Depth-first iteration of the children of `node`
-* @param node
-*/
-function* depthFirst$3(node) {
-	if (!root$2) return;
-	const stack = new StackMutable();
-	stack.push(...node.childrenStore);
-	let entry = stack.pop();
-	while (entry) {
-		yield entry;
-		if (entry) stack.push(...entry.childrenStore);
-		if (stack.isEmpty) break;
-		entry = stack.pop();
-	}
-}
-/**
-* Breadth-first iteration of the children of `node`
-* @param node
-*/
-function* breadthFirst$2(node) {
-	if (!node) return;
-	const queue = new QueueMutable();
-	queue.enqueue(...node.childrenStore);
-	let entry = queue.dequeue();
-	while (entry) {
-		yield entry;
-		if (entry) queue.enqueue(...entry.childrenStore);
-		if (queue.isEmpty) break;
-		entry = queue.dequeue();
-	}
-}
-/**
-* Validates the tree from `root` downwards.
-* @param root
-* @param seen
-*/
-function treeTest(root, seen = []) {
-	if (root.parent === root) return [
-		false,
-		`Root has itself as parent`,
-		root
-	];
-	if (seen.includes(root)) return [
-		false,
-		`Same node instance is appearing further in tree`,
-		root
-	];
-	seen.push(root);
-	if (containsDuplicateInstances(root.childrenStore)) return [
-		false,
-		`Children list contains duplicates`,
-		root
-	];
-	for (const c of root.childrenStore) {
-		if (c.parent !== root) return [
-			false,
-			`Member of childrenStore does not have .parent set`,
-			c
-		];
-		if (hasAnyChild$1(root, c)) return [
-			false,
-			`Child has parent as its own child`,
-			c
-		];
-		const v = treeTest(c, seen);
-		if (!v[0]) return v;
-	}
-	return [
-		true,
-		``,
-		root
-	];
-}
-/**
-* Throws an exception if `root` fails tree validation
-* @param root
-*/
-function throwTreeTest(root) {
-	const v = treeTest(root);
-	if (v[0]) return;
-	throw new Error(`${v[1]} Node: ${toStringAbbreviate(v[2].value, 30)}`, { cause: v[2] });
-}
-/**
-* Iterate over direct children of `root`, yielding {@link TreeNode} instances.
-* Use {@link childrenValues} to iterate over child values
-* @param root
-*/
-function* children$2(root) {
-	for (const c of root.childrenStore) yield c;
-}
-/**
-* Iterate over the value of direct children of `root`.
-* Use {@link children} if you want to iterate over {@link TreeNode} instances instead.
-* @param root
-*/
-function* childrenValues(root) {
-	for (const c of root.childrenStore) if (typeof c.value !== `undefined`) yield c.value;
-}
-/**
-* Iterate over all parents of `child`. First result is the immediate parent.
-* @param child
-*/
-function* parents$1(child) {
-	let p = child.parent;
-	while (p) {
-		yield p;
-		p = p.parent;
-	}
-}
-/**
-* Returns the depth of `node`. A root node (ie. with no parents) has a depth of 0.
-* @param node
-*/
-function nodeDepth(node) {
-	return [...parents$1(node)].length;
-}
-/**
-* Returns _true_ if `child` is an immediate child of `parent`.
-* @param child
-* @param parent
-* @param eq Equality function to compare nodes. Uses `isEqualDefault` by default, which compares by reference.
-*/
-function hasChild$1(child, parent, eq = isEqualDefault) {
-	for (const c of parent.childrenStore) if (eq(c, child)) return true;
-	return false;
-}
-/**
-* Returns the first immediate child of `parent` that matches `value`.
-*
-* Use {@link queryByValue} if you want all matching children.
-* @param value
-* @param parent
-* @param eq
-*/
-function findChildByValue$1(value, parent, eq = isEqualDefault) {
-	for (const c of parent.childrenStore) if (eq(value, c.value)) return c;
-}
-/**
-* Yield all immediate children of `parent` that match `value`.
-*
-* Use {@link findChildByValue} if you only want the first matching child.
-* @param value
-* @param parent
-* @param eq
-*/
-function* queryByValue(value, parent, eq = isEqualDefault) {
-	for (const c of parent.childrenStore) if (eq(value, c.value)) yield c;
-}
-/**
-* Returns _true_ if `prospectiveChild` is some child node of `parent`,
-* anywhere in the tree structure.
-*
-* Use {@link hasChild} to only check immediate children.
-* @param prospectiveChild
-* @param parent
-*/
-function hasAnyChild$1(prospectiveChild, parent) {
-	for (const c of breadthFirst$2(parent)) if (c === prospectiveChild) return true;
-	return false;
-}
-/**
-* Using a breadth-first search, return the first child of `parent` that has `value`.
-* @param value Value being sought
-* @param parent Parent node
-* @param eq Equality function to compare values. Uses `isEqualDefault` by default, which compares by reference.
-*/
-function findAnyChildByValue$2(value, parent, eq = isEqualDefault) {
-	for (const c of breadthFirst$2(parent)) if (eq(c.value, value)) return c;
-}
-/**
-* Traverses up a node to find the root.
-* @param node
-*/
-function getRoot(node) {
-	if (node.parent) return getRoot(node.parent);
-	return node;
-}
-/**
-* Returns _true_ if `prospectiveParent` is any ancestor
-* parent of `child`.
-*
-* Use {@link hasParent} to only check immediate parent.
-* @param child
-* @param prospectiveParent
-*/
-function hasAnyParent$1(child, prospectiveParent) {
-	for (const p of parents$1(child)) if (p === prospectiveParent) return true;
-	return false;
-}
-/**
-* Yields the node value of each parent of `child`.
-* _undefined_ values are not returned.
-*
-* Use {@link queryParentsValue} to search for a particular value
-* @param child
-*/
-function* parentsValues(child) {
-	for (const p of parents$1(child)) if (typeof p.value !== `undefined`) yield p.value;
-	return false;
-}
-/**
-* Yields all parents of `child` that have a given value.
-* Use {@link findParentsValue} to find the first match only.
-* @param child
-* @param value
-* @param eq
-*/
-function* queryParentsValue(child, value, eq = isEqualDefault) {
-	for (const p of parents$1(child)) if (typeof p.value !== `undefined`) {
-		if (eq(p.value, value)) yield p;
-	}
-	return false;
-}
-/**
-* Returns the first parent that has a given value.
-* @param child
-* @param value
-* @param eq
-*/
-function findParentsValue(child, value, eq = isEqualDefault) {
-	return [...queryParentsValue(child, value, eq)][0];
-}
-/**
-* Returns _true_ if `prospectiveParent` is the immediate
-* parent of `child`.
-*
-* Use {@link hasAnyParent} to check for any ancestor parent.
-* @param child
-* @param prospectiveParent
-*/
-function hasParent$1(child, prospectiveParent) {
-	return child.parent === prospectiveParent;
-}
-/**
-* Computes the maximum depth of the tree.
-* That is, how many steps down from `node` it can go.
-* If a tree is: root -> childA -> subChildB
-* ```js
-* // Yields 2, since there are at max two steps down from root
-* computeMaxDepth(root);
-* ```
-* @param node
-*/
-function computeMaxDepth(node) {
-	return computeMaxDepthImpl(node, 0);
-}
-function computeMaxDepthImpl(node, startingDepth = 0) {
-	let depth = startingDepth;
-	for (const c of node.childrenStore) depth = Math.max(depth, computeMaxDepthImpl(c, startingDepth + 1));
-	return depth;
-}
-/**
-* Adds a child node to `parent`.
-* If `child` already has a parent, it is removed from that parent.
-* @param child
-* @param parent
-* @throws Error if adding a child would break tree structure
-*/
-function add(child, parent) {
-	throwAttemptedChild(child, parent);
-	const p = child.parent;
-	parent.childrenStore = [...parent.childrenStore, child];
-	child.parent = parent;
-	if (p) p.childrenStore = without(p.childrenStore, child);
-}
-/**
-* Adds a new child node based on a value
-*/
-function addValue(value, parent) {
-	return createNode$1(value, parent);
-}
-/**
-* Creates the root for a tree, with an optional `value`.
-* Use {@link rootWrapped} if you want a more object-oriented mode of access.
-* @param value
-*/
-function root$2(value) {
-	return createNode$1(value);
-}
-function fromPlainObject(value, label = ``, parent, seen = []) {
-	const entries = Object.entries(value);
-	parent = parent === void 0 ? root$2() : addValue({
-		label,
-		value
-	}, parent);
-	for (const entry of entries) {
-		const value = entry[1];
-		if (seen.includes(value)) continue;
-		seen.push(value);
-		if (typeof entry[1] === `object`) fromPlainObject(value, entry[0], parent, seen);
-		else addValue({
-			label: entry[0],
-			value
-		}, parent);
-	}
-	return parent;
-}
-/**
-* Creates a tree, returning it as a {@link WrappedNode} for object-oriented access.
-* Use {@link Trees.Mutable.root} alternatively.
-* @param value
-*/
-function rootWrapped$1(value) {
-	return wrap$1(createNode$1(value));
-}
-/**
-* Creates a `TreeNode` instance with a given value and parent.
-* Parent node, if specified, has its `childrenStore` property changed to include new child.
-* @param value
-* @param parent
-*/
-function createNode$1(value, parent) {
-	const n = {
-		childrenStore: [],
-		parent,
-		value
-	};
-	if (parent !== void 0) parent.childrenStore = [...parent.childrenStore, n];
-	return n;
-}
-function childrenLength$1(node) {
-	return node.childrenStore.length;
-}
-function value(node) {
-	return node.value;
-}
-/**
-* Projects `node` as a dynamic traversable.
-* Dynamic in the sense that it creates the traversable project for nodes on demand.
-* A consequence is that node identities are not stable.
-* @param node
-*/
-function asDynamicTraversable$1(node) {
-	return {
-		*children() {
-			for (const c of node.childrenStore) yield asDynamicTraversable$1(c);
-		},
-		getParent() {
-			if (node.parent === void 0) return;
-			return asDynamicTraversable$1(node.parent);
-		},
-		getValue() {
-			return node.value;
-		},
-		getIdentity() {
-			return node;
-		}
-	};
-}
-/**
-* Throws an error if:
-* 1. `child` is the same node as `parent`
-* 2. `child` is already an immediate child of `parent`
-* 3. `child` is an ancestor parent of `parent`
-* 4. `child` has `parent` as its own child
-* @param c
-* @param parent
-*/
-function throwAttemptedChild(c, parent) {
-	if (parent === c) throw new Error(`Cannot add self as child`);
-	if (c.parent === parent) return;
-	if (hasAnyParent$1(parent, c)) throw new Error(`Child contains parent (1)`, { cause: c });
-	if (hasAnyParent$1(c, parent)) throw new Error(`Parent already contains child`, { cause: c });
-	if (hasAnyChild$1(parent, c)) throw new Error(`Child contains parent (2)`, { cause: c });
-}
-/**
-* Sets the children of `parent` to a list of `children`.
-*
-* Any previous children are disconnected from this parent.
-* All new children have their parent set to `parent`.
-*
-* There is some validation to ensure that adding the children doesn't break the tree.
-*/
-function setChildren(parent, children) {
-	for (const c of children) throwAttemptedChild(c, parent);
-	parent.childrenStore = [...children];
-	for (const c of children) c.parent = parent;
-}
-function toStringDeep$4(node, indent = 0) {
-	const t = `${`  `.repeat(indent)} + ${node.value ? JSON.stringify(node.value) : `-`}`;
-	return node.childrenStore.length > 0 ? `${t}\n${node.childrenStore.map((d) => toStringDeep$4(d, indent + 1)).join(`\n`)}` : t;
-}
-function* followValue$1(root, continuePredicate, depth = 1) {
-	for (const c of root.childrenStore) {
-		const value = c.value;
-		if (value === void 0) continue;
-		if (continuePredicate(value, depth)) {
-			yield c.value;
-			yield* followValue$1(c, continuePredicate, depth + 1);
-		}
-	}
-}
-var traverse_object_exports = /* @__PURE__ */ __exportAll({
-	asDynamicTraversable: () => asDynamicTraversable,
-	children: () => children$1,
-	create: () => create$1,
-	createSimplified: () => createSimplified,
-	createWrapped: () => createWrapped,
-	depthFirst: () => depthFirst$2,
-	getByPath: () => getByPath,
-	prettyPrint: () => prettyPrint,
-	prettyPrintEntries: () => prettyPrintEntries,
-	toStringDeep: () => toStringDeep$3,
-	traceByPath: () => traceByPath
-});
-/**
-* Helper function to get a 'friendly' string representation of an array of {@link TraverseObjectEntry}.
-* @param entries 
-* @returns 
-*/
-function prettyPrintEntries(entries) {
-	if (entries.length === 0) return `(empty)`;
-	let t = ``;
-	for (const [index, entry] of entries.entries()) {
-		t += `  `.repeat(index);
-		t += entry.name + ` = ` + JSON.stringify(entry.leafValue) + `\n`;
-	}
-	return t;
-}
-/**
-* Returns a human-friendly debug string for a tree-like structure
-* ```js
-* console.log(Trees.prettyPrint(obj));
-* ```
-* @param indent
-* @param node
-* @param options
-* @returns
-*/
-const prettyPrint = (node, indent = 0, options = {}) => {
-	resultThrow(nullUndefTest(node, `node`));
-	const entry = getNamedEntry(node, options.name ?? `node`);
-	const t = `${`  `.repeat(indent)} + name: ${entry.name} value: ${JSON.stringify(entry.leafValue)}`;
-	const childrenAsArray = [...children$1(node, options)];
-	return childrenAsArray.length > 0 ? t + `\n` + childrenAsArray.map((d) => prettyPrint(d.leafValue, indent + 1, {
-		...options,
-		name: d.name
-	})).join(`\n`) : t;
-};
-/**
-* Returns a debug string representation of the node (recursive)
-* @param node 
-* @param indent 
-* @returns 
-*/
-const toStringDeep$3 = (node, indent = 0) => {
-	let t = ` `.repeat(indent) + ` ${node.value?.name}`;
-	if (node.value !== void 0) {
-		if (`sourceValue` in node.value && `leafValue` in node.value) {
-			let sourceValue = toStringAbbreviate(node.value.sourceValue, 20);
-			const leafValue = toStringAbbreviate(node.value.leafValue, 20);
-			sourceValue = sourceValue === leafValue ? `` : `source: ` + sourceValue;
-			t += ` = ${leafValue} ${sourceValue}`;
-		} else if (`sourceValue` in node.value && node.value.sourceValue !== void 0) t += ` = ${node.value.sourceValue}`;
-		if (`ancestors` in node.value) t += ` (ancestors: ${node.value.ancestors.join(`, `)})`;
-	}
-	t += `\n`;
-	for (const c of node.childrenStore) t += toStringDeep$3(c, indent + 1);
-	return t;
-};
-/**
-* Yields the direct (ie. non-recursive) children of a tree-like object as a pairing
-* of node name and value. Supports basic objects, Maps and arrays.
-* 
-* To iterate recursively, consider {@link depthFirst}
-* 
-* Each child is returned in an {@link TraverseObjectEntry} structure:
-* ```typescript
-* type Entry = Readonly<{
-*  // Property name
-*  name: string, 
-*  // Value of property, as if you called `object[propertyName]`
-*  sourceValue: any,
-*  // Branch nodes will have _undefined_, leaf nodes will contain the value
-*  leafValue: any 
-* }>;
-* ```
-* 
-* For example, iterating over a flat object:
-* ```js
-* const verySimpleObject = { field: `hello`, flag: true }
-* const kids = [ ...children(verySimpleObject) ];
-* // Yields:
-* // [ { name: "field", sourceValue: `hello`, leafValue: `hello` },
-* //  { name: "flag", sourceValue: true, leafValue: true } ]
-* ```
-* 
-* For objects containing objects:
-* ```js
-* const lessSimpleObject = { field: `hello`, flag: true, colour: { `red`, opacity: 0.5 } }
-* const kids = [ ...children(verySimpleObject) ];
-* // Yields as before, plus:
-* //  { name: "colour", sourceValue: { name: 'red', opacity: 0.5 }, leafValue: undefined }
-* ```
-* 
-* Note that 'sourceValue' always contains the property value, as if you 
-* access it via `object[propName]`. 'leafValue' only contains the value if it's a leaf
-* node.
-* 
-* Arrays are assigned a name based on index.
-* @example Arrays
-* ```js
-* const colours = [ { r: 1, g: 0, b: 0 }, { r: 0, g: 1, b: 0 }, { r: 0, g: 0, b: 1 } ];
-* // Children: 
-* // [
-* //  { name: "array[0]", value: {r:1,g:0,b:0} },
-* //  { name: "array[1]", value: {r:0,g:1,b:0} },
-* //  { name: "array[2]", value: {r:0,g:0,b:1} },
-* // ]
-* ```
-* 
-* Pass in `options.name` (eg 'colours') to have names generated as 'colours[0]', etc.
-* Options can also be used to filter children. By default all direct children are returned.
-* @param node 
-* @param options  
-*/
-function* children$1(node, options = {}) {
-	resultThrow(nullUndefTest(node, `node`));
-	const filteringOption = options.filter ?? `none`;
-	const filterByValue = (v) => {
-		if (filteringOption === `none`) return [true, isPrimitive(v)];
-		else if (filteringOption === `leaves` && isPrimitive(v)) return [true, true];
-		else if (filteringOption === `branches` && !isPrimitive(v)) return [true, false];
-		return [false, isPrimitive(v)];
-	};
-	if (Array.isArray(node)) for (const [index, element] of node.entries()) {
-		const f = filterByValue(element);
-		if (f[0]) yield {
-			name: index.toString(),
-			_kind: `entry`,
-			sourceValue: element,
-			leafValue: f[1] ? element : void 0
-		};
-	}
-	else if (typeof node === `object`) {
-		const entriesIter = `entries` in node ? node.entries() : Object.entries(node);
-		for (const [name, value] of entriesIter) {
-			const [filter, isPrimitive] = filterByValue(value);
-			if (filter) yield {
-				name,
-				_kind: `entry`,
-				sourceValue: value,
-				leafValue: isPrimitive ? value : void 0
-			};
-		}
-	}
-}
-function* depthFirst$2(node, options = {}, ancestors = []) {
-	for (const c of children$1(node, options)) {
-		yield {
-			...c,
-			ancestors: [...ancestors],
-			_kind: `entry-ancestors`
-		};
-		yield* depthFirst$2(c.sourceValue, options, [...ancestors, c.name]);
-	}
-}
-/**
-* Finds a given direct child by name
-* @param name
-* @param node
-* @returns
-*/
-function childByName(name, node) {
-	for (const d of children$1(node)) if (d.name === name) return d;
-}
-/**
-* Returns the closest matching entry, tracing `path` in an array, Map or simple object.
-* Returns an entry with _undefined_ value at the point where tracing stopped.
-* Use {@link traceByPath} to step through all the segments.
-*
-* ```js
-* const people = {
-*  jane: {
-*   address: {
-*    postcode: 1000,
-*    street: 'West St',
-*    city: 'Blahville'
-*   },
-* colour: 'red'
-*  }
-* }
-* Trees.getByPath('jane.address.postcode', people); // '.' default separator
-* // ['postcode', 1000]
-* Trees.getByPath('jane.address.country.state', people);
-* // ['country', undefined] - since full path could not be resolved.
-* ```
-* @param path Path, eg `jane.address.postcode`
-* @param node Node to look within
-* @param options Options for parsing path. By default '.' is used as a separator
-* @returns
-*/
-function getByPath(path, node, options = {}) {
-	const v = last(traceByPath(path, node, options));
-	if (!v) throw new Error(`Could not trace path: ${path} `);
-	return v;
-}
-/**
-* Enumerates over children of `node` towards the node named in `path`.
-* This is useful if you want to get the interim steps to the target node.
-* 
-* Use {@link getByPath} if you don't care about interim steps.
-*
-* ```js
-* const people = {
-*  jane: {
-*   address: {
-*    postcode: 1000,
-*    street: 'West St',
-*    city: 'Blahville'
-*   },
-* colour: 'red'
-*  }
-* }
-* for (const p of Trees.traceByPath('jane.address.street', people)) {
-* // { name: "jane", value: { address: { postcode: 1000,street: 'West St', city: 'Blahville' }, colour: 'red'} },
-* // { name: "address", value: { postcode: 1000, street: 'West St', city: 'Blahville' } },
-* // { name: "street", value: "West St" } }
-* }
-* ```
-*
-* Results stop when the path can't be followed any further.
-* The last entry will have a name of the last sought path segment, and _undefined_ as its value.
-* 
-* @param path Path to traverse
-* @param node Starting node
-* @param options Options for path traversal logic
-* @returns
-*/
-function* traceByPath(path, node, options = {}) {
-	resultThrow(nullUndefTest(path, `path`), nullUndefTest(node, `node`));
-	const separator = options.separator ?? `.`;
-	const pathSplit = path.split(separator);
-	const ancestors = [];
-	for (const p of pathSplit) {
-		const entry = childByName(p, node);
-		if (!entry) {
-			yield {
-				name: p,
-				sourceValue: void 0,
-				leafValue: void 0,
-				ancestors,
-				_kind: `entry-ancestors`
-			};
-			return;
-		}
-		node = entry.sourceValue;
-		yield {
-			...entry,
-			ancestors: [...ancestors],
-			_kind: `entry-ancestors`
-		};
-		ancestors.push(p);
-	}
-}
-/**
-* Returns a projection of `node` as a dynamic traversable.
-* This means that the tree structure is dynamically created as last-minute as possible.
-* 
-* The type when calling `getValue()` is {@link TraverseObjectEntryStatic}:
-* ```typescript
-* type EntryStatic = Readonly<{ 
-*  name: string,
-*  value: any
-*  ancestors: string[] 
-* }>
-* ```
-* 
-* Note that the object identity of TraversableTree return results is not stable.
-* This is because they are created on-the-fly by reading fields of `node`.
-* 
-* ```js
-* const c1 = [ ...asDynamicTraversable(someObject).children() ];
-* const c2 = [ ...asDynamicTraversable(someObject).children() ];
-* 
-* // Object identity is not the same
-* c1[ 0 ] === c1[ 0 ]; // false
-* 
-* // ...even though its referring to the same value
-* c1[ 0 ].getValue() === c1[ 0 ].getValue(); // true
-* ```
-* 
-* Instead .getIdentity() to get a stable identity:
-* ```js
-* c1[ 0 ].getIdentity() === c2[ 0 ].getIdentity(); // true
-* ```
-* 
-* @example
-* ```js
-* const myObj = { name: `Pedro`, size: 45, colour: `orange` };
-* const root = Trees.FromObject.asDynamicTraversable(myObj);
-* for (const v of Trees.Traverse.breadthFirst(root)) {
-* // v.getValue() yields:
-* // { name: 'name', sourceValue: 'Pedro' ...}, 
-* // { name: 'size', sourceValue: 45 ... }
-* // ...
-* }
-* ```
-* @param node Object to read
-* @param options Options when creating traversable
-* @param ancestors Do not use
-* @param parent Do not use
-* @returns 
-*/
-const asDynamicTraversable = (node, options = {}, ancestors = [], parent) => {
-	const name = options.name ?? `object`;
-	const t = {
-		*children() {
-			for (const { name: childName, sourceValue, leafValue } of children$1(node, options)) yield asDynamicTraversable(sourceValue, {
-				...options,
-				name: childName
-			}, [...ancestors, name], t);
-		},
-		getParent() {
-			return parent;
-		},
-		getValue() {
-			return {
-				name,
-				sourceValue: node,
-				ancestors,
-				_kind: `entry-static`
-			};
-		},
-		getIdentity() {
-			return node;
-		}
-	};
-	return t;
-};
-/**
-* Reads all fields and sub-fields of `node`, returning as a 'wrapped' tree structure.
-* Is a snapshot of `node`, and won't update if it mutates.
-* @param node 
-* @param options 
-* @returns 
-*/
-const createWrapped = (node, options) => {
-	return wrap$1(create$1(node, options));
-};
-/**
-* Reads all fields and sub-fields of `node`, returning as a basic tree structure.
-* The structure is a snapshot of the object. If the object changes afterwards, the tree will
-* remain the same.
-* 
-* Alternatively, consider {@link asDynamicTraversable} which reads the object dynamically.
-* @example
-* ```js
-* const myObj = { name: `Pedro`, size: 45, colour: `orange` };
-* const root = Trees.FromObject.create(myObj);
-* for (const v of Trees.Traverse.breadthFirst(root)) {
-* // v.getValue() yields:
-* // { name: 'name', sourceValue: 'Pedro' ...}, 
-* // { name: 'size', sourceValue: 45 ... }
-* // ...
-* }
-* ```
-* @param node 
-* @param options 
-* @returns 
-*/
-const create$1 = (node, options = {}) => {
-	return createImpl(node, (options.valuesAtLeaves ?? false ? (v) => {
-		if (isPrimitive(v)) return v;
-	} : (v) => v)(node), options, []);
-};
-const createImpl = (sourceValue, leafValue, options = {}, ancestors) => {
-	const defaultName = options.name ?? `object_ci`;
-	const r = root$2({
-		name: defaultName,
-		sourceValue: leafValue,
-		ancestors: [...ancestors],
-		_kind: `entry-static`
-	});
-	ancestors = [...ancestors, defaultName];
-	for (const c of children$1(sourceValue, options)) {
-		const v = options.valuesAtLeaves ? c.leafValue : c.sourceValue;
-		add(createImpl(c.sourceValue, v, {
-			...options,
-			name: c.name
-		}, ancestors), r);
-	}
-	return r;
-};
-/**
-* Returns a copy of `node` with its (and all its childrens') parent information removed.
-* 
-* Under the hood:
-* ```js
-* TreeArrayBacked.stripParentage(create(node, options));
-* ```
-* @param node 
-* @param options 
-* @returns 
-*/
-const createSimplified = (node, options = {}) => {
-	return stripParentage(create$1(node, options));
-};
-/**
-* Generates a name for a node.
-* Uses the 'name' property if it exists, otherwise uses `defaultName`
-* @param node
-* @param defaultName
-* @returns
-*/
-function getNamedEntry(node, defaultName = ``) {
-	if (`name` in node && `leafValue` in node && `sourceValue` in node) return {
-		name: node.name,
-		_kind: `entry`,
-		leafValue: node.leafValue,
-		sourceValue: node.sourceValue
-	};
-	if (`name` in node) return {
-		name: node.name,
-		leafValue: node,
-		sourceValue: node,
-		_kind: `entry`
-	};
-	return {
-		name: defaultName,
-		leafValue: node,
-		sourceValue: node,
-		_kind: `entry`
-	};
-}
-function isSingleValue(v) {
-	if (`value` in v) return true;
-	return false;
-}
-function isMultiValue(v) {
-	if (`values` in v) return Array.isArray(v.values);
-	return false;
-}
-var pathed_exports = /* @__PURE__ */ __exportAll({
-	Pathed: () => Pathed,
-	addValueByPath: () => addValueByPath,
-	children: () => children,
-	childrenLengthByPath: () => childrenLengthByPath,
-	clearValuesByPath: () => clearValuesByPath,
-	findAnyChildByValue: () => findAnyChildByValue$1,
-	hasValue: () => hasValue,
-	parent: () => parent,
-	parentValues: () => parentValues,
-	removeValueByPath: () => removeValueByPath,
-	siblings: () => siblings$1,
-	siblingsValues: () => siblingsValues,
-	toStringDeep: () => toStringDeep$2,
-	valueByPath: () => valueByPath,
-	valuesByPath: () => valuesByPath
-});
-/**
-* Creates a wrapper for working with 'pathed' trees.
-* An example is a filesystem.
-*
-* ```js
-* const t = new Pathed();
-* // Store a value. Path implies a structure of
-* //   c -> users -> admin
-* // ...which is automatically created
-* t.add({x:10}, `c.users.admin`);
-*
-* t.add({x:20}, `c.users.guest`);
-* // Tree will now be:
-* // c-> users -> admin
-* //            -> guest
-*
-* t.getValue(`c.users.guest`); // { x:20 }
-* ```
-*
-* By default only a single value can be stored at a path.
-* Set options to allow this:
-* ```js
-* const t = new Pathed({ duplicates: `allow` });
-* t.add({x:10}, `c.users.admin`);
-* t.add({x:20}, `c.users.admin`);
-* t.getValue(`c.users.admin`);   // Throws an error because there are multiple values
-* t.getValues(`c.users.admin`);  // [ {x:10}, {x:20 } ]
-* ```
-* @param pathOpts
-* @returns
-*/
-var Pathed = class {
-	#root;
-	#pathOpts;
-	/**
-	* Create, using default options
-	* @param pathOpts
-	*/
-	constructor(pathOpts = {}) {
-		this.#pathOpts = {
-			separator: `.`,
-			startsWithSeparator: false,
-			duplicates: `overwrite`,
-			...pathOpts
-		};
-	}
-	/**
-	* Adds a value at the string path, automatically creating intermediate nodes as needed.
-	* By default, if a value already exists at the path, it will be overwritten. Set options to change this.
-	* @param value Value to associate with path
-	* @param path Path
-	*/
-	add(value, path) {
-		throwIfFailed(this.validate(path));
-		const n = addValueByPath(value, path, this.#pathOpts, this.#root);
-		if (this.#root === void 0) this.#root = getRoot(n);
-	}
-	validate(path) {
-		if (this.#pathOpts.startsWithSeparator && !path.startsWith(this.#pathOpts.separator)) return {
-			success: false,
-			error: `Path must start with separator when 'startsWithSeparator' is enabled. Got: ${path}`
-		};
-		return {
-			success: true,
-			value: path
-		};
-	}
-	/**
-	* Returns a string representation of tree
-	* @returns Returns a string representation of tree
-	*/
-	prettyPrint() {
-		if (this.#root === void 0) return `(empty)`;
-		return toStringDeep$4(this.#root);
-	}
-	/**
-	* Removes the value at the given path, returning _true_
-	* if there was a value. This will delete tree nodes if they become empty
-	* @param path
-	* @returns _true_ if value was removed
-	*/
-	remove(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return false;
-		return removeValueByPath(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Returns _true_ if we have a value at `path`
-	* @param path
-	* @returns _true_ if value exists at path
-	*/
-	hasPath(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return false;
-		return findChildByPath(path, this.#root, this.#pathOpts) !== void 0;
-	}
-	/**
-	* Returns a tree node for a given path, or _undefined_
-	* if path does not exist.
-	*
-	* Use {@link getValue} to get the value at a node instead.
-	* @param path
-	* @returns The tree node for the given path, or _undefined_ if not found
-	*/
-	getNode(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return;
-		return findChildByPath(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Returns the value at the path, or _undefined_ if path is not found.
-	* Use {@link getNode} to get the tree node instead.
-	* @param path
-	* @returns The value at the path, or _undefined_ if path is not found
-	*/
-	getValue(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return;
-		return valueByPath(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Gets the containing path to `node`. If _includeNode_ is true, we also include the
-	* node's own label.
-	*/
-	getPath(node, includeNode) {
-		if (this.#root === void 0) return ``;
-		const segments = [];
-		if (includeNode && node.value) segments.push(node.value?.label);
-		for (const p of parentValues(node)) segments.unshift(p.label);
-		let path = segments.join(this.#pathOpts.separator);
-		if (this.#pathOpts.startsWithSeparator) {
-			if (!path.startsWith(this.#pathOpts.separator)) path = this.#pathOpts.separator + path;
-			if (!path.endsWith(this.#pathOpts.separator) && (node.childrenStore.length > 0 || !includeNode)) path += this.#pathOpts.separator;
-		}
-		return path;
-	}
-	/**
-	* Gets the number of children at a given path.
-	* Returns NaN if path does not exist or has no children.
-	* @param path
-	* @returns The number of children at the path, or NaN if path is not found
-	*/
-	childrenLength(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return NaN;
-		const c = findChildByPath(path, this.#root, this.#pathOpts);
-		if (c === void 0) return NaN;
-		return c.childrenStore.length;
-	}
-	/**
-	* Get all the values stored at a path, if multiple values are allowed. Returns an empty array if path does not exist or has no value.
-	* @param path
-	* @returns An array of values at the path, or an empty array if path is not found
-	*/
-	getValues(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return void 0;
-		return valuesByPath(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Removes all values at the given path, but leaves the structure of the tree intact. Returns _true_ if there was a value to clear.
-	* @param path
-	* @returns _true_ if there was a value to clear at the path
-	*/
-	clearValues(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return false;
-		return clearValuesByPath(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Iterate all children of this path
-	*/
-	*children(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return;
-		yield* children(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Iterate all siblings of this path
-	*/
-	*siblings(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return;
-		yield* siblings$1(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Iterate all siblings of this path
-	*/
-	*siblingsValues(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return;
-		yield* siblingsValues(path, this.#root, this.#pathOpts);
-	}
-	/**
-	* Returns the parent node of `path`, or _undefined_ if not found or at root.
-	*/
-	parent(path) {
-		throwIfFailed(this.validate(path));
-		if (this.#root === void 0) return;
-		return parent(path, this.#root, this.#pathOpts);
-	}
-	get separator() {
-		return this.#pathOpts.separator;
-	}
-	/**
-	* Returns the root tree node.
-	* @returns   The root tree node, or _undefined_ if tree is empty
-	*/
-	get root() {
-		return this.#root;
-	}
-};
-/**
-* Adds a value by a string path, with '.' as a the default delimiter
-* Automatically generates intermediate nodes.
-*
-* ```js
-* const root = addValueByPath({}, 'c');
-* addValueByPath({x:'blah'}, 'c.users.admin', root);
-* ```
-*
-* Creates the structure:
-* ```
-* c          value: { }            label: c
-* + users    value: undefined      label: users
-*  + admin   value: { x: 'blah' }  label: admin
-* ```
-*
-* By default, multiple values under same key are overwritten, with the most recent winning.
-* @param value Value to add
-* @param path Path to add at
-* @param node Node to insert
-* @param pathOpts Options
-*/
-function addValueByPath(value, path, pathOpts, node) {
-	const separator = pathOpts.separator;
-	const duplicatePath = pathOpts.duplicates;
-	const split = path.split(separator);
-	let count = 0;
-	for (const p of split) {
-		const lastEntry = count === split.length - 1;
-		const found = findChildByLabel(p, node);
-		if (found === void 0) node = createNode$1({
-			value: lastEntry ? value : void 0,
-			label: p
-		}, node);
-		else {
-			node = found;
-			if (lastEntry) switch (duplicatePath) {
-				case `ignore`: break;
-				case `allow`: {
-					const existing = getValuesFromNode(node);
-					node.value = {
-						values: [...existing, value],
-						label: p
-					};
-					break;
-				}
-				case `overwrite`:
-					node.value = {
-						value,
-						label: p
-					};
-					break;
-			}
-			else node = found;
-		}
-		count++;
-	}
-	if (node === void 0) throw new Error(`Could not create tree`);
-	return node;
-}
-/**
-* Removes the value at the given path, returning _true_ if there was something to remove.
-* @param node
-* @returns _true_ if something removed
-*/
-function isLabelledNodeEmpty(node) {
-	if (node.value === void 0) return true;
-	if (`values` in node.value) return node.value.values.length === 0;
-	if (`value` in node.value) return node.value.value === void 0;
-	return true;
-}
-function pruneLabelledBranch(node) {
-	if (node.childrenStore.length > 0) return;
-	if (!isLabelledNodeEmpty(node)) return;
-	const parent = node.parent;
-	if (!parent) return;
-	remove$1(node);
-	pruneLabelledBranch(parent);
-}
-function removeValueByPath(path, root, pathOpts) {
-	if (root === void 0) return false;
-	const c = findChildByPath(path, root, pathOpts);
-	if (c === void 0) return false;
-	c.value = void 0;
-	pruneLabelledBranch(c);
-	return true;
-}
-function clearValuesByPath(path, root, pathOpts) {
-	if (root === void 0) return false;
-	const c = findChildByPath(path, root, pathOpts);
-	if (c === void 0) return false;
-	c.value = {
-		label: c.value?.label ?? ``,
-		value: void 0
-	};
-	return true;
-}
-/**
-* Return the length of children of `path`, or NaN if path not found.
-*/
-function childrenLengthByPath(path, searchStart, pathOpts) {
-	if (searchStart === void 0) return NaN;
-	const c = findChildByPath(path, searchStart, pathOpts);
-	if (c === void 0) return NaN;
-	return c.childrenStore.length;
-}
-/**
-* Iterate over all the children of `path`
-*/
-function* children(path, searchStart, pathOpts) {
-	if (searchStart === void 0) return;
-	const c = findChildByPath(path, searchStart, pathOpts);
-	if (c === void 0) return;
-	for (const ch of c.childrenStore) yield ch;
-}
-/**
-* Iterate over all the siblings of `path`, excluding the node at `path` itself.
-* Yields LabelledNode instances, which allow you to traverse tree. If all you care about is the values, use {@link siblingsValues} instead.
-*/
-function* siblings$1(path, searchStart, pathOpts) {
-	if (searchStart === void 0) return;
-	const c = findChildByPath(path, searchStart, pathOpts);
-	if (c === void 0) return;
-	const parent = c.parent;
-	if (parent === void 0) return;
-	for (const ch of parent.childrenStore) {
-		if (ch === c) continue;
-		if (typeof ch === `undefined`) throw new TypeError(`Unexpected undefined child node`);
-		yield ch;
-	}
-}
-/**
-* Iterate over the values of all the siblings of `path`, excluding the node at `path` itself. If you need to traverse tree, use {@link siblings} instead.
-* @param path
-* @param searchStart
-* @param pathOpts
-*/
-function* siblingsValues(path, searchStart, pathOpts) {
-	for (const s of siblings$1(path, searchStart, pathOpts)) {
-		if (s.value === void 0) continue;
-		yield s.value;
-	}
-}
-/**
-* Return the parent node of `path`, or undefined if not found or at root.
-*/
-function parent(path, searchStart, pathOpts) {
-	if (searchStart === void 0) return;
-	const c = findChildByPath(path, searchStart, pathOpts);
-	if (c === void 0) return;
-	return c.parent;
-}
-function* parentValues(start) {
-	for (const p of parents$1(start)) {
-		if (p.value === void 0) continue;
-		yield p.value;
-	}
-}
-/**
-* Searches direct children, returning the node that has the given `label`
-* @param label
-* @param node
-* @returns Child node, or _undefined_
-*/
-function findChildByLabel(label, node) {
-	if (node === void 0) return void 0;
-	if (label === void 0) throw new Error(`Parameter 'label' cannot be undefined`);
-	if (node.value?.label === label) return node;
-	for (const c of node.childrenStore) if (c.value?.label === label) return c;
-}
-/**
-* Searches children, returning the node that has the given `value`.
-* @param value Value
-* @param node Node to start search from
-* @param maxDepth Maximum depth, defaults to full recursion
-* @param eq Equality function
-* @returns Child, or _undefined_ if not found
-*/
-function findAnyChildByValue$1(value, node, maxDepth = Number.MAX_SAFE_INTEGER, eq = isEqualValueDefault) {
-	if (typeof node === `undefined`) throw new TypeError(`Param 'node' is undefined`);
-	if (maxDepth <= 0) return;
-	if (typeof value === `undefined`) throw new Error(`Param 'value' cannot be undefined`);
-	for (const c of node.childrenStore) if (hasValue(value, c, eq)) return c;
-	for (const c of node.childrenStore) {
-		const result = findAnyChildByValue$1(value, c, maxDepth - 1, eq);
-		if (typeof result !== `undefined`) return result;
-	}
-}
-function hasValue(value, node, eq = isEqualDefault) {
-	if (typeof node.value === `undefined`) return false;
-	if (isSingleValue(node.value)) {
-		if (eq(node.value.value, value)) return true;
-	} else if (isMultiValue(node.value)) {
-		for (const v of node.value.values) if (eq(v, value)) return true;
-	}
-	return false;
-}
-function valueByPath(path, node, pathOpts = {}) {
-	const values = valuesByPath(path, node, pathOpts);
-	if (typeof values === `undefined`) return;
-	if (values.length === 0) return void 0;
-	if (values.length > 1) throw new Error(`Multiple values at path. Use getValues instead`);
-	return values[0];
-}
-function getValuesFromNode(node) {
-	if (node.value === void 0) return [];
-	if (`values` in node.value) return node.value.values;
-	if (`value` in node.value) {
-		if (node.value.value === void 0) return [];
-		return [node.value.value];
-	}
-	return [];
-}
-function findChildByPath(path, searchStart, pathOpts) {
-	if (path.endsWith(pathOpts.separator) && pathOpts.startsWithSeparator) path = path.slice(0, -pathOpts.separator.length);
-	const split = path.split(pathOpts.separator);
-	let c = searchStart;
-	for (const p of split) {
-		c = findChildByLabel(p, c);
-		if (c === void 0) return;
-	}
-	return c;
-}
-function valuesByPath(path, searchStart, pathOpts = {}) {
-	const separator = pathOpts.separator ?? `.`;
-	const split = path.split(separator);
-	let c = searchStart;
-	for (const p of split) {
-		c = findChildByLabel(p, c);
-		if (c === void 0) return;
-	}
-	return getValuesFromNode(c);
-}
-function formatInspectValue(v) {
-	if (v === void 0) return `undefined`;
-	if (v === null) return `null`;
-	if (typeof v === `string`) return `"${v}"`;
-	if (typeof v === `number` || typeof v === `boolean`) return String(v);
-	if (Array.isArray(v)) {
-		if (v.length === 0) return `[]`;
-		return `[ ${v.map(formatInspectValue).join(`, `)} ]`;
-	}
-	if (typeof v === `object`) return `{ ${Object.entries(v).map(([k, val]) => `${k}: ${formatInspectValue(val)}`).join(`, `)} }`;
-	return String(v);
-}
-/**
-* Returns a string representation of a LabelledNode tree.
-* Format: `{ label: "x", value: ..., children: [...] }`
-*/
-function toStringDeep$2(node) {
-	const label = node.value?.label ?? `?`;
-	const innerValue = node.value === void 0 ? void 0 : `values` in node.value ? node.value.values : `value` in node.value ? node.value.value : void 0;
-	const children = node.childrenStore.map((c) => toStringDeep$2(c));
-	const childrenStr = children.length === 0 ? `[]` : `[ ${children.join(`, `)} ]`;
-	return `{ label: "${label}", value: ${formatInspectValue(innerValue)}, children: ${childrenStr} }`;
-}
-var traversable_tree_exports = /* @__PURE__ */ __exportAll({
-	breadthFirst: () => breadthFirst$1,
-	childrenLength: () => childrenLength,
-	couldAddChild: () => couldAddChild,
-	depthFirst: () => depthFirst$1,
-	find: () => find$2,
-	findAnyChildByValue: () => findAnyChildByValue,
-	findAnyParentByValue: () => findAnyParentByValue,
-	findByValue: () => findByValue,
-	findChildByValue: () => findChildByValue,
-	findParentByValue: () => findParentByValue,
-	followValue: () => followValue,
-	hasAnyChild: () => hasAnyChild,
-	hasAnyChildValue: () => hasAnyChildValue,
-	hasAnyParent: () => hasAnyParent,
-	hasAnyParentValue: () => hasAnyParentValue,
-	hasChild: () => hasChild,
-	hasChildValue: () => hasChildValue,
-	hasParent: () => hasParent,
-	hasParentValue: () => hasParentValue,
-	parents: () => parents,
-	siblings: () => siblings,
-	toString: () => toString,
-	toStringDeep: () => toStringDeep$1
-});
-/**
-* Returns the number of children of `tree`.
-* Under the hood is just `[ ...tree.children() ].length`
-* @param tree 
-* @returns 
-*/
-const childrenLength = (tree) => {
-	return [...tree.children()].length;
-};
-/**
-* Returns _true_ if `child` is parented at any level (grand-parented etc) by `possibleParent`
-* @param child Child being sought
-* @param possibleParent Possible parent of child
-* @param eq Equality comparison function {@link isEqualDefault} used by default
-* @returns
-*/
-const hasAnyParent = (child, possibleParent, eq) => {
-	return hasParent(child, possibleParent, eq, Number.MAX_SAFE_INTEGER);
-};
-/**
-* Returns _true_ if `child` is parented at any level (grand-parented etc) by a parent with value `possibleParentValue`
-* @param child Child being sought
-* @param possibleParentValue Value of possible parent of child
-* @param eq Equality comparison function {@link isEqualDefault} used by default
-* @throws TypeError if `child` is undefined
-* @returns
-*/
-const hasAnyParentValue = (child, possibleParentValue, eq) => {
-	if (typeof child === `undefined`) throw new TypeError(`Param 'child' is undefined`);
-	return hasParentValue(child, possibleParentValue, eq, Number.MAX_SAFE_INTEGER);
-};
-/**
-* Returns any parent of `child` that has value `possibleParentValue`. Returns _undefined_ if not found.
-* @param child Child being sought
-* @param possibleParentValue Value of possible parent of child
-* @param eq Equality comparison function {@link isEqualDefault} used by default
-* @returns
-*/
-const findAnyParentByValue = (child, possibleParentValue, eq) => {
-	return findParentByValue(child, possibleParentValue, eq, Number.MAX_SAFE_INTEGER);
-};
-/**
-* Returns _true_ if `child` exists within `possibleParent`. By default it only looks at the immediate
-* parent (maxDepth: 0). Use Number.MAX_SAFE_INTEGER for searching recursively upwards (or {@link hasAnyParent})
-* @param child Child being sought
-* @param possibleParent Possible parent of child
-* @param maxDepth Max depth of traversal. Default of 0 only looks for immediate parent.
-* @param eq Equality comparison function. {@link isEqualDefault} used by default.
-* @returns
-*/
-const hasParent = (child, possibleParent, eq = isEqualDefault, maxDepth = 0) => {
-	if (maxDepth < 0) return false;
-	const isChildTrav = isTraversable(child);
-	const isParentTrav = isTraversable(possibleParent);
-	const p = isChildTrav ? child.getParent() : child.parent;
-	if (typeof p === `undefined`) return false;
-	if (eq(p, possibleParent)) return true;
-	if (eq(isChildTrav ? p.getIdentity() : p.value, isParentTrav ? possibleParent.getIdentity() : possibleParent.value)) return true;
-	return hasParent(p, possibleParent, eq, maxDepth - 1);
-};
-/**
-* Checks if a child node has a parent with a certain value
-* Note: by default only checks immediate parent. Set maxDepth to a large value to recurse
-* 
-* Uses `getValue()` on the parent if that function exists.
-* @param child Node to start looking from
-* @param possibleParentValue Value to seek
-* @param eq Equality checker
-* @param maxDepth Defaults to 0, so it only checks immediate parent
-* @returns 
-*/
-const hasParentValue = (child, possibleParentValue, eq = isEqualDefault, maxDepth = 0) => {
-	if (child === void 0) throw new Error(`Param 'child' is undefined`);
-	if (maxDepth < 0) return false;
-	const p = `getParent` in child ? child.getParent() : child.parent;
-	if (p === void 0) return false;
-	if (eq(`getValue` in p ? p.getValue() : p.value, possibleParentValue)) return true;
-	return hasParentValue(p, possibleParentValue, eq, maxDepth - 1);
-};
-/**
-* Returns any parent of `child` that has value `possibleParentValue`. Returns _undefined_ if not found.
-* @param child Child being sought
-* @param possibleParentValue Value of possible parent of child
-* @param eq Equality comparison function {@link isEqualDefault} used by default
-* @param maxDepth Maximum depth of traversal. Default of 0 only looks for immediate parent.
-* @returns 
-*/
-const findParentByValue = (child, possibleParentValue, eq = isEqualDefault, maxDepth = 0) => {
-	if (maxDepth < 0) return;
-	const p = `getParent` in child ? child.getParent() : child.parent;
-	if (p === void 0) return;
-	if (eq(`getValue` in p ? p.getValue() : p.value, possibleParentValue)) return p;
-	return findParentByValue(p, possibleParentValue, eq, maxDepth - 1);
-};
-/**
-* Returns _true_ if `prospectiveChild` can be legally added to `parent`.
-* _False_ is returned if:
-*  * `parent` and `prospectiveChild` are equal
-*  * `parent` already contains `prospectiveChild`
-*  * `prospectiveChild` has `parent` as its own child
-*
-* Throws an error if `parent` or `prospectiveChild` is null/undefined.
-* @param parent Parent to add to
-* @param prospectiveChild Prospective child
-* @param eq Equality function
-*/
-const couldAddChild = (parent, prospectiveChild, eq = isEqualDefault) => {
-	if (eq(parent, prospectiveChild)) throw new Error(`Child equals parent`);
-	if (hasAnyChild(parent, prospectiveChild, eq)) throw new Error(`Circular. Parent already has child`);
-	if (hasAnyChild(prospectiveChild, parent, eq)) throw new Error(`Prospective child has parent as child relation`);
-};
-/**
-* Returns _true_ if _possibleChild_ is contained within _parent_ tree.
-* That is, it is any sub-child.
-* @param parent Parent tree
-* @param possibleChild Sought child
-* @param eq Equality function, or {@link isEqualDefault} if undefined.
-* @returns
-*/
-const hasAnyChild = (parent, possibleChild, eq = isEqualDefault) => {
-	return hasChild(parent, possibleChild, eq, Number.MAX_SAFE_INTEGER);
-};
-/**
-* Returns _true_ if `parent` has any child with value `possibleChildValue`. It explores
-* at children at any depth from `parent`.
-* @param parent 
-* @param possibleChildValue 
-* @param eq 
-* @returns 
-*/
-const hasAnyChildValue = (parent, possibleChildValue, eq = isEqualDefault) => {
-	return hasChildValue(parent, possibleChildValue, eq, Number.MAX_SAFE_INTEGER);
-};
-/**
-* Returns _true_ if _possibleChild_ is contained within _maxDepth_ children
-* of _parent_ node. By default only looks at immediate children (maxDepth = 0).
-*
-* ```js
-* // Just check parentNode for childNode
-* Trees.hasChild(parentNode, childNode);
-* // See if parentNode or parentNode's parents have childNode
-* Trees.hasChild(parentNode, childNode, 1);
-* // Use custom equality function, in this case comparing on name field
-* Trees.hasChild(parentNode, childNode, 0, (a, b) => a.name === b.name);
-* ```
-* @param parent Parent tree
-* @param possibleChild Sought child
-* @param maxDepth Maximum depth. 0 for immediate children, Number.MAX_SAFE_INTEGER for boundless
-* @param eq Equality function, or {@link isEqualDefault} if undefined.
-* @returns
-*/
-const hasChild = (parent, possibleChild, eq = isEqualDefault, maxDepth = 0) => {
-	if (maxDepth < 0) return false;
-	if (eq(parent, possibleChild)) return true;
-	const pId = `getIdentity` in parent ? parent.getIdentity() : parent.value;
-	const pcId = `getIdentity` in possibleChild ? possibleChild.getIdentity() : possibleChild.value;
-	if (eq(pId, pcId)) return true;
-	for (const c of breadthFirst$1(parent, maxDepth)) {
-		const cId = `getIdentity` in c ? c.getIdentity() : c.value;
-		if (eq(c, possibleChild)) return true;
-		if (eq(cId, pcId)) return true;
-	}
-	return false;
-};
-/**
-* Returns _true_ if `parent` has any child with value `possibleChildValue`. It explores
-* at children up to `maxDepth` from `parent`. By default only looks at immediate children (maxDepth = 0).
-* @param parent 
-* @param possibleValue 
-* @param eq 
-* @param maxDepth 
-* @returns 
-*/
-const hasChildValue = (parent, possibleValue, eq = isEqualDefault, maxDepth = 0) => {
-	if (maxDepth < 0) return false;
-	if (eq(parent.getValue(), possibleValue)) return true;
-	for (const c of breadthFirst$1(parent, maxDepth)) if (eq(c.getValue(), possibleValue)) return true;
-	return false;
-};
-/**
-* Iterates over siblings of `node`.
-* 
-* Other iteration options:
-* * {@link breadthFirst}: Children, breadth-first
-* * {@link depthFirst}: Children, depth-first
-* * {@link parents}: Chain of parents, starting with immediate parent
-* * {@link siblings}: Nodes with same parent
-* @param node Node to begin from
-* @returns 
-*/
-function* siblings(node) {
-	const p = node.getParent();
-	if (p === void 0) return;
-	for (const s of p.children()) {
-		if (s === node) continue;
-		yield s;
-	}
-}
-/**
-* Iterates over parents of `node`, starting with immediate parent
-* 
-* Other iteration options:
-* * {@link breadthFirst}: Children, breadth-first
-* * {@link depthFirst}: Children, depth-first
-* * {@link parents}: Chain of parents, starting with immediate parent
-* * {@link siblings}: Nodes with same parent
-* @param node Node to begin from
-* @returns 
-*/
-function* parents(node) {
-	if (isTraversable(node)) {
-		let p = node.getParent();
-		while (p !== void 0) {
-			yield p;
-			p = p.getParent();
-		}
-	} else {
-		let p = node.parent;
-		while (p !== void 0) {
-			yield p;
-			p = p.parent;
-		}
-	}
-}
-/**
-* Descends `parent`, breadth-first, looking for a particular value.
-* Returns _undefined_ if not found.
-* @param parent 
-* @param possibleValue 
-* @param eq 
-* @returns 
-*/
-function findAnyChildByValue(parent, possibleValue, eq = isEqualDefault) {
-	return findChildByValue(parent, possibleValue, eq, Number.MAX_SAFE_INTEGER);
-}
-/**
-* Searches breadth-first for `possibleValue` under and including `parent`.
-* `maxDepth` sets he maximum level to which the tree is searched.
-* @param parent 
-* @param possibleValue 
-* @param eq 
-* @param maxDepth 
-* @returns 
-*/
-function findChildByValue(parent, possibleValue, eq = isEqualDefault, maxDepth = 0) {
-	if (maxDepth < 0) return;
-	const isTraver = isTraversable(parent);
-	if (isTraver) {
-		if (eq(parent.getValue(), possibleValue)) return parent;
-	} else if (eq(parent.value, possibleValue)) return parent;
-	for (const d of breadthFirst$1(parent, maxDepth)) if (isTraver) {
-		if (eq(d.getValue(), possibleValue)) return d;
-	} else if (eq(d.value, possibleValue)) return d;
-}
-/**
-* Iterates over children of `root`, depth-first.
-* 
-* Other iteration options:
-* * {@link breadthFirst}: Children, breadth-first
-* * {@link depthFirst}: Children, depth-first
-* * {@link parents}: Chain of parents, starting with immediate parent
-* * {@link siblings}: Nodes with same parent
-* @param root Root node 
-* @returns 
-*/
-function* depthFirst$1(root) {
-	if (!root) return;
-	const stack = new StackMutable();
-	let entry = root;
-	while (entry) {
-		const entries = isTraversable(entry) ? [...entry.children()] : [...entry.childrenStore];
-		stack.push(...entries);
-		if (stack.isEmpty) break;
-		entry = stack.pop();
-		if (entry) yield entry;
-	}
-}
-/**
-* Iterates over the children of `root`, breadth-first
-* 
-* Other iteration options:
-* * {@link breadthFirst}: Children, breadth-first
-* * {@link depthFirst}: Children, depth-first
-* * {@link parents}: Chain of parents, starting with immediate parent
-* * {@link siblings}: Nodes with same parent
-* 
-* @example Traversing over a simple object
-* ```js
-* const myObj = { name: `Pedro`, size: 45, colour: `orange` };
-* const root = Trees.FromObject.asDynamicTraversable(myObj);
-* for (const v of Trees.Traverse.breadthFirst(root)) {
-* // v.getValue() yields:
-* // { name: 'name', sourceValue: 'Pedro' ...}, 
-* // { name: 'size', sourceValue: 45 ... }
-* // ...
-* }
-* ```
-* @param root Root node
-* @param depth How many levels to traverse 
-* @returns 
-*/
-function* breadthFirst$1(root, depth = Number.MAX_SAFE_INTEGER) {
-	if (!root) return;
-	const queue = isTraversable(root) ? new QueueMutable() : new QueueMutable();
-	let entry = root;
-	while (entry) {
-		if (depth < 0) return;
-		if (entry !== void 0) {
-			const kids = `childrenStore` in entry ? entry.childrenStore : entry.children();
-			for (const c of kids) {
-				yield c;
-				queue.enqueue(c);
-			}
-		}
-		entry = queue.dequeue();
-		depth--;
-	}
-}
-/**
-* Applies `predicate` to `root` and all its child nodes, returning the node where
-* `predicate` yields _true_.
-* Use {@link findByValue} to find a node by its value
-* @param root 
-* @param predicate 
-* @param order Iterate children by breadth or depth. Default 'breadth'
-* @returns 
-*/
-function find$2(root, predicate, order = `breadth`) {
-	if (predicate(root)) return root;
-	const iter = order === `breadth` ? breadthFirst$1 : depthFirst$1;
-	for (const c of iter(root)) if (predicate(c)) return c;
-}
-/**
-* Applies `predicate` to `root` and all its child nodes, returning the node value for
-* `predicate` yields _true_.
-* Use {@link find} to filter by nodes rather than values
-* 
-* ```js
-* const n = findByValue(root, (v) => v.name === 'Bob');
-* ```
-* @param root 
-* @param predicate 
-* @param order Iterate children by breadth or depth. Default 'breadth'
-* @returns 
-*/
-function findByValue(root, predicate, order = `breadth`) {
-	if (predicate(root.getValue())) return root;
-	const iter = order === `breadth` ? breadthFirst$1 : depthFirst$1;
-	for (const c of iter(root)) if (predicate(c.getValue())) return c;
-}
-/**
-* Search through children in a path-like manner.
-* 
-* It finds the first child of `root` that matches `continuePredicate`. 
-* The function gets passed a depth of 1 to begin with. It recurses, looking for the next sub-child, etc.
-* 
-* If it can't find a child, it stops.
-* 
-* This is different to 'find' functions, which exhaustively search all possible child nodes, regardless of position in tree.
-* 
-* ```js
-* const path = 'a.aa.aaa'.split('.');
-* const pred = (nodeValue, depth) => {
-*  if (nodeValue === path[0]) {
-*    path.shift(); // Remove first element
-*    return true;
-*  }
-*  return false;
-* }
-* 
-* // Assuming we have a tree of string values:
-* // a
-* //   - aa
-* //       - aaa
-* //   - ab
-* // b
-* //   - ba
-* for (const c of follow(tree, pred)) {
-*  // Returns nodes: a, aa and then aaa
-* }
-* ```
-* @param root 
-* @param continuePredicate 
-* @param depth 
-*/
-function* followValue(root, continuePredicate, depth = 1) {
-	for (const c of root.children()) if (continuePredicate(c.getValue(), depth)) {
-		yield c.getValue();
-		yield* followValue(c, continuePredicate, depth + 1);
-	}
-}
-function toStringDeep$1(node, depth = 0) {
-	if (node === void 0) return `(undefined)`;
-	if (node === null) return `(null)`;
-	const v = node.getValue();
-	let type = typeof v;
-	if (Array.isArray(v)) type = `array`;
-	let t = `  `.repeat(depth) + `value: ${JSON.stringify(v)} (${type})\n`;
-	for (const n of node.children()) t += toStringDeep$1(n, depth + 1);
-	return t;
-}
-function toString(...nodes) {
-	let t = ``;
-	for (const node of nodes) {
-		const v = node.getValue();
-		const vString = toStringAbbreviate(v);
-		const children = [...node.children()];
-		const parent = node.getParent();
-		let type = typeof v;
-		if (Array.isArray(v)) type = `array`;
-		t += `value: ${vString} (${type}) kids: ${children.length} parented: ${parent ? `y` : `n`}\n`;
-	}
-	return t;
-}
-var binary_tree_exports = /* @__PURE__ */ __exportAll({
-	addLeft: () => addLeft,
-	addRight: () => addRight,
-	balanceFactor: () => balanceFactor,
-	breadthFirst: () => breadthFirst,
-	createNode: () => createNode,
-	depthFirst: () => depthFirst,
-	find: () => find$1,
-	fromArray: () => fromArray$1,
-	getLeft: () => getLeft,
-	getRight: () => getRight,
-	grandparent: () => grandparent,
-	hasLeft: () => hasLeft,
-	hasRight: () => hasRight,
-	height: () => height,
-	inOrder: () => inOrder$1,
-	isLeaf: () => isLeaf,
-	isParentLeftChild: () => isParentLeftChild,
-	isParentRightChild: () => isParentRightChild,
-	leftSubtreeHeightFn: () => leftSubtreeHeightFn,
-	parentChildSide: () => parentChildSide,
-	postOrder: () => postOrder$1,
-	preOrder: () => preOrder$1,
-	removeNode: () => removeNode,
-	rightSubtreeHeightFn: () => rightSubtreeHeightFn,
-	root: () => root$1,
-	rootWrapped: () => rootWrapped,
-	setLeft: () => setLeft,
-	setRight: () => setRight,
-	sibling: () => sibling,
-	toArray: () => toArray,
-	toStringDeep: () => toStringDeep,
-	uncle: () => uncle,
-	wrap: () => wrap
-});
-const getLeftChild = (node) => {
-	return node.childrenStore[0];
-};
-const getRightChild = (node) => {
-	return node.childrenStore[1];
-};
-const getLeft = (node) => {
-	return getLeftChild(node);
-};
-const getRight = (node) => {
-	return getRightChild(node);
-};
-const hasLeft = (node) => {
-	return getLeftChild(node) !== void 0;
-};
-const hasRight = (node) => {
-	return getRightChild(node) !== void 0;
-};
-const isLeaf = (node) => {
-	return !hasLeft(node) && !hasRight(node);
-};
-const setLeft = (parent, child) => {
-	const existingLeft = getLeftChild(parent);
-	if (existingLeft) existingLeft.parent = void 0;
-	const children = [...parent.childrenStore];
-	if (child === void 0 && children.length <= 1) {
-		parent.childrenStore = [];
-		return;
-	} else if (child === void 0) {
-		children[0] = void 0;
-		parent.childrenStore = children;
-		return;
-	}
-	if (children.length === 0) children.push(child);
-	else children[0] = child;
-	parent.childrenStore = children;
-	child.parent = parent;
-};
-const setRight = (parent, child) => {
-	const existingRight = getRightChild(parent);
-	if (existingRight) existingRight.parent = void 0;
-	const children = [...parent.childrenStore];
-	if (child === void 0) {
-		if (children.length >= 2) {
-			children[1] = void 0;
-			if (children[0] === void 0) parent.childrenStore = [];
-			else parent.childrenStore = children;
-		}
-		return;
-	}
-	if (children.length === 0) children.push(void 0, child);
-	else if (children.length === 1) children.push(child);
-	else children[1] = child;
-	parent.childrenStore = children;
-	child.parent = parent;
-};
-const removeNode = (node) => {
-	const p = node.parent;
-	if (!p) return;
-	if (p.childrenStore[0] === node) setLeft(p, void 0);
-	else if (p.childrenStore[1] === node) setRight(p, void 0);
-};
-const sibling = (node) => {
-	const parent = node.parent;
-	if (!parent) return void 0;
-	const left = getLeftChild(parent);
-	const right = getRightChild(parent);
-	if (left === node) return right;
-	if (right === node) return left;
-};
-const uncle = (node) => {
-	const parent = node.parent;
-	if (!parent) return void 0;
-	return sibling(parent);
-};
-const grandparent = (node) => {
-	const parent = node.parent;
-	if (!parent) return void 0;
-	return parent.parent;
-};
-const isParentLeftChild = (node) => {
-	const parent = node.parent;
-	if (!parent) return false;
-	return getLeftChild(parent) === node;
-};
-const isParentRightChild = (node) => {
-	const parent = node.parent;
-	if (!parent) return false;
-	return getRightChild(parent) === node;
-};
-const parentChildSide = (node) => {
-	if (!node.parent) return `neutral`;
-	return isParentLeftChild(node) ? `left` : `right`;
-};
-const leftSubtreeHeight = (node) => {
-	const left = getLeftChild(node);
-	return left ? subtreeHeight(left) + 1 : 0;
-};
-const rightSubtreeHeight = (node) => {
-	const right = getRightChild(node);
-	return right ? subtreeHeight(right) + 1 : 0;
-};
-const subtreeHeight = (node) => {
-	return Math.max(leftSubtreeHeight(node), rightSubtreeHeight(node));
-};
-const height = (node) => {
-	return subtreeHeight(node);
-};
-const balanceFactor = (node) => {
-	return leftSubtreeHeight(node) - rightSubtreeHeight(node);
-};
-const leftSubtreeHeightFn = leftSubtreeHeight;
-const rightSubtreeHeightFn = rightSubtreeHeight;
-const addLeft = (value, parent) => {
-	const existingLeft = getLeftChild(parent);
-	if (existingLeft) existingLeft.parent = void 0;
-	const child = {
-		value,
-		parent,
-		childrenStore: []
-	};
-	const children = [...parent.childrenStore];
-	if (children.length === 0) children.push(child);
-	else if (children.length === 1) children[0] = child;
-	else children[0] = child;
-	parent.childrenStore = children;
-	return child;
-};
-const addRight = (value, parent) => {
-	const existingRight = getRightChild(parent);
-	if (existingRight) existingRight.parent = void 0;
-	const child = {
-		value,
-		parent,
-		childrenStore: []
-	};
-	const children = [...parent.childrenStore];
-	if (children.length === 0) {
-		children.push(void 0);
-		children.push(child);
-	} else if (children.length === 1) children.push(child);
-	else children[1] = child;
-	parent.childrenStore = children;
-	return child;
-};
-const root$1 = (value) => {
-	return root$2(value);
-};
-const createNode = (value, parent) => {
-	return createNode$1(value, parent);
-};
-const unwrapNode = (node) => {
-	return `node` in node ? node.node : node;
-};
-const wrapNode = (node) => {
-	return wrap(node);
-};
-const wrap = (node) => {
-	return {
-		node,
-		get left() {
-			const left = getLeftChild(node);
-			return left ? wrapNode(left) : void 0;
-		},
-		get right() {
-			const right = getRightChild(node);
-			return right ? wrapNode(right) : void 0;
-		},
-		set left(value) {
-			setLeft(node, value ? unwrapNode(value) : void 0);
-		},
-		set right(value) {
-			setRight(node, value ? unwrapNode(value) : void 0);
-		},
-		get parentChildSide() {
-			return parentChildSide(node);
-		},
-		get isParentLeftChild() {
-			return isParentLeftChild(node);
-		},
-		get isParentRightChild() {
-			return isParentRightChild(node);
-		},
-		get isLeaf() {
-			return isLeaf(node);
-		},
-		get sibling() {
-			const sib = sibling(node);
-			return sib ? wrapNode(sib) : void 0;
-		},
-		get uncle() {
-			const unc = uncle(node);
-			return unc ? wrapNode(unc) : void 0;
-		},
-		get grandparent() {
-			const gp = grandparent(node);
-			return gp ? wrapNode(gp) : void 0;
-		},
-		get leftSubtreeHeight() {
-			return leftSubtreeHeight(node);
-		},
-		get rightSubtreeHeight() {
-			return rightSubtreeHeight(node);
-		},
-		get height() {
-			return height(node);
-		},
-		get balanceFactor() {
-			return balanceFactor(node);
-		},
-		has(value) {
-			return find$1(node, value) !== void 0;
-		},
-		addLeft(value) {
-			return wrapNode(addLeft(value, node));
-		},
-		addRight(value) {
-			return wrapNode(addRight(value, node));
-		},
-		setLeft(nodeOrWrapped) {
-			setLeft(node, unwrapNode(nodeOrWrapped));
-		},
-		setRight(nodeOrWrapped) {
-			setRight(node, unwrapNode(nodeOrWrapped));
-		},
-		remove() {
-			removeNode(node);
-		}
-	};
-};
-const rootWrapped = (value) => {
-	return wrap(root$2(value));
-};
-const find$1 = (root, value) => {
-	for (const n of breadthFirst(root)) if (n.value === value) return n;
-};
-function* inOrder$1(node) {
-	const left = getLeftChild(node);
-	if (left) yield* inOrder$1(left);
-	yield node;
-	const right = getRightChild(node);
-	if (right) yield* inOrder$1(right);
-}
-function* preOrder$1(node) {
-	yield node;
-	const left = getLeftChild(node);
-	if (left) yield* preOrder$1(left);
-	const right = getRightChild(node);
-	if (right) yield* preOrder$1(right);
-}
-function* postOrder$1(node) {
-	const left = getLeftChild(node);
-	if (left) yield* postOrder$1(left);
-	const right = getRightChild(node);
-	if (right) yield* postOrder$1(right);
-	yield node;
-}
-function* depthFirst(node) {
-	const left = getLeftChild(node);
-	const right = getRightChild(node);
-	if (left) yield* depthFirst(left);
-	if (right) yield* depthFirst(right);
-	yield node;
-}
-function* breadthFirst(node) {
-	yield node;
-	const queue = [];
-	queue.push(...node.childrenStore.filter((c) => c !== void 0 && c.value !== void 0));
-	while (queue.length > 0) {
-		const current = queue.shift();
-		yield current;
-		queue.push(...current.childrenStore.filter((c) => c !== void 0 && c.value !== void 0));
-	}
-}
-const fromArray$1 = (array) => {
-	if (array.length === 0) return void 0;
-	const rootNode = root$2(array[0]);
-	const insert = (index, parent) => {
-		const leftIdx = 2 * index + 1;
-		const rightIdx = 2 * index + 2;
-		if (leftIdx < array.length) {
-			addLeft(array[leftIdx], parent);
-			insert(leftIdx, getLeftChild(parent));
-		}
-		if (rightIdx < array.length) {
-			addRight(array[rightIdx], parent);
-			insert(rightIdx, getRightChild(parent));
-		}
-	};
-	insert(0, rootNode);
-	return rootNode;
-};
-const toArray = (root) => {
-	const result = [];
-	for (const node of breadthFirst(root)) if (node.value !== void 0) result.push(node.value);
-	return result;
-};
-const toStringDeep = (node, indent = 0) => {
-	const v = node.value !== void 0 ? JSON.stringify(node.value) : `-`;
-	const prefix = `  `.repeat(indent);
-	const left = getLeftChild(node);
-	const right = getRightChild(node);
-	let result = `${prefix}${v}`;
-	if (left || right) {
-		result += `\n`;
-		if (left) {
-			result += `${prefix}  L: ${toStringDeep(left, indent + 1)}`;
-			if (right) result += `\n`;
-		}
-		if (right) result += `${prefix}  R: ${toStringDeep(right, indent + 1)}`;
-	}
-	return result;
-};
-var binary_search_tree_exports = /* @__PURE__ */ __exportAll({
-	Bst: () => Bst,
-	create: () => create,
-	find: () => find,
-	fromArray: () => fromArray,
-	has: () => has,
-	inOrder: () => inOrder,
-	insert: () => insert,
-	max: () => max,
-	min: () => min,
-	postOrder: () => postOrder,
-	preOrder: () => preOrder,
-	remove: () => remove,
-	root: () => root,
-	valuesInOrder: () => valuesInOrder
-});
-var Bst = class {
-	root;
-	comparer;
-	constructor(comparer = defaultComparer) {
-		this.comparer = comparer;
-		this.root = root$1();
-	}
-	insert(value) {
-		this.root = insert(this.root, value, this.comparer);
-		return this.root;
-	}
-	has(value) {
-		return has(this.root, value, this.comparer);
-	}
-	find(value) {
-		return find(this.root, value, this.comparer);
-	}
-	remove(value) {
-		const result = remove(this.root, value, this.comparer);
-		if (result) this.root = result;
-		return result !== void 0;
-	}
-	min() {
-		return min(this.root);
-	}
-	max() {
-		return max(this.root);
-	}
-	inOrder() {
-		return inOrder(this.root);
-	}
-	preOrder() {
-		return preOrder(this.root);
-	}
-	postOrder() {
-		return postOrder(this.root);
-	}
-	valuesInOrder() {
-		return valuesInOrder(this.root);
-	}
-	toArrayInOrder() {
-		return Array.from(this.valuesInOrder());
-	}
-};
-const insert = (root, value, compare = defaultComparer) => {
-	if (root.value === void 0) {
-		root.value = value;
-		return root;
-	}
-	let current = root;
-	while (true) {
-		const cmp = compare(value, current.value);
-		if (cmp < 0) {
-			const left = getLeft(current);
-			if (left) current = left;
-			else {
-				addLeft(value, current);
-				break;
-			}
-		} else if (cmp > 0) {
-			const right = getRight(current);
-			if (right) current = right;
-			else {
-				addRight(value, current);
-				break;
-			}
-		} else break;
-	}
-	return root;
-};
-const has = (root, value, compare = defaultComparer) => {
-	return find(root, value, compare) !== void 0;
-};
-const find = (root, value, compare = defaultComparer) => {
-	if (!root || root.value === void 0) return void 0;
-	const cmp = compare(value, root.value);
-	if (cmp === 0) return root;
-	else if (cmp < 0) {
-		const left = getLeft(root);
-		return left ? find(left, value, compare) : void 0;
-	} else {
-		const right = getRight(root);
-		return right ? find(right, value, compare) : void 0;
-	}
-};
-const min = (root) => {
-	if (!root || root.value === void 0) return void 0;
-	let current = root;
-	while (getLeft(current)) current = getLeft(current);
-	return current;
-};
-const max = (root) => {
-	if (!root || root.value === void 0) return void 0;
-	let current = root;
-	while (getRight(current)) current = getRight(current);
-	return current;
-};
-const remove = (root, value, compare = defaultComparer) => {
-	if (!root || root.value === void 0) return void 0;
-	const nodeToRemove = find(root, value, compare);
-	if (!nodeToRemove) return;
-	const left = getLeft(nodeToRemove);
-	const right = getRight(nodeToRemove);
-	if (!left && !right) if (nodeToRemove === root) {
-		root.value = void 0;
-		root.childrenStore = [];
-	} else removeNode(nodeToRemove);
-	else if (!left) if (nodeToRemove === root) {
-		root.value = right.value;
-		root.childrenStore = right.childrenStore;
-		for (const child of root.childrenStore) if (child) child.parent = root;
-	} else {
-		const parent = nodeToRemove.parent;
-		if (getLeft(parent) === nodeToRemove) setLeft(parent, right);
-		else setRight(parent, right);
-	}
-	else if (!right) if (nodeToRemove === root) {
-		root.value = left.value;
-		root.childrenStore = left.childrenStore;
-		for (const child of root.childrenStore) if (child) child.parent = root;
-	} else {
-		const parent = nodeToRemove.parent;
-		if (getLeft(parent) === nodeToRemove) setLeft(parent, left);
-		else setRight(parent, left);
-	}
-	else {
-		const successor = min(right);
-		nodeToRemove.value = successor.value;
-		const succParent = successor.parent;
-		const succRight = getRight(successor);
-		if (getLeft(succParent) === successor) setLeft(succParent, succRight);
-		else setRight(succParent, succRight);
-	}
-	return root;
-};
-function* inOrder(node) {
-	if (!node) return;
-	const left = getLeft(node);
-	if (left) yield* inOrder(left);
-	yield node;
-	const right = getRight(node);
-	if (right) yield* inOrder(right);
-}
-function* preOrder(node) {
-	if (!node) return;
-	yield node;
-	const left = getLeft(node);
-	if (left) yield* preOrder(left);
-	const right = getRight(node);
-	if (right) yield* preOrder(right);
-}
-function* postOrder(node) {
-	if (!node) return;
-	const left = getLeft(node);
-	if (left) yield* postOrder(left);
-	const right = getRight(node);
-	if (right) yield* postOrder(right);
-	yield node;
-}
-function* valuesInOrder(node) {
-	for (const n of inOrder(node)) if (n.value !== void 0) yield n.value;
-}
-const create = (comparer) => {
-	return new Bst(comparer);
-};
-const fromArray = (array, comparer = defaultComparer) => {
-	const bst = new Bst(comparer);
-	for (const value of array) bst.insert(value);
-	return bst;
-};
-const root = () => {
-	return root$1();
-};
-var tree_exports = /* @__PURE__ */ __exportAll({
-	BinarySearchTree: () => binary_search_tree_exports,
-	BinaryTree: () => binary_tree_exports,
-	FromObject: () => traverse_object_exports,
-	Mutable: () => tree_mutable_exports,
-	Pathed: () => pathed_exports,
-	Traverse: () => traversable_tree_exports,
-	compare: () => compare$1,
-	isMultiValue: () => isMultiValue,
-	isSingleValue: () => isSingleValue,
-	isTraversable: () => isTraversable,
-	isTreeNode: () => isTreeNode,
-	toTraversable: () => toTraversable
-});
-/**
-* Makes a 'traversable' to move around a {@link TreeNode}, 
-* an existing {@link TraversableTree} or a plain object.
-* 
-* @param node 
-* @returns 
-*/
-const toTraversable = (node) => {
-	if (isTraversable(node)) return node;
-	if (isTreeNode(node)) return asDynamicTraversable$1(node);
-	if (typeof node === `object`) return asDynamicTraversable(node);
-	throw new Error(`Parameter 'node' not convertible`);
-};
-/**
-* Checks whether `node` is of type {@link TreeNode}.
-* 
-* Checks for: parent, childrenStore and value defined on `node`.
-* @param node 
-* @returns 
-*/
-const isTreeNode = (node) => {
-	if (`parent` in node && `childrenStore` in node && `value` in node) {
-		if (Array.isArray(node.childrenStore)) return true;
+		];
 	}
-	return false;
-};
-/**
-* Checks if `node` is of type {@link TraversableTree}.
-* 
-* Checks by looking for: children, getParent, getValue and getIdentity defined on `node`.
-* @param node 
-* @returns 
-*/
-const isTraversable = (node) => {
-	return `children` in node && `getParent` in node && `getValue` in node && `getIdentity` in node;
 };
+__decorate([property({ attribute: false })], SplitButton.prototype, "registry", void 0);
+__decorate([property({ attribute: false })], SplitButton.prototype, "keyboardManager", void 0);
+__decorate([property({ type: String })], SplitButton.prototype, "mode", void 0);
+__decorate([property({
+	type: String,
+	attribute: `default-value`
+})], SplitButton.prototype, "defaultValue", void 0);
+__decorate([property({ attribute: false })], SplitButton.prototype, "itemsProvider", void 0);
+__decorate([property({ attribute: false })], SplitButton.prototype, "items", void 0);
+__decorate([query(`ixfx-menu-trigger`)], SplitButton.prototype, "_menuTrigger", void 0);
+__decorate([state()], SplitButton.prototype, "_compact", void 0);
+__decorate([state()], SplitButton.prototype, "_selectedCommand", void 0);
+__decorate([state()], SplitButton.prototype, "_selectedLabel", void 0);
+__decorate([state()], SplitButton.prototype, "_selectedIcon", void 0);
+__decorate([state()], SplitButton.prototype, "_switcherItems", void 0);
+__decorate([state()], SplitButton.prototype, "_dynamicItems", void 0);
+__decorate([state()], SplitButton.prototype, "_loadingItems", void 0);
+__decorate([state()], SplitButton.prototype, "_menuHasItems", void 0);
+SplitButton = __decorate([safeCustomElement(`ixfx-split-button`)], SplitButton);
 //#endregion
 //#region src/crumbs/crumb-path-controller.ts
 var CrumbPathController = class {
@@ -4301,7 +1577,7 @@ var CrumbPathController = class {
 	constructor(options = {}) {
 		this.#separator = options.separator ?? `/`;
 		this.#onQuery = options.onQuery;
-		this.#pathed = new tree_exports.Pathed.Pathed({ separator: this.#separator });
+		this.#pathed = new Trees.Pathed.Pathed({ separator: this.#separator });
 		if (options.paths) this.addPaths(options.paths);
 	}
 	get separator() {
@@ -4410,7 +1686,6 @@ let CrumbPathElement = class CrumbPathElement extends LitElement {
 				case `Escape`:
 					e.preventDefault();
 					this.#closeDropdown();
-					break;
 			}
 		};
 		this.#onHostKeyDown = (e) => {
@@ -4749,9 +2024,11 @@ let CrumbPathElement = class CrumbPathElement extends LitElement {
 	#onHostKeyDown;
 	render() {
 		const segments = this.#getSegments();
-		if (this._editing) return html`
+		if (this._editing) {
+			const editValue = this.path;
+			return html`
         <ixfx-ac-text
-          .value=${this.path}
+          .value=${editValue}
           .tabSuffix=${this.separator}
           .completionProvider=${this.#makeCompletionProvider()}
           @change=${this.#onAcChange}
@@ -4759,6 +2036,7 @@ let CrumbPathElement = class CrumbPathElement extends LitElement {
           @keydown=${this.#onAcKeyDown}
         ></ixfx-ac-text>
       `;
+		}
 		const rootSegments = this.#getRootSegments();
 		const leadingCaret = this.siblingLookup && rootSegments.length === 0 ? html`
       <div class="caret ${this._openIdx === -1 ? `open` : ``} ${this._confirmedLeafIndices.has(``) ? `disabled` : ``}"
@@ -4986,7 +2264,7 @@ CrumbPathElement = __decorate([safeCustomElement(`ixfx-crumb-path`)], CrumbPathE
 //#endregion
 //#region src/editable-label/editable-number.ts
 const DRAG_THRESHOLD_PX = 3;
-let EditableNumber = class EditableNumber extends EditableLabel {
+let EditableNumber = class EditableNumber extends WheelNudgeMixin(EditableLabel) {
 	#dragStartY;
 	#dragStartValue;
 	#dragging;
@@ -5239,14 +2517,15 @@ let EditableNumber = class EditableNumber extends EditableLabel {
 		this.style.setProperty(`--value`, String(normalized));
 		let valueStart = 0;
 		let valueEnd = normalized;
-		if (this.linearStyle === `bipolar`) if (normalized <= .5) {
-			valueStart = normalized;
-			valueEnd = .5;
-		} else {
-			valueStart = .5;
-			valueEnd = normalized;
-		}
-		else if (this.linearStyle === `unipolar`) {
+		if (this.linearStyle === `bipolar`) {
+			if (normalized <= .5) {
+				valueStart = normalized;
+				valueEnd = .5;
+			} else {
+				valueStart = .5;
+				valueEnd = normalized;
+			}
+		} else if (this.linearStyle === `unipolar`) {
 			valueStart = .5 - normalized * .5;
 			valueEnd = .5 + normalized * .5;
 		}
@@ -5288,8 +2567,7 @@ let EditableNumber = class EditableNumber extends EditableLabel {
 	_handleArrowKey(e) {
 		const range = (this.max ?? 100) - (this.min ?? 0);
 		if (range === 0) return false;
-		const shiftDivisor = e.shiftKey ? 10 : 1;
-		const effectiveStep = resolveStep(range, void 0, this.step) / shiftDivisor;
+		const effectiveStep = resolveAxisStep(range, this.stops, this.step, e.shiftKey);
 		let delta = 0;
 		let handled = false;
 		switch (e.key) {
@@ -5310,33 +2588,49 @@ let EditableNumber = class EditableNumber extends EditableLabel {
 			case `End`:
 				delta = (this.max ?? 0) - this._parseValue();
 				handled = true;
-				break;
 		}
 		if (handled) {
 			e.preventDefault();
-			const prev = this.value;
-			const current = this._parseValue();
-			const newValue = this._clamp(this._snap(current + delta));
-			const newValueStr = this.step !== void 0 ? this._formatNumber(newValue) : newValue.toFixed(this.precision);
-			this.value = newValueStr;
-			this._requestDisplayUpdate();
-			this._updateValueCss(this._normalizedValue(newValue));
-			if (newValueStr !== prev) this.dispatchEvent(new CustomEvent(`input`, {
-				detail: { value: newValueStr },
-				bubbles: true,
-				composed: true
-			}));
-			requestAnimationFrame(() => {
-				if (this.value !== prev) this.dispatchEvent(new CustomEvent(`change`, {
-					detail: { value: this.value },
-					bubbles: true,
-					composed: true
-				}));
-			});
+			this._applyDelta(delta);
 			return true;
 		}
 		return false;
 	}
+	/**
+	* Apply a signed delta to the current value, clamp/snap/format, and fire
+	* `input`/`change`. Shared between arrow-key handler and the wheel handler.
+	*/
+	_applyDelta(delta) {
+		const prev = this.value;
+		const current = this._parseValue();
+		const newValue = this._clamp(this._snap(current + delta));
+		const newValueStr = this.step !== void 0 ? this._formatNumber(newValue) : newValue.toFixed(this.precision);
+		this.value = newValueStr;
+		this._requestDisplayUpdate();
+		this._updateValueCss(this._normalizedValue(newValue));
+		if (newValueStr !== prev) this.dispatchEvent(new CustomEvent(`input`, {
+			detail: { value: newValueStr },
+			bubbles: true,
+			composed: true
+		}));
+		requestAnimationFrame(() => {
+			if (this.value !== prev) this.dispatchEvent(new CustomEvent(`change`, {
+				detail: { value: this.value },
+				bubbles: true,
+				composed: true
+			}));
+		});
+	}
+	_shouldHandleWheel() {
+		if (this._editing) return false;
+		return super._shouldHandleWheel();
+	}
+	_applyWheelDelta(direction, event) {
+		const range = (this.max ?? 100) - (this.min ?? 0);
+		if (range === 0) return;
+		const effectiveStep = resolveAxisStep(range, this.stops, this.step, event.shiftKey);
+		this._applyDelta(direction * effectiveStep);
+	}
 	_parseValue() {
 		return Number.parseFloat(this.value) || 0;
 	}
@@ -5359,6 +2653,11 @@ let EditableNumber = class EditableNumber extends EditableLabel {
 		return n;
 	}
 	_snap(n) {
+		if (this.stops && this.stops > 1) {
+			const min = this.min ?? 0;
+			const stopStep = ((this.max ?? 100) - min) / this.stops;
+			return Math.round((n - min) / stopStep) * stopStep + min;
+		}
 		if (!this.step) return n;
 		return Math.round(n / this.step) * this.step;
 	}
@@ -5549,6 +2848,7 @@ let EditableNumber = class EditableNumber extends EditableLabel {
 __decorate([property({ type: Number })], EditableNumber.prototype, "min", void 0);
 __decorate([property({ type: Number })], EditableNumber.prototype, "max", void 0);
 __decorate([property({ type: Number })], EditableNumber.prototype, "step", void 0);
+__decorate([property({ type: Number })], EditableNumber.prototype, "stops", void 0);
 __decorate([property({
 	type: Number,
 	attribute: `drag-sensitivity`
@@ -5971,9 +3271,7 @@ let VerticalListElement = class VerticalListElement extends LitElement {
 					}
 					break;
 				}
-				case `Escape`:
-					this._clearSelection();
-					break;
+				case `Escape`: this._clearSelection();
 			}
 		};
 		this._onClick = (e) => {
@@ -6061,7 +3359,7 @@ let VerticalListElement = class VerticalListElement extends LitElement {
 				this._selectedItems = remapped;
 			}
 			this._syncItemStates();
-		}
+		} else if (changed.has(`checkboxRenderer`) && this.interactionMode === `checked`) this._syncCheckboxes();
 	}
 	/** The most recently selected item, or `undefined` if nothing is selected. */
 	get selectedItem() {
@@ -6142,7 +3440,7 @@ let VerticalListElement = class VerticalListElement extends LitElement {
 	_replaceSelection(item) {
 		if (this.selectionMode === `none`) return;
 		const previous = this._selectedItems;
-		const next = new Set([item]);
+		const next = /* @__PURE__ */ new Set([item]);
 		this._selectedItems = next;
 		this.#selectionAnchor = item;
 		this._syncItemStates();
@@ -6229,7 +3527,7 @@ let VerticalListElement = class VerticalListElement extends LitElement {
 				} else if (e.shiftKey && (this.selectionMode === `multiple` || mode === `vscode`)) this._rangeSelectTo(item);
 				else this._replaceSelection(item);
 				break;
-			case `checked`: break;
+			case `checked`:
 		}
 	}
 	_handleSpaceKey(item) {
@@ -6257,6 +3555,7 @@ let VerticalListElement = class VerticalListElement extends LitElement {
 	}
 	_syncCheckboxes() {
 		const inCheckedMode = this.interactionMode === `checked`;
+		const wantsCustom = typeof this.checkboxRenderer === `function`;
 		if (inCheckedMode) for (const inner of Array.from(this.children)) {
 			if (!inner.hasAttribute(`data-list-item`)) continue;
 			if (inner.parentElement !== this) continue;
@@ -6281,24 +3580,70 @@ let VerticalListElement = class VerticalListElement extends LitElement {
 			this.#customWrappers.clear();
 		}
 		for (const el of this.querySelectorAll(`li`)) {
-			let cb = el.querySelector(`input.ixfx-list-checkbox`);
-			if (inCheckedMode) {
-				if (!cb) {
-					cb = document.createElement(`input`);
-					cb.type = `checkbox`;
-					cb.className = `ixfx-list-checkbox`;
-					cb.style.cssText = `flex-shrink:0;margin:0 6px 0 0;cursor:pointer;accent-color:var(--accent,#60a5fa);pointer-events:auto`;
-					cb.tabIndex = -1;
-					cb.addEventListener(`click`, (e) => {
-						e.stopPropagation();
-						this._toggleItem(el);
-					});
-					el.prepend(cb);
-				}
-				cb.checked = this._selectedItems.has(el);
-			} else if (cb) cb.remove();
+			const existing = el.querySelector(`.ixfx-list-checkbox`);
+			if (!inCheckedMode) {
+				if (existing) existing.remove();
+				continue;
+			}
+			const existingIsCustom = existing?.classList.contains(`ixfx-list-checkbox-custom`) ?? false;
+			if (existing && existingIsCustom !== wantsCustom) existing.remove();
+			let cb = el.querySelector(`.ixfx-list-checkbox`);
+			if (!cb) {
+				cb = wantsCustom ? this._createCustomCheckbox(el) : this._createNativeCheckboxCell(el);
+				el.prepend(cb);
+			}
+			const checked = this._selectedItems.has(el);
+			if (wantsCustom) {
+				cb.setAttribute(`aria-checked`, String(checked));
+				cb.toggleAttribute(`data-checked`, checked);
+				if (this.checkboxRenderer) render(this.checkboxRenderer(checked), cb);
+			} else {
+				const input = cb.querySelector(`input.ixfx-list-checkbox`);
+				if (input) input.checked = checked;
+			}
 		}
 	}
+	/**
+	* Native checkbox cell: a span that stretches to the row's full cross-axis
+	* (so the entire column height is a click target) with a real `<input>`
+	* centred inside. The span owns the click; the input is purely visual and
+	* has `pointer-events:none` so a single click produces one toggle.
+	*/
+	_createNativeCheckboxCell(el) {
+		const cell = document.createElement(`span`);
+		cell.className = `ixfx-list-checkbox ixfx-list-checkbox-native`;
+		cell.style.cssText = `display:inline-flex;align-items:center;justify-content:center;flex-shrink:0;align-self:stretch;width:18px;margin:0 6px 0 0;cursor:pointer;pointer-events:auto`;
+		cell.tabIndex = -1;
+		cell.setAttribute(`role`, `checkbox`);
+		cell.setAttribute(`part`, `checkbox`);
+		cell.addEventListener(`click`, (e) => {
+			e.stopPropagation();
+			this._toggleItem(el);
+		});
+		const input = document.createElement(`input`);
+		input.type = `checkbox`;
+		input.className = `ixfx-list-checkbox`;
+		input.style.cssText = `pointer-events:none;cursor:pointer;margin:0`;
+		cell.appendChild(input);
+		return cell;
+	}
+	/**
+	* Custom checkbox cell: same shape as the native cell (a stretching span)
+	* so behaviour is identical. The renderer's content goes inside.
+	*/
+	_createCustomCheckbox(el) {
+		const span = document.createElement(`span`);
+		span.className = `ixfx-list-checkbox ixfx-list-checkbox-custom`;
+		span.style.cssText = `display:inline-flex;align-items:center;justify-content:center;flex-shrink:0;align-self:stretch;width:24px;margin:0 6px 0 0;cursor:pointer;pointer-events:auto`;
+		span.tabIndex = -1;
+		span.setAttribute(`role`, `checkbox`);
+		span.setAttribute(`part`, `checkbox`);
+		span.addEventListener(`click`, (e) => {
+			e.stopPropagation();
+			this._toggleItem(el);
+		});
+		return span;
+	}
 	_findListItem(path) {
 		for (const target of path) {
 			if (!(target instanceof Element)) continue;
@@ -6360,8 +3705,14 @@ let VerticalListElement = class VerticalListElement extends LitElement {
       padding: 0;
       width: 100%;
       height: 100%;
+      overflow-x: hidden;
       overflow-y: auto;
       box-sizing: border-box;
+      /* Scrollbar theming: end users override these CSS variables to control
+         the native scrollbar (scrollbar-width, scrollbar-gutter, scrollbar-color). */
+      scrollbar-width: var(--list-scrollbar-width, auto);
+      scrollbar-gutter: var(--list-scrollbar-gutter, auto);
+      scrollbar-color: var(--list-scrollbar-color, auto);
     }
 
     ::slotted([hidden]) {
@@ -6391,6 +3742,25 @@ let VerticalListElement = class VerticalListElement extends LitElement {
       outline: 1px solid transparent;
     }
 
+    /* In checked mode, only the checkbox column is clickable; the row body
+       gets a default cursor so it doesn't suggest otherwise. */
+    :host([interaction-mode="checked"]) ::slotted(li),
+    :host([interaction-mode="checked"]) ::slotted([data-list-item]) {
+      cursor: default;
+    }
+
+    /* Wrapper inserted around custom [data-list-item] elements in checked mode.
+       Provides the flex layout so the injected checkbox can stretch to the
+       row's full height via align-self:stretch. */
+    .ixfx-custom-row {
+      display: flex;
+      align-items: center;
+      min-height: var(--list-item-height, 28px);
+      box-sizing: border-box;
+      cursor: default;
+      user-select: none;
+    }
+
     ::slotted([data-tickled]) {
       background: var(--item-bg-tickled);
       outline: var(--item-border-tickled);
@@ -6498,6 +3868,7 @@ __decorate([property({
 	attribute: `interaction-mode`
 })], VerticalListElement.prototype, "interactionMode", void 0);
 __decorate([property({ attribute: false })], VerticalListElement.prototype, "filterPredicate", void 0);
+__decorate([property({ attribute: false })], VerticalListElement.prototype, "checkboxRenderer", void 0);
 __decorate([state()], VerticalListElement.prototype, "_selectedItems", void 0);
 __decorate([state()], VerticalListElement.prototype, "_searchVisible", void 0);
 __decorate([state()], VerticalListElement.prototype, "_searchQuery", void 0);
@@ -6633,6 +4004,441 @@ function createVerticalListAdapter(renderItem, options) {
 	return adapter;
 }
 //#endregion
+//#region src/notifier/notification-pill.ts
+let NotificationPillElement = class NotificationPillElement extends LitElement {
+	constructor(..._args) {
+		super(..._args);
+		this.notificationType = `info`;
+		this.message = ``;
+		this.dismissing = false;
+		this.notificationId = ``;
+	}
+	#handleClick() {
+		this.#emitTap();
+	}
+	#handleKeyDown(e) {
+		if (e.key === `Enter` || e.key === ` `) {
+			e.preventDefault();
+			this.#emitTap();
+		}
+	}
+	#emitTap() {
+		this.dispatchEvent(new CustomEvent(`pill-tap`, {
+			detail: { id: this.notificationId },
+			bubbles: true,
+			composed: true
+		}));
+	}
+	#renderIcon() {
+		if (!this.icon) return nothing;
+		if (this.icon.startsWith(`<svg`)) return html`<span class="pill-icon">${unsafeHTML(this.icon)}</span>`;
+		if (!getIcon(this.icon)) return nothing;
+		return html`<ixfx-icon class="pill-icon" name="${this.icon}"></ixfx-icon>`;
+	}
+	render() {
+		return html`
+      <button
+        type="button"
+        class="pill"
+        notification-type="${this.notificationType}"
+        @click=${this.#handleClick}
+        @keydown=${this.#handleKeyDown}
+        aria-label="${this.message}"
+      >
+        ${this.#renderIcon()}
+        <span class="pill-message">${this.message}</span>
+      </button>
+    `;
+	}
+	static {
+		this.styles = [themeFallbacks, css`
+      :host {
+        display: block;
+      }
+
+      .pill {
+        appearance: none;
+        cursor: pointer;
+        font-family: var(--font-family, inherit);
+        font-size: var(--text-m, 12px);
+        padding: var(--space-s, 4px) var(--space-m, 8px);
+        border-radius: var(--radius-l, 6px);
+        border: 1px solid var(--surface-6, #666);
+        display: inline-flex;
+        align-items: center;
+        gap: var(--space-s, 4px);
+        max-width: 300px;
+        box-shadow: var(--shadow-m);
+        transition: opacity 0.2s ease-out, transform 0.2s ease-out;
+        pointer-events: auto;
+      }
+
+      :host([dismissing]) .pill {
+        opacity: 0;
+        transform: translateX(20px);
+      }
+
+      .pill[notification-type="info"] {
+        background: var(--surface-5, #555);
+        color: var(--surface-5-text, #fff);
+      }
+
+      .pill[notification-type="warning"] {
+        background: color-mix(in oklch, oklch(65% 0.18 70) 30%, var(--surface-5));
+        border-color: oklch(65% 0.18 70);
+        color: var(--surface-5-text, #fff);
+      }
+
+      .pill[notification-type="error"] {
+        background: var(--error, #c00);
+        border-color: var(--error, #c00);
+        color: var(--error-text, #fff);
+      }
+
+      .pill-icon {
+        display: inline-flex;
+        align-items: center;
+        flex-shrink: 0;
+      }
+
+      .pill-icon ixfx-icon {
+        font-size: var(--text-m, 12px);
+      }
+
+      .pill-message {
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+
+      .pill:focus-visible {
+        outline: 2px solid var(--accent, #4a9);
+        outline-offset: 2px;
+      }
+
+      @media (prefers-reduced-motion: reduce) {
+        .pill {
+          transition: opacity 0.1s ease-out;
+          transform: none !important;
+        }
+      }
+    `];
+	}
+};
+__decorate([property({
+	type: String,
+	attribute: `notification-type`
+})], NotificationPillElement.prototype, "notificationType", void 0);
+__decorate([property({ type: String })], NotificationPillElement.prototype, "message", void 0);
+__decorate([property({ type: String })], NotificationPillElement.prototype, "icon", void 0);
+__decorate([property({
+	type: Boolean,
+	reflect: true
+})], NotificationPillElement.prototype, "dismissing", void 0);
+__decorate([property({
+	type: String,
+	attribute: `notification-id`
+})], NotificationPillElement.prototype, "notificationId", void 0);
+NotificationPillElement = __decorate([safeCustomElement(`ixfx-notification-pill`)], NotificationPillElement);
+//#endregion
+//#region src/notifier/pill-renderer.ts
+const ROW_SPACING = 8;
+const DEFAULT_ROW_HEIGHT = 40;
+const STACK_OFFSET_STEP = 4;
+const STACK_OPACITY_BASE = .7;
+const STACK_OPACITY_DECAY = .15;
+const STACK_OPACITY_MIN = .2;
+function edgesOf(position) {
+	return {
+		vertical: position.startsWith(`top`) ? `top` : `bottom`,
+		horizontal: position.endsWith(`-left`) ? `left` : position.endsWith(`-right`) ? `right` : `middle`
+	};
+}
+function anchorStyles(position, safeArea) {
+	const { vertical, horizontal } = edgesOf(position);
+	const vMargin = `calc(var(--space-l, 12px) + ${(vertical === `top` ? safeArea.top : safeArea.bottom) ?? 0}px)`;
+	let css = `position: fixed; `;
+	css += vertical === `top` ? `top: ${vMargin}; bottom: auto; ` : `bottom: ${vMargin}; top: auto; `;
+	if (horizontal === `left`) {
+		const hMargin = `calc(var(--space-l, 12px) + ${safeArea.left ?? 0}px)`;
+		css += `left: ${hMargin}; right: auto;`;
+	} else if (horizontal === `right`) {
+		const hMargin = `calc(var(--space-l, 12px) + ${safeArea.right ?? 0}px)`;
+		css += `right: ${hMargin}; left: auto;`;
+	} else css += `left: 50%; right: auto;`;
+	return css;
+}
+/** Entry-animation starting transform: pills slide in from the edge they're anchored to. */
+function entryTransform(edges) {
+	const dy = edges.vertical === `top` ? -20 : 20;
+	if (edges.horizontal === `middle`) return `translateX(-50%) translate(0, ${dy}px)`;
+	return `translate(${edges.horizontal === `left` ? -20 : 20}px, ${dy}px)`;
+}
+function restingTransform(edges, dx, dy) {
+	if (edges.horizontal === `middle`) return `translateX(-50%) translate(${dx}px, ${dy}px)`;
+	return `translate(${dx}px, ${dy}px)`;
+}
+function createPillRenderer(options = {}) {
+	const position = options.position ?? `top-right`;
+	const queueDisplay = options.queueDisplay ?? `list`;
+	const safeArea = options.safeArea ?? {};
+	const edges = edgesOf(position);
+	let container = null;
+	let hooks = null;
+	const pills = /* @__PURE__ */ new Map();
+	let rowHeight = DEFAULT_ROW_HEIGHT;
+	let measured = false;
+	function ensureContainer() {
+		if (container) return container;
+		container = document.createElement(`div`);
+		container.className = `ixfx-notification-container`;
+		container.setAttribute(`role`, `region`);
+		container.setAttribute(`aria-label`, `Notifications`);
+		document.body.appendChild(container);
+		return container;
+	}
+	function updateAttributes(el, notification) {
+		el.setAttribute(`notification-type`, notification.type);
+		el.setAttribute(`message`, notification.message);
+		if (notification.icon) el.setAttribute(`icon`, notification.icon);
+		else el.removeAttribute(`icon`);
+	}
+	function createPillElement(notification) {
+		const el = document.createElement(`ixfx-notification-pill`);
+		el.setAttribute(`notification-id`, notification.id);
+		el.style.cssText = anchorStyles(position, safeArea);
+		updateAttributes(el, notification);
+		el.style.opacity = `0`;
+		el.style.transform = entryTransform(edges);
+		el.addEventListener(`pill-tap`, (e) => {
+			const customEvent = e;
+			hooks?.onTap(customEvent.detail.id);
+		});
+		return el;
+	}
+	function measureRowHeight(el) {
+		if (measured) return;
+		requestAnimationFrame(() => {
+			const height = el.getBoundingClientRect().height;
+			if (height > 0) {
+				rowHeight = height;
+				measured = true;
+			}
+		});
+	}
+	/** Positions every currently-visible pill for its rank in `order` (index 0 = front/oldest). */
+	function applyLayout(order) {
+		const total = order.length;
+		order.forEach((notification, index) => {
+			const entry = pills.get(notification.id);
+			if (!entry) return;
+			const el = entry.element;
+			let dx = 0;
+			let dy = 0;
+			let opacity = 1;
+			let pointerEvents = `auto`;
+			let filter = `none`;
+			if (queueDisplay === `list`) {
+				const step = index * (rowHeight + ROW_SPACING);
+				dy = edges.vertical === `top` ? step : -step;
+			} else {
+				const step = index * STACK_OFFSET_STEP;
+				dy = edges.vertical === `top` ? step : -step;
+				dx = edges.horizontal === `left` ? step : edges.horizontal === `right` ? -step : 0;
+				if (index > 0) {
+					const hintIndex = index - 1;
+					opacity = Math.max(STACK_OPACITY_MIN, STACK_OPACITY_BASE - hintIndex * STACK_OPACITY_DECAY);
+					pointerEvents = `none`;
+					filter = `saturate(0.6)`;
+				}
+			}
+			el.style.transition = `opacity 0.2s ease-out, transform 0.2s ease-out`;
+			el.style.opacity = `${opacity}`;
+			el.style.zIndex = `${total - index}`;
+			el.style.pointerEvents = pointerEvents;
+			el.style.filter = filter;
+			el.style.transform = restingTransform(edges, dx, dy);
+		});
+	}
+	function dismiss(id) {
+		const entry = pills.get(id);
+		if (!entry) return;
+		const el = entry.element;
+		el.setAttribute(`dismissing`, `true`);
+		const cleanup = () => {
+			el.removeEventListener(`transitionend`, cleanup);
+			el.remove();
+			pills.delete(id);
+			if (container && pills.size === 0) {
+				container.remove();
+				container = null;
+				measured = false;
+				rowHeight = DEFAULT_ROW_HEIGHT;
+			}
+		};
+		el.addEventListener(`transitionend`, cleanup);
+		setTimeout(cleanup, 300);
+	}
+	function setNotifications(notifications, _queueSize) {
+		const cont = ensureContainer();
+		const idsToKeep = new Set(notifications.map((n) => n.id));
+		for (const notification of notifications) {
+			const existing = pills.get(notification.id);
+			if (existing) {
+				existing.notification = notification;
+				updateAttributes(existing.element, notification);
+				continue;
+			}
+			const el = createPillElement(notification);
+			pills.set(notification.id, {
+				element: el,
+				notification
+			});
+			cont.appendChild(el);
+			measureRowHeight(el);
+		}
+		for (const [id] of pills) if (!idsToKeep.has(id)) dismiss(id);
+		requestAnimationFrame(() => applyLayout(notifications));
+	}
+	return {
+		attach(newHooks) {
+			hooks = newHooks;
+		},
+		detach() {
+			for (const [id] of pills) dismiss(id);
+			if (container) {
+				container.remove();
+				container = null;
+			}
+		},
+		setNotifications
+	};
+}
+//#endregion
+//#region src/notifier/manager.ts
+const options = {
+	renderer: void 0,
+	timeout: 4e3,
+	timeoutError: 8e3,
+	queue: true,
+	queueSize: 3,
+	tapBehaviour: `dismiss`,
+	tapHandlerDefault: void 0
+};
+/** Rank-ordered, index 0 = oldest/first (next to be evicted or timed out). Length never exceeds queueSize (or 1 when queuing is disabled). */
+const visible = [];
+let renderer = null;
+let defaultRenderer = null;
+function getDefaultRenderer() {
+	defaultRenderer ??= createPillRenderer({ position: `top-right` });
+	return defaultRenderer;
+}
+function getRenderer() {
+	return renderer ?? getDefaultRenderer();
+}
+function syncRenderer() {
+	getRenderer().setNotifications([...visible], options.queueSize);
+}
+function clearTimer(managed) {
+	if (managed.timer !== null) {
+		clearTimeout(managed.timer);
+		managed.timer = null;
+	}
+}
+/**
+* A message shown alone takes the full timeout. A message that joined a
+* non-empty queue at arrival time is permanently "wasQueued" and gets
+* 1/queueSize of the timeout once it reaches the front. The timer for a
+* given message is only ever started once - when it first becomes front.
+*/
+function startTimer(managed) {
+	const base = managed.type === `error` ? options.timeoutError : options.timeout;
+	const duration = managed.wasQueued ? base / options.queueSize : base;
+	managed.timer = window.setTimeout(() => dismiss(managed.id), duration);
+}
+function ensureFrontTimer() {
+	const front = visible[0];
+	if (front && front.timer === null) startTimer(front);
+}
+const NotificationManager = {
+	configure(opts) {
+		if (opts.renderer !== void 0) {
+			renderer?.detach?.();
+			renderer = opts.renderer;
+			renderer.attach({ onTap(id) {
+				const notification = visible.find((n) => n.id === id);
+				if (!notification) return;
+				if (notification.onTap) notification.onTap(id);
+				else options.tapHandlerDefault?.(notification);
+				if (options.tapBehaviour === `dismiss`) dismiss(id);
+			} });
+			syncRenderer();
+		}
+		if (opts.timeout !== void 0) options.timeout = opts.timeout;
+		if (opts.timeoutError !== void 0) options.timeoutError = opts.timeoutError;
+		if (opts.queue !== void 0) options.queue = opts.queue;
+		if (opts.queueSize !== void 0) {
+			options.queueSize = Math.max(1, opts.queueSize);
+			while (visible.length > options.queueSize) clearTimer(visible.shift());
+			ensureFrontTimer();
+			syncRenderer();
+		}
+		if (opts.tapBehaviour !== void 0) options.tapBehaviour = opts.tapBehaviour;
+		if (opts.tapHandlerDefault !== void 0) options.tapHandlerDefault = opts.tapHandlerDefault;
+	},
+	notify(content) {
+		const id = crypto.randomUUID();
+		const now = Date.now();
+		const icon = content.icon ?? (content.type === `error` ? `error` : void 0);
+		const managed = {
+			...content,
+			icon,
+			id,
+			createdAt: now,
+			updatedAt: now,
+			timer: null,
+			wasQueued: false
+		};
+		if (options.queue) {
+			if (visible.length >= options.queueSize) clearTimer(visible.shift());
+			managed.wasQueued = visible.length > 0;
+			visible.push(managed);
+		} else {
+			while (visible.length > 0) clearTimer(visible.pop());
+			visible.push(managed);
+		}
+		ensureFrontTimer();
+		syncRenderer();
+		return id;
+	},
+	update(id, content) {
+		const managed = visible.find((n) => n.id === id);
+		if (!managed) return;
+		Object.assign(managed, content);
+		managed.updatedAt = Date.now();
+		if (visible[0] === managed) {
+			clearTimer(managed);
+			startTimer(managed);
+		}
+		syncRenderer();
+	},
+	dismiss(id) {
+		dismiss(id);
+	},
+	dismissAll() {
+		for (const m of visible) clearTimer(m);
+		visible.length = 0;
+		syncRenderer();
+	}
+};
+function dismiss(id) {
+	const idx = visible.findIndex((m) => m.id === id);
+	if (idx === -1) return;
+	clearTimer(visible.splice(idx, 1)[0]);
+	ensureFrontTimer();
+	syncRenderer();
+}
+//#endregion
 //#region src/panel/panel-group.ts
 let PanelGroupElement = class PanelGroupElement extends LitElement {
 	constructor(..._args) {
@@ -6867,11 +4673,13 @@ let RangeMultiElement = class RangeMultiElement extends LitElement {
 			}
 			a = newA;
 			b = newB;
-		} else if (which === `a`) if (v > this.b && this.crossover === `stop`) t.valueAsNumber = this.#scaleTo100(this.a);
-		else a = v;
-		else if (which === `b`) if (v < a && this.crossover === `stop`) t.valueAsNumber = this.#scaleTo100(this.b);
-		else b = v;
-		else throw new Error(`Expected 'a' or 'b', got: '${t.id}'`);
+		} else if (which === `a`) {
+			if (v > this.b && this.crossover === `stop`) t.valueAsNumber = this.#scaleTo100(this.a);
+			else a = v;
+		} else if (which === `b`) {
+			if (v < a && this.crossover === `stop`) t.valueAsNumber = this.#scaleTo100(this.b);
+			else b = v;
+		} else throw new Error(`Expected 'a' or 'b', got: '${t.id}'`);
 		this.setPoles(a, b);
 	}
 	setPoles(a, b) {
@@ -6930,63 +4738,65 @@ let RangeMultiElement = class RangeMultiElement extends LitElement {
 					const currentPos = isVertical ? current.offset.y : current.offset.x;
 					const amt = (isVertical ? startPos - currentPos : currentPos - startPos) / valuePerPix;
 					polesChanged = true;
-					if (draggingWhich === `a`) if (resizeMode === `bipolar`) {
-						const calcA = startA + amt;
-						const calcB = startB - amt;
-						if (calcA < min || calcB > max || calcA > max || calcB < min) return;
-						setPoles(calcA, calcB);
-					} else if (resizeMode === `bipolar-flex`) {
-						let calcA = startA + amt;
-						let calcB = startB;
-						if (startB <= min) calcB = min;
-						else if (startB >= max) calcB = max;
-						else {
-							calcA = startA + amt;
-							calcB = startB - amt;
+					if (draggingWhich === `a`) {
+						if (resizeMode === `bipolar`) {
+							const calcA = startA + amt;
+							const calcB = startB - amt;
+							if (calcA < min || calcB > max || calcA > max || calcB < min) return;
+							setPoles(calcA, calcB);
+						} else if (resizeMode === `bipolar-flex`) {
+							let calcA = startA + amt;
+							let calcB = startB;
+							if (startB <= min) calcB = min;
+							else if (startB >= max) calcB = max;
+							else {
+								calcA = startA + amt;
+								calcB = startB - amt;
+							}
+							if (calcA < min) calcA = min;
+							if (calcA > max) calcA = max;
+							if (calcB < min) calcB = min;
+							if (calcB > max) calcB = max;
+							if (calcA > calcB) return;
+							setPoles(calcA, calcB);
+						} else {
+							let constrainedAmt = amt;
+							if (startA + amt < min) constrainedAmt = min - startA;
+							if (startB + constrainedAmt > max) constrainedAmt = max - startB;
+							const finalA = startA + constrainedAmt;
+							const finalB = startB + constrainedAmt;
+							if (finalA >= min && finalB <= max) setPoles(finalA, finalB);
 						}
-						if (calcA < min) calcA = min;
-						if (calcA > max) calcA = max;
-						if (calcB < min) calcB = min;
-						if (calcB > max) calcB = max;
-						if (calcA > calcB) return;
-						setPoles(calcA, calcB);
-					} else {
-						let constrainedAmt = amt;
-						if (startA + amt < min) constrainedAmt = min - startA;
-						if (startB + constrainedAmt > max) constrainedAmt = max - startB;
-						const finalA = startA + constrainedAmt;
-						const finalB = startB + constrainedAmt;
-						if (finalA >= min && finalB <= max) setPoles(finalA, finalB);
-					}
-					else if (draggingWhich === `b`) if (resizeMode === `bipolar`) {
-						const calcA = startA - amt;
-						const calcB = startB + amt;
-						if (calcA < min || calcB > max || calcA > max || calcB < min) return;
-						setPoles(calcA, calcB);
-					} else if (resizeMode === `bipolar-flex`) {
-						let calcA = startA;
-						let calcB = startB + amt;
-						if (startA <= min) calcA = min;
-						else if (startA >= max) calcA = max;
-						else {
-							calcA = startA - amt;
-							calcB = startB + amt;
+					} else if (draggingWhich === `b`) {
+						if (resizeMode === `bipolar`) {
+							const calcA = startA - amt;
+							const calcB = startB + amt;
+							if (calcA < min || calcB > max || calcA > max || calcB < min) return;
+							setPoles(calcA, calcB);
+						} else if (resizeMode === `bipolar-flex`) {
+							let calcA = startA;
+							let calcB = startB + amt;
+							if (startA <= min) calcA = min;
+							else if (startA >= max) calcA = max;
+							else {
+								calcA = startA - amt;
+								calcB = startB + amt;
+							}
+							if (calcA < min) calcA = min;
+							if (calcA > max) calcA = max;
+							if (calcB < min) calcB = min;
+							if (calcB > max) calcB = max;
+							if (calcA > calcB) return;
+							setPoles(calcA, calcB);
+						} else {
+							let constrainedAmt = amt;
+							if (startA + amt < min) constrainedAmt = min - startA;
+							if (startB + constrainedAmt > max) constrainedAmt = max - startB;
+							const finalA = startA + constrainedAmt;
+							const finalB = startB + constrainedAmt;
+							if (finalA >= min && finalB <= max) setPoles(finalA, finalB);
 						}
-						if (calcA < min) calcA = min;
-						if (calcA > max) calcA = max;
-						if (calcB < min) calcB = min;
-						if (calcB > max) calcB = max;
-						if (calcA > calcB) return;
-						setPoles(calcA, calcB);
-					} else {
-						let constrainedAmt = amt;
-						if (startA + amt < min) constrainedAmt = min - startA;
-						if (startB + constrainedAmt > max) constrainedAmt = max - startB;
-						const finalA = startA + constrainedAmt;
-						const finalB = startB + constrainedAmt;
-						if (finalA >= min && finalB <= max) setPoles(finalA, finalB);
-					}
-					else if (resizeMode === `bipolar`) {
+					} else if (resizeMode === `bipolar`) {
 						const calcA = startA + amt;
 						const calcB = startB + amt;
 						if (calcA < min || calcB > max) return;
@@ -7317,7 +5127,7 @@ let TabListItemElement = class TabListItemElement extends LitElement {
 			prominenceStyles,
 			css`
       :host {
-        --selected-colour: var(--accent);
+        --selected-colour: var(--surface-2-text);
         --selected-border-width: 1px;
         --padding: var(--space-m);
         display: inline-flex;
@@ -7343,6 +5153,8 @@ let TabListItemElement = class TabListItemElement extends LitElement {
         border-bottom-color: var(--indicator-color-bottom, transparent);
         border-left-color: var(--indicator-color-left, transparent);
         border-right-color: var(--indicator-color-right, transparent);
+        background: var(--surface-5);
+        font-weight: bold;
       }
 
       .label {
@@ -7366,13 +5178,18 @@ let TabListItemElement = class TabListItemElement extends LitElement {
       }
 
       .toolbar {
-        display: none;
+        /* Always laid out (display: flex) so the tab's width doesn't shift when
+           the toolbar appears on selection. visibility: hidden keeps the
+           toolbar from receiving pointer events or painting, while preserving
+           the space its contents take up. */
+        display: flex;
         align-items: center;
         gap: var(--space-xs);
+        visibility: hidden;
       }
 
       :host([selected]) .toolbar {
-        display: flex;
+        visibility: visible;
       }
 
       slot[name="toolbar"] {
@@ -7795,86 +5612,11 @@ function monitorIndeterminate(targetElOrQuery, watchedElsOrQueries) {
 	};
 }
 //#endregion
-//#region src/util/is-numeric.ts
-function isNumeric(str) {
-	if (typeof str === `number`) return true;
-	if (typeof str !== `string`) return false;
-	const trimmed = str.trim();
-	return trimmed !== `` && !Number.isNaN(Number(trimmed));
-}
-//#endregion
-//#region src/util/tooltip.ts
-var _TooltipElement;
-let TooltipElement = class TooltipElement extends LitElement {
-	static {
-		_TooltipElement = this;
-	}
-	constructor(..._args) {
-		super(..._args);
-		this.valueFormatTooltip = _TooltipElement.defaultFormatter;
-		this.orientation = `top`;
-		this.anchor = `--tooltip`;
-	}
-	static {
-		this.numberFormatter = (v) => Math.floor(v).toString();
-	}
-	static {
-		this.defaultFormatter = (v) => {
-			if (typeof v === `number`) {
-				if (Number.isInteger(v)) return v.toString();
-				return v.toFixed(2);
-			} else if (typeof v === `string`) return v;
-			else return JSON.stringify(v);
-		};
-	}
-	#renderIcon() {
-		if (!this.icon) return nothing;
-		if (this.icon.startsWith(`<svg`)) return html`<span class="tooltip-icon" style="display:inline-flex;align-items:center;margin-right:0.25em">${unsafeHTML(this.icon)}</span>`;
-		if (!getIcon(this.icon)) return nothing;
-		return html`<ixfx-icon class="tooltip-icon" style="margin-right:0.25em" name="${this.icon}"></ixfx-icon>`;
-	}
-	render() {
-		const classes = {
-			"tooltip": true,
-			"tooltip-orientation-top": this.orientation === `top`,
-			"tooltip-orientation-bottom": this.orientation === `bottom`,
-			"tooltip-orientation-right": this.orientation === `right`,
-			"tooltip-orientation-left": this.orientation === `left`,
-			"tooltip-type-text": true,
-			"tooltip-type-number": false,
-			"tooltip-style-bubble": true
-		};
-		let value = ``;
-		switch (typeof this.value) {
-			case `number`:
-				classes[`tooltip-type-number`] = true;
-				value = this.valueFormatTooltip(this.value);
-				break;
-			case `string`:
-				if (isNumeric(this.value)) {
-					classes[`tooltip-type-number`] = true;
-					value = this.valueFormatTooltip(Number.parseFloat(this.value));
-				} else value = this.value;
-				break;
-			default: value = JSON.stringify(this.value);
-		}
-		return html`<output style="--anchor-id: ${this.anchor}" class=${classMap(classes)}>${this.#renderIcon()}${value}</output>`;
-	}
-	createRenderRoot() {
-		return this;
-	}
-};
-__decorate([property({ type: String })], TooltipElement.prototype, "orientation", void 0);
-__decorate([property({ type: String })], TooltipElement.prototype, "anchor", void 0);
-__decorate([property()], TooltipElement.prototype, "value", void 0);
-__decorate([property({ type: String })], TooltipElement.prototype, "icon", void 0);
-TooltipElement = _TooltipElement = __decorate([safeCustomElement(`ixfx-tooltip`)], TooltipElement);
-//#endregion
 //#region src/index.ts
 function init() {
 	console.log(`Init`);
 }
 //#endregion
-export { AcTextElement, AcTokenElement, ButtonElement, Checkbox, ColourPicker, ColourPickerPopup, CrumbNavigationElement, CrumbPathController, CrumbPathElement, DataController, DataDisplayComponent, EditableLabel, EditableNumber, GroupedItemListerElement, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, IxfxHexEditorElement, IxfxIconElement, IxfxTimelineElement, LabelledRadialInput, LabelledRangeInput, LedElement, menu_exports as Menu, MillerBaseElement, MillerListElement, MillerTreeController, NarrowedTextElement, PanelElement, PanelGroupElement, PlotDataSeries, PlotHistogram, PlotMultiAxis, PlotSingleAxis, PlotXyAxis, PolarPad, RadialInputElement, RadioGroup, RangeElement, RangeInput, RangeMultiElement, SelectHorizontalElement, SnapContainer, SplitButton, SplitLayoutElement, SwipeElement, TabListElement, TabListItemElement, TabPanelElement, TabPanelsElement, TimelineController, TimelineTrackTabElement, TooltipElement, TransitoryLabelElement, TreeBaseElement, TreeController, TreeDataModel, TreeListElement, VerticalListElement, XyPad, applyAgeModification, applyHighlights, attachTimelineInteractions, buildHighlightTargets, clearHighlights, collectDataResult, computeColour, createAcCompletionProvider, createElementIncrSearch, createFuzzySearch, createIncrSearch, createTreeListAdapter, createVerticalListAdapter, getIcon, hasIcon, iconBus, init, monitorIndeterminate, parseColourScaleAttr, readBaseColour, registerIcon, resolveCssVars, resolveGrid, svgToDataUri, timelineStyles };
+export { AcTextElement, AcTokenElement, ButtonElement, Checkbox, ColourPicker, ColourPickerPopup, CrumbNavigationElement, CrumbPathController, CrumbPathElement, DataController, DataDisplayComponent, EditableLabel, EditableNumber, GroupedItemListerElement, ICON_CARET_RIGHT, ICON_CHECK, ICON_CHEVRON_DOWN, ICON_CLOSE, IncrSearchTreeController as IncrSearchMillerController, IncrSearchTreeController, IxfxHexEditorElement, IxfxIconElement, IxfxTimelineElement, LabelledRadialInput, LabelledRangeInput, LedElement, menu_exports as Menu, MillerBaseElement, MillerListElement, MillerTreeController, NarrowedTextElement, NotificationManager, NotificationPillElement, PanelElement, PanelGroupElement, PlotDataSeries, PlotHistogram, PlotMultiAxis, PlotSingleAxis, PlotXyAxis, PolarPad, RadialInputElement, RadioGroup, RangeElement, RangeInput, RangeMultiElement, SelectHorizontalElement, SliderInputElement, SnapContainer, SplitButton, SplitLayoutElement, SwipeElement, TabListElement, TabListItemElement, TabPanelElement, TabPanelsElement, TimelineController, TimelineTrackTabElement, TooltipElement, TransitoryLabelElement, TreeBaseElement, TreeController, TreeDataModel, TreeListElement, VerticalListElement, XyPad, applyAgeModification, applyHighlights, attachTimelineInteractions, buildHighlightTargets, clearHighlights, collectDataResult, computeColour, createAcCompletionProvider, createElementIncrSearch, createFuzzySearch, createIncrSearch, createPillRenderer, createTreeListAdapter, createVerticalListAdapter, getIcon, hasIcon, iconBus, init, monitorIndeterminate, parseColourScaleAttr, readBaseColour, registerIcon, resolveCssVars, resolveGrid, svgToDataUri, timelineStyles };
 
 //# sourceMappingURL=index.js.map