@carto/ps-react-ui 4.19.0 → 4.20.1

package/dist/spread-Dy8pshpN.js

@@ -0,0 +1,149 @@
+import { C as e, T as t } from "./stores-BVFMfgyo.js";
+import { n, t as r } from "./download-BT6qBamM.js";
+import { a as i, c as a, l as o, o as s, s as c, u as l } from "./formula-Dsru_p-g.js";
+import { c as u } from "react/compiler-runtime";
+import { Box as d, Skeleton as f } from "@mui/material";
+import { jsx as p, jsxs as m } from "react/jsx-runtime";
+//#region src/widgets-v2/spread/separator.tsx
+function h() {
+	let e = u(1), t;
+	return e[0] === Symbol.for("react.memo_cache_sentinel") ? (t = /* @__PURE__ */ p(s, {
+		color: "inherit",
+		children: "-"
+	}), e[0] = t) : t = e[0], t;
+}
+//#endregion
+//#region src/widgets-v2/spread/spread-ui.tsx
+function g(e) {
+	let t = u(8), { items: n, formatter: r, ref: f } = e, g = r ?? _, v;
+	if (t[0] !== g || t[1] !== n) {
+		let e;
+		t[3] === g ? e = t[4] : (e = (e, t) => /* @__PURE__ */ m(d, {
+			sx: i.row,
+			children: [e.series ? /* @__PURE__ */ p(a, {
+				name: e.series.name,
+				color: e.series.color
+			}) : null, /* @__PURE__ */ m(d, {
+				sx: i.body,
+				children: [/* @__PURE__ */ m(d, {
+					sx: i.valueRow,
+					children: [
+						e.prefix ? /* @__PURE__ */ p(o, { children: e.prefix }) : null,
+						/* @__PURE__ */ p(s, {
+							color: e.color,
+							children: g(e.min)
+						}),
+						/* @__PURE__ */ p(h, {}),
+						/* @__PURE__ */ p(s, {
+							color: e.color,
+							children: g(e.max)
+						}),
+						e.suffix ? /* @__PURE__ */ p(c, { children: e.suffix }) : null
+					]
+				}), e.note ? /* @__PURE__ */ p(l, { children: e.note }) : null]
+			})]
+		}, `spread-${e.series?.name ?? ""}-${e.min}-${e.max}-${t}`), t[3] = g, t[4] = e), v = n.map(e), t[0] = g, t[1] = n, t[2] = v;
+	} else v = t[2];
+	let y;
+	return t[5] !== f || t[6] !== v ? (y = /* @__PURE__ */ p(d, {
+		ref: f,
+		sx: i.root,
+		children: v
+	}), t[5] = f, t[6] = v, t[7] = y) : y = t[7], y;
+}
+function _(e) {
+	return String(e);
+}
+//#endregion
+//#region src/widgets-v2/spread/spread.tsx
+var v = Object.freeze([]), y = (e) => ({
+	data: e.data ?? v,
+	formatter: e.formatter
+});
+function b() {
+	let n = u(3), r = t(), i = e(r, y), a;
+	return n[0] !== i.data || n[1] !== i.formatter ? (a = /* @__PURE__ */ p(g, {
+		items: i.data,
+		formatter: i.formatter
+	}), n[0] = i.data, n[1] = i.formatter, n[2] = a) : a = n[2], a;
+}
+//#endregion
+//#region src/widgets-v2/spread/skeleton.tsx
+var x = {
+	root: {
+		display: "flex",
+		flexDirection: "column",
+		gap: 2,
+		py: 1
+	},
+	row: {
+		display: "flex",
+		alignItems: "center",
+		gap: 1.5
+	},
+	block: {
+		width: 200,
+		height: 32
+	}
+};
+function S(e) {
+	let t = u(2), { count: n } = e, r = n === void 0 ? 1 : n, i;
+	return t[0] === r ? i = t[1] : (i = /* @__PURE__ */ p(d, {
+		sx: x.root,
+		children: Array.from({ length: r }).map(C)
+	}), t[0] = r, t[1] = i), i;
+}
+function C(e, t) {
+	return /* @__PURE__ */ p(d, {
+		sx: x.row,
+		children: /* @__PURE__ */ p(f, {
+			variant: "rectangular",
+			sx: x.block
+		})
+	}, `row-${t}`);
+}
+//#endregion
+//#region src/widgets-v2/spread/download.ts
+function w(e) {
+	let t = [];
+	return e.getCaptureEl && t.push(n({
+		filename: e.filename,
+		getCaptureEl: e.getCaptureEl,
+		pixelRatio: e.pngPixelRatio,
+		backgroundColor: e.pngBackgroundColor
+	})), t.push(r({
+		filename: e.filename,
+		getRows: () => {
+			let t = e.getData(), n = [[
+				"series",
+				"prefix",
+				"min",
+				"max",
+				"suffix",
+				"note"
+			]];
+			for (let e of t) n.push([
+				e.series?.name ?? "",
+				e.prefix ?? "",
+				e.min,
+				e.max,
+				e.suffix ?? "",
+				e.note ?? ""
+			]);
+			return n;
+		}
+	})), t;
+}
+//#endregion
+//#region src/widgets-v2/spread/band.ts
+function T({ value: e, spread: t, variant: n = "percentage" }) {
+	let r = n === "absolute" ? t : t / 100 * e, i = Math.abs(r);
+	return {
+		min: e - i,
+		max: e + i
+	};
+}
+//#endregion
+export { g as a, b as i, w as n, h as o, S as r, T as t };
+
+//# sourceMappingURL=spread-Dy8pshpN.js.map

package/dist/spread-Dy8pshpN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spread-Dy8pshpN.js","names":["Value","Separator","$","_c","t0","Symbol","for","Box","Ref","Note","Prefix","Series","Suffix","Value","styles","Separator","SpreadDataItem","SpreadUIProps","items","formatter","value","ref","HTMLDivElement","SpreadUI","t0","$","_c","fmt","_temp","t1","t2","item","i","series","name","min","max","row","color","body","valueRow","prefix","suffix","note","map","root","n","String","useWidgetId","useWidgetShallow","SpreadUI","SpreadWidgetData","SpreadSlice","data","formatter","value","EMPTY_DATA","Object","freeze","spreadSelector","s","Spread","$","_c","id","slice","t0","Box","Skeleton","SxProps","Theme","styles","root","display","flexDirection","gap","py","row","alignItems","block","width","height","Record","SpreadSkeletonProps","count","SpreadSkeleton","t0","$","_c","t1","undefined","t2","Array","from","length","map","_temp","_","i","buildCsvDownloadItem","buildPngDownloadItem","DownloadItem","SpreadWidgetData","createSpreadDownloadConfig","args","filename","getData","getCaptureEl","HTMLElement","pngPixelRatio","pngBackgroundColor","items","push","pixelRatio","backgroundColor","getRows","data","rows","item","series","name","prefix","min","max","suffix","note","SpreadVariant","GetSpreadBandOptions","value","spread","variant","getSpreadBand","min","max","offset","width","Math","abs"],"sources":["../src/widgets-v2/spread/separator.tsx","../src/widgets-v2/spread/spread-ui.tsx","../src/widgets-v2/spread/spread.tsx","../src/widgets-v2/spread/skeleton.tsx","../src/widgets-v2/spread/download.ts","../src/widgets-v2/spread/band.ts"],"sourcesContent":["import { Value } from '../formula'\n\n/**\n * Em-dash separator placed between a Spread row's `min` and `max` values.\n * Built from the Formula {@link Value} primitive so typography (h5/600,\n * baseline alignment) matches the numbers around it. Renders with\n * `text.secondary` so it visually recedes between the two bounds.\n */\nexport function Separator() {\n  return <Value color='inherit'>-</Value>\n}\n","import { Box } from '@mui/material'\nimport type { Ref } from 'react'\nimport { Note, Prefix, Series, Suffix, Value } from '../formula'\nimport { styles } from '../formula/style'\nimport { Separator } from './separator'\nimport type { SpreadDataItem } from './types'\n\nexport interface SpreadUIProps {\n  items: readonly SpreadDataItem[]\n  /** Number formatter — applied to each item's `min` and `max`. */\n  formatter?: (value: number) => string\n  /** Forwarded to the root `<Box>` so consumers can capture the DOM (PNG export). */\n  ref?: Ref<HTMLDivElement>\n}\n\n/**\n * Pure presentational component for the Spread widget. Each item renders as\n * a row containing (in order): optional `Series` avatar, a body with\n * `[prefix] min — max [suffix]` plus optional `Note`. Reuses the Formula\n * primitives ({@link Series}, {@link Prefix}, {@link Value}, {@link Suffix},\n * {@link Note}) and the Formula row styles so Spread and Formula stay\n * visually aligned when used together.\n */\nexport function SpreadUI({ items, formatter, ref }: SpreadUIProps) {\n  const fmt = formatter ?? ((n: number) => String(n))\n  return (\n    <Box ref={ref} sx={styles.root}>\n      {items.map((item, i) => (\n        // Composite of series name + min/max bounds for stability across\n        // reorders; falls back to the index when bounds happen to collide.\n        <Box\n          key={`spread-${item.series?.name ?? ''}-${item.min}-${item.max}-${i}`}\n          sx={styles.row}\n        >\n          {item.series ? (\n            <Series name={item.series.name} color={item.series.color} />\n          ) : null}\n          <Box sx={styles.body}>\n            <Box sx={styles.valueRow}>\n              {item.prefix ? <Prefix>{item.prefix}</Prefix> : null}\n              <Value color={item.color}>{fmt(item.min)}</Value>\n              <Separator />\n              <Value color={item.color}>{fmt(item.max)}</Value>\n              {item.suffix ? <Suffix>{item.suffix}</Suffix> : null}\n            </Box>\n            {item.note ? <Note>{item.note}</Note> : null}\n          </Box>\n        </Box>\n      ))}\n    </Box>\n  )\n}\n","import { useWidgetId, useWidgetShallow } from '../stores'\nimport { SpreadUI } from './spread-ui'\nimport type { SpreadWidgetData } from './types'\n\ninterface SpreadSlice {\n  data: SpreadWidgetData\n  formatter?: (value: number) => string\n}\n\n// Stable empty-data sentinel — keeps the slice's `data` reference stable\n// when the underlying store value is null/undefined so the shallow-equality\n// gate in `useWidgetShallow` doesn't re-render every commit.\nconst EMPTY_DATA: SpreadWidgetData = Object.freeze([]) as SpreadWidgetData\n\nconst spreadSelector = (s: {\n  data: unknown\n  formatter?: (value: number) => string\n}): SpreadSlice => ({\n  data: (s.data ?? EMPTY_DATA) as SpreadWidgetData,\n  formatter: s.formatter,\n})\n\n/**\n * Stateful Spread bridge — reads `data` (post-pipeline) and `formatter` from\n * the per-widget store and forwards them to the pure {@link SpreadUI}.\n */\nexport function Spread() {\n  const id = useWidgetId()\n  const slice = useWidgetShallow(id, spreadSelector)\n  return <SpreadUI items={slice.data} formatter={slice.formatter} />\n}\n","import { Box, Skeleton } from '@mui/material'\nimport type { SxProps, Theme } from '@mui/material'\n\nconst styles = {\n  root: {\n    display: 'flex',\n    flexDirection: 'column',\n    gap: 2,\n    py: 1,\n  },\n  row: {\n    display: 'flex',\n    alignItems: 'center',\n    gap: 1.5,\n  },\n  block: { width: 200, height: 32 },\n} satisfies Record<string, SxProps<Theme>>\n\nexport interface SpreadSkeletonProps {\n  count?: number\n}\n\n/**\n * Loading placeholder for the Spread widget. Renders `count` rows, each\n * sized for the `min — max` pair so the layout doesn't jump once data\n * resolves. Mirrors the row-per-item structure of {@link SpreadUI}.\n */\nexport function SpreadSkeleton({ count = 1 }: SpreadSkeletonProps) {\n  return (\n    <Box sx={styles.root}>\n      {Array.from({ length: count }).map((_, i) => (\n        <Box key={`row-${i}`} sx={styles.row}>\n          <Skeleton variant='rectangular' sx={styles.block} />\n        </Box>\n      ))}\n    </Box>\n  )\n}\n","import {\n  buildCsvDownloadItem,\n  buildPngDownloadItem,\n  type DownloadItem,\n} from '../actions/download'\nimport type { SpreadWidgetData } from './types'\n\n/**\n * Download menu items for the Spread widget. Always includes a CSV item\n * with `series, prefix, min, max, suffix, note` columns (one row per\n * entry). When `getCaptureEl` is supplied, prepends a PNG item that\n * rasterises the captured element via `html2canvas`.\n */\nexport function createSpreadDownloadConfig(args: {\n  filename: string\n  getData: () => SpreadWidgetData\n  getCaptureEl?: () => HTMLElement | null\n  pngPixelRatio?: number\n  pngBackgroundColor?: string | null\n}): DownloadItem[] {\n  const items: DownloadItem[] = []\n  if (args.getCaptureEl) {\n    items.push(\n      buildPngDownloadItem({\n        filename: args.filename,\n        getCaptureEl: args.getCaptureEl,\n        pixelRatio: args.pngPixelRatio,\n        backgroundColor: args.pngBackgroundColor,\n      }),\n    )\n  }\n  items.push(\n    buildCsvDownloadItem({\n      filename: args.filename,\n      getRows: () => {\n        const data = args.getData()\n        const rows: unknown[][] = [\n          ['series', 'prefix', 'min', 'max', 'suffix', 'note'],\n        ]\n        for (const item of data) {\n          rows.push([\n            item.series?.name ?? '',\n            item.prefix ?? '',\n            item.min,\n            item.max,\n            item.suffix ?? '',\n            item.note ?? '',\n          ])\n        }\n        return rows\n      },\n    }),\n  )\n  return items\n}\n","/**\n * How a `spread` amount is applied to a centre value.\n *\n * - `percentage` — `spread` is a whole-number percentage of the centre\n *   value, so `5` means +/-5%.\n * - `absolute` — `spread` is a raw offset in the value's own units.\n */\nexport type SpreadVariant = 'percentage' | 'absolute'\n\nexport interface GetSpreadBandOptions {\n  /** The centre value the band is drawn around. */\n  value: number\n  /** Half-width of the band, read according to `variant`. */\n  spread: number\n  /** Defaults to `percentage`. */\n  variant?: SpreadVariant\n}\n\n/**\n * Derives the `min` / `max` band around a centre value, for feeding a\n * {@link SpreadDataItem} from a single aggregated number (a prediction, a\n * target) plus a tolerance — rather than from a real column range.\n *\n * `spread` is read as a percentage by default, which is what a tolerance\n * almost always is: an absolute offset is meaningless without knowing the\n * value's magnitude, and gets visually lost on large values (+/-5 on a\n * prediction of 204,113 renders as a range indistinguishable from a single\n * number).\n *\n * @example\n * getSpreadBand({ value: 1000, spread: 5 })\n * // -> { min: 950, max: 1050 }\n * getSpreadBand({ value: 1000, spread: 5, variant: 'absolute' })\n * // -> { min: 995, max: 1005 }\n */\nexport function getSpreadBand({\n  value,\n  spread,\n  variant = 'percentage',\n}: GetSpreadBandOptions): { min: number; max: number } {\n  const offset = variant === 'absolute' ? spread : (spread / 100) * value\n  // Keep `min <= max`: a percentage of a negative centre value (or a negative\n  // `spread`) yields a negative offset, which would invert the band.\n  const width = Math.abs(offset)\n\n  return { min: value - width, max: value + width }\n}\n"],"mappings":"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"}

package/dist/stores-B81-IU1G.js

@@ -0,0 +1,374 @@
+import { c as e } from "react/compiler-runtime";
+import { createContext as t, isValidElement as n, useContext as r } from "react";
+import { useStore as i } from "zustand";
+import { createStore as a } from "zustand/vanilla";
+import { devtools as o } from "zustand/middleware";
+import { useShallow as s } from "zustand/react/shallow";
+//#region src/legend/stores/legend-context.ts
+var c = t(null);
+function l() {
+	let e = r(c);
+	if (e == null) throw Error("useLegendId() must be called inside <Legend.Provider>. If you are calling from outside the Provider tree, use the hooks (useLegendStore, useLegendShallow) directly with an explicit id.");
+	return e;
+}
+//#endregion
+//#region src/legend/stores/selectors.ts
+var u = (e, t) => e.order - t.order;
+function d(e) {
+	return Object.values(e.groups).sort(u);
+}
+function f(e, t) {
+	return Object.values(e.layers).filter((e) => e.groupId === t).sort(u);
+}
+function p(e) {
+	return Object.values(e.layers).sort(u);
+}
+function m(e) {
+	let t = Object.values(e.groups);
+	return t.length > 0 && t.every((e) => e.collapsed);
+}
+function h(e) {
+	return Object.keys(e.groups).length > 0;
+}
+function g(e) {
+	let t = (t) => f(e, t).filter((e) => e.visible), n = [];
+	for (let r of d(e)) {
+		let e = t(r.id);
+		e.length > 0 && n.push({
+			group: r,
+			layers: e
+		});
+	}
+	let r = t(void 0);
+	return r.length > 0 && n.push({ layers: r }), n;
+}
+function _(e, t) {
+	let n = e.layers[t];
+	return n ? n.variables.length > 0 || (n.sections?.length ?? 0) > 0 || !!n.helperText : !1;
+}
+function v(e, t) {
+	let n = !1, r = !1;
+	for (let i of f(e, t)) i.visible ? n = !0 : r = !0;
+	return n && r ? "mixed" : r ? "hidden" : "visible";
+}
+//#endregion
+//#region src/legend/stores/legend-store-registry.ts
+var y = /* @__PURE__ */ new Map(), b = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Set(), S = () => {
+	try {
+		return !1;
+	} catch {
+		return !1;
+	}
+}, C = (e) => Math.min(1, Math.max(0, e));
+function w(e, t) {
+	return e.visible === t ? null : t ? {
+		visible: t,
+		collapsed: e.collapsedBeforeHide ?? !1,
+		collapsedBeforeHide: void 0
+	} : {
+		visible: t,
+		collapsed: !0,
+		collapsedBeforeHide: e.collapsed
+	};
+}
+function T(e, t) {
+	return e.visible ? { collapsed: t } : {
+		collapsed: t,
+		collapsedBeforeHide: t
+	};
+}
+function E(e, t, n) {
+	let r = e.findIndex((e) => e.id === t);
+	if (r === -1) return null;
+	let i = Math.max(0, Math.min(e.length - 1, n));
+	if (i === r) return null;
+	let a = [...e], [o] = a.splice(r, 1);
+	a.splice(i, 0, o);
+	let s = /* @__PURE__ */ new Map();
+	return a.forEach((e, t) => {
+		e.order !== t && s.set(e.id, t);
+	}), s.size > 0 ? s : null;
+}
+function D(e, t, n) {
+	let r = e.layers[t];
+	return r ? { layers: {
+		...e.layers,
+		[t]: {
+			...r,
+			...n
+		}
+	} } : {};
+}
+function O(e, t, n) {
+	let r = e.groups[t];
+	return r ? { groups: {
+		...e.groups,
+		[t]: {
+			...r,
+			...n
+		}
+	} } : {};
+}
+function k(e, t) {
+	if (!t || !e || e === t) return t;
+	let n = t.map((t) => {
+		let n = e.find((e) => e.id === t.id);
+		return n && n.active !== t.active && t.options.includes(n.active) ? {
+			...t,
+			active: n.active
+		} : t;
+	});
+	return e.length === n.length && n.every((t, n) => {
+		let r = e[n];
+		return r.id === t.id && r.title === t.title && r.options === t.options && r.active === t.active;
+	}) ? e : n;
+}
+function A(e, t) {
+	return !n(e) || !n(t) || e.type !== t.type || e.key !== t.key ? !1 : j(e.props, t.props);
+}
+function j(e, t) {
+	let n = /* @__PURE__ */ new Set([...Object.keys(e), ...Object.keys(t)]);
+	for (let r of n) if (!Object.is(e[r], t[r]) && !A(e[r], t[r])) return !1;
+	return !0;
+}
+function M(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let r of e) {
+		let e = t(r.merged), i = n.get(e);
+		i ? i.push(r) : n.set(e, [r]);
+	}
+	for (let e of n.values()) e.sort((e, t) => e.merged.order - t.merged.order || e.index - t.index).forEach((e, t) => {
+		e.merged.order = t;
+	});
+}
+function N(e, t, n) {
+	return {
+		...t,
+		visible: e?.visible ?? t.visible ?? !0,
+		opacity: e?.opacity ?? t.opacity ?? 1,
+		collapsed: e?.collapsed ?? t.collapsed ?? !1,
+		collapsedBeforeHide: e?.collapsedBeforeHide,
+		sections: k(e?.sections, t.sections),
+		order: e?.order ?? t.order ?? n
+	};
+}
+function P(e, t, n, r) {
+	return {
+		...t,
+		collapsed: e?.collapsed ?? t.collapsed ?? !r,
+		collapsedBeforeHide: e?.collapsedBeforeHide,
+		order: e?.order ?? t.order ?? n
+	};
+}
+function F(e, t, n) {
+	let r = t.map((t, n) => ({
+		index: n,
+		merged: N(e.layers[t.id], t, n)
+	}));
+	M(r, (e) => e.groupId);
+	let i = new Set(r.filter(({ merged: e }) => e.visible && e.groupId != null).map(({ merged: e }) => e.groupId)), a = n.map((t, n) => ({
+		index: n,
+		merged: P(e.groups[t.id], t, n, i.has(t.id))
+	}));
+	M(a, () => void 0);
+	let o = r.length !== Object.keys(e.layers).length, s = {};
+	for (let { merged: t } of r) {
+		let n = e.layers[t.id];
+		n && j(n, t) ? s[t.id] = n : (s[t.id] = t, o = !0);
+	}
+	let c = a.length !== Object.keys(e.groups).length, l = {};
+	for (let { merged: t } of a) {
+		let n = e.groups[t.id];
+		n && j(n, t) ? l[t.id] = n : (l[t.id] = t, c = !0);
+	}
+	return !o && !c ? {} : {
+		layers: o ? s : e.layers,
+		groups: c ? l : e.groups
+	};
+}
+function I(e, t, n) {
+	let r = Object.values(t).map((e, t) => ({
+		index: t,
+		merged: { ...e }
+	}));
+	M(r, n);
+	let i = r.length !== Object.keys(e).length, a = {};
+	for (let { merged: t } of r) {
+		let n = e[t.id];
+		n && j(n, t) ? a[t.id] = n : (a[t.id] = t, i = !0);
+	}
+	return i ? a : null;
+}
+function L(e, t) {
+	let n = Object.values(e.layers).filter((e) => e.groupId === t.groupId && e.id !== t.id).length, r = N(e.layers[t.id], t, n), i = I(e.layers, {
+		...e.layers,
+		[t.id]: r
+	}, (e) => e.groupId);
+	return i ? { layers: i } : {};
+}
+function R(e, t) {
+	if (!e.layers[t]) return {};
+	let n = { ...e.layers };
+	delete n[t];
+	let r = I(e.layers, n, (e) => e.groupId);
+	return r ? { layers: r } : {};
+}
+function z(e, t) {
+	let n = Object.values(e.groups).filter((e) => e.id !== t.id).length, r = Object.values(e.layers).some((e) => e.groupId === t.id && e.visible), i = P(e.groups[t.id], t, n, r), a = I(e.groups, {
+		...e.groups,
+		[t.id]: i
+	}, () => void 0);
+	return a ? { groups: a } : {};
+}
+function B(e, t) {
+	if (!e.groups[t]) return {};
+	let n = { ...e.groups };
+	delete n[t];
+	let r = I(e.groups, n, () => void 0), i = Object.values(e.layers).filter((e) => e.groupId === t);
+	if (i.length === 0) return r ? { groups: r } : {};
+	let a = { ...e.layers };
+	for (let e of i) a[e.id] = {
+		...e,
+		groupId: void 0
+	};
+	let o = I(e.layers, a, (e) => e.groupId);
+	return {
+		...r ? { groups: r } : {},
+		...o ? { layers: o } : {}
+	};
+}
+function V(e, t = {}) {
+	let n = F({
+		layers: {},
+		groups: {}
+	}, t.layers ?? [], t.groups ?? []);
+	return a()(o((e) => ({
+		layers: n.layers ?? {},
+		groups: n.groups ?? {},
+		setVisibility: (t, n) => e((e) => {
+			let r = e.layers[t], i = r && w(r, n);
+			return i ? D(e, t, i) : {};
+		}, !1, "setVisibility"),
+		setOpacity: (t, n) => e((e) => D(e, t, { opacity: C(n) }), !1, "setOpacity"),
+		setCollapsed: (t, n) => e((e) => {
+			let r = e.layers[t];
+			return r ? D(e, t, T(r, n)) : {};
+		}, !1, "setCollapsed"),
+		setSectionValue: (t, n, r) => e((e) => {
+			let i = e.layers[t], a = i?.sections?.find((e) => e.id === n);
+			return !i?.sections || !a || a.active === r || !a.options.includes(r) ? {} : D(e, t, { sections: i.sections.map((e) => e.id === n ? {
+				...e,
+				active: r
+			} : e) });
+		}, !1, "setSectionValue"),
+		moveLayer: (t, n) => e((e) => {
+			let r = e.layers[t];
+			if (!r) return {};
+			let i = E(f(e, r.groupId), t, n);
+			if (!i) return {};
+			let a = { ...e.layers };
+			for (let [e, t] of i) a[e] = {
+				...a[e],
+				order: t
+			};
+			return { layers: a };
+		}, !1, "moveLayer"),
+		setGroupVisibility: (t, n) => e((e) => {
+			let r = e.groups[t];
+			if (!r) return {};
+			let i = Object.values(e.layers).filter((e) => e.groupId === t), a = i.some((e) => e.visible);
+			if (i.length === 0 || !n && !a) return {};
+			let o = { ...e.layers }, s = !1;
+			for (let e of i) {
+				let t = w(e, n);
+				t && (o[e.id] = {
+					...e,
+					...t
+				}, s = !0);
+			}
+			if (!s) return {};
+			let c = null;
+			return !n && a ? c = {
+				collapsed: !0,
+				collapsedBeforeHide: r.collapsed
+			} : n && !a && (c = {
+				collapsed: r.collapsedBeforeHide ?? !1,
+				collapsedBeforeHide: void 0
+			}), {
+				layers: o,
+				...c ? { groups: {
+					...e.groups,
+					[t]: {
+						...r,
+						...c
+					}
+				} } : {}
+			};
+		}, !1, "setGroupVisibility"),
+		setGroupCollapsed: (t, n) => e((e) => {
+			if (!e.groups[t]) return {};
+			let r = Object.values(e.layers).filter((e) => e.groupId === t);
+			return O(e, t, r.length > 0 && r.every((e) => !e.visible) ? {
+				collapsed: n,
+				collapsedBeforeHide: n
+			} : { collapsed: n });
+		}, !1, "setGroupCollapsed"),
+		moveGroup: (t, n) => e((e) => {
+			if (!e.groups[t]) return {};
+			let r = E(d(e), t, n);
+			if (!r) return {};
+			let i = { ...e.groups };
+			for (let [e, t] of r) i[e] = {
+				...i[e],
+				order: t
+			};
+			return { groups: i };
+		}, !1, "moveGroup"),
+		setLegendLayer: (t) => e((e) => L(e, t), !1, "setLegendLayer"),
+		removeLegendLayer: (t) => e((e) => R(e, t), !1, "removeLegendLayer"),
+		setLegendGroup: (t) => e((e) => z(e, t), !1, "setLegendGroup"),
+		removeLegendGroup: (t) => e((e) => B(e, t), !1, "removeLegendGroup"),
+		_sync: (t, n) => e((e) => F(e, t, n), !1, "_sync")
+	}), {
+		name: `legend-${e}`,
+		enabled: S()
+	}));
+}
+function H(e) {
+	let t = y.get(e);
+	if (!t) throw Error(`[legend] Legend store "${e}" not found.`);
+	return t;
+}
+function U(e) {
+	return y.has(e);
+}
+function W(e) {
+	y.delete(e);
+}
+function G() {
+	y.clear(), b.clear(), x.clear();
+}
+function K(e, t) {
+	y.set(e, t);
+}
+function q(e, t) {
+	y.set(e, t);
+	let n = (b.get(e) ?? 0) + 1;
+	b.set(e, n), n > 1 && S() && !x.has(e) && (console.warn(`[legend] Duplicate <Legend.Provider id="${e}"> detected. Multiple providers sharing an id will race on prop sync. Use unique ids per legend panel.`), x.add(e));
+}
+function J(e, t) {
+	let n = (b.get(e) ?? 1) - 1;
+	n <= 0 ? (b.delete(e), t.keepAlive || y.delete(e)) : b.set(e, n);
+}
+function Y(t, n) {
+	let r = e(2), a;
+	return r[0] === t ? a = r[1] : (a = H(t), r[0] = t, r[1] = a), i(a, n);
+}
+function X(t, n) {
+	let r = e(2), a;
+	return r[0] === t ? a = r[1] : (a = H(t), r[0] = t, r[1] = a), i(a, s(n));
+}
+//#endregion
+export { p as _, U as a, l as b, J as c, m as d, v as f, d as g, f as h, H as i, X as l, _ as m, V as n, q as o, h as p, W as r, K as s, G as t, Y as u, g as v, c as y };
+
+//# sourceMappingURL=stores-B81-IU1G.js.map

package/dist/stores-B81-IU1G.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores-B81-IU1G.js","names":["createContext","useContext","LegendContext","useLegendId","id","Error","LegendGroup","LegendLayer","LegendState","byOrder","order","a","T","b","selectOrderedGroups","state","Object","values","groups","sort","selectLayersByGroup","groupId","layers","filter","l","selectOrderedLayers","selectAllGroupsCollapsed","length","every","g","collapsed","selectHasGroups","keys","selectVisibleLayersGrouped","group","visible","sections","id","push","ungrouped","undefined","selectLayerCollapsible","layerId","layer","variables","Boolean","helperText","LegendVisibility","selectGroupVisibility","anyVisible","anyHidden","isValidElement","useStore","StoreApi","createStore","devtools","useShallow","LegendConfigSection","LegendGroup","LegendGroupInput","LegendInit","LegendLayer","LegendLayerInput","LegendState","LegendStoreApi","selectLayersByGroup","selectOrderedGroups","legendStores","Map","legendMountCounts","warnedDuplicates","Set","isDev","Boolean","import","meta","env","DEV","clamp01","n","Math","min","max","visibilityPatch","entity","visible","collapsed","collapsedBeforeHide","undefined","collapsePatch","movePatch","id","order","bucket","T","toIndex","fromIndex","findIndex","e","clamped","length","next","moved","splice","orders","forEach","index","set","size","updateLayer","state","patch","Partial","layer","layers","updateGroup","group","groups","mergeSections","prev","merged","map","section","prevSection","find","p","active","options","includes","sameAsPrev","every","m","i","title","reactElementEqual","a","b","type","key","shallowEqualEntity","props","Record","keys","Object","is","normalizeOrders","entries","bucketOf","buckets","entry","get","push","values","sort","mergeLayerEntity","input","fallbackOrder","opacity","sections","mergeGroupEntity","hasVisibleLayer","syncState","layerInputs","groupInputs","layerEntries","l","groupId","groupsWithVisibleLayer","filter","groupEntries","has","layersChanged","groupsChanged","rebuildRecord","changed","out","before","upsertLayerState","siblingCount","removeLayerState","upsertGroupState","count","g","some","removeGroupState","nextGroups","members","nextLayers","member","createLegendStore","init","seeded","setVisibility","lid","s","setOpacity","setCollapsed","setSectionValue","sectionId","value","x","moveLayer","setGroupVisibility","gid","anyVisible","groupPatch","setGroupCollapsed","hidden","moveGroup","setLegendLayer","removeLegendLayer","setLegendGroup","removeLegendGroup","_sync","name","enabled","getLegendStore","store","Error","hasLegendStore","deleteLegendStore","delete","clearAllLegendStores","clear","setLegendStoreEntry","registerLegendStore","console","warn","add","unregisterLegendStore","keepAlive","useLegendStore","selector","$","_c","t0","useLegendShallow"],"sources":["../src/legend/stores/legend-context.ts","../src/legend/stores/selectors.ts","../src/legend/stores/legend-store-registry.ts"],"sourcesContent":["import { createContext, useContext } from 'react'\n\n/** @experimental This API is new and may change in a future release. */\nexport const LegendContext = createContext<string | null>(null)\n\n/** @experimental This API is new and may change in a future release. */\nexport function useLegendId(): string {\n  const id = useContext(LegendContext)\n  if (id == null) {\n    throw new Error(\n      'useLegendId() must be called inside <Legend.Provider>. ' +\n        'If you are calling from outside the Provider tree, use the hooks ' +\n        '(useLegendStore, useLegendShallow) directly with an explicit id.',\n    )\n  }\n  return id\n}\n","import type { LegendGroup, LegendLayer, LegendState } from './types'\n\nconst byOrder = <T extends { order: number }>(a: T, b: T): number =>\n  a.order - b.order\n\n/**\n * Groups sorted by `order`.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectOrderedGroups(state: LegendState): LegendGroup[] {\n  return Object.values(state.groups).sort(byOrder)\n}\n\n/**\n * Layers belonging to `groupId` (pass `undefined` for ungrouped, top-level\n * layers), sorted by `order`.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectLayersByGroup(\n  state: LegendState,\n  groupId: string | undefined,\n): LegendLayer[] {\n  return Object.values(state.layers)\n    .filter((l) => l.groupId === groupId)\n    .sort(byOrder)\n}\n\n/**\n * All layers sorted by `order`, regardless of group.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectOrderedLayers(state: LegendState): LegendLayer[] {\n  return Object.values(state.layers).sort(byOrder)\n}\n\n/**\n * `true` when every group is collapsed (`false` with no groups) — drives the\n * \"Collapse all groups\" / \"Expand all groups\" menu label flip.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectAllGroupsCollapsed(state: LegendState): boolean {\n  const groups = Object.values(state.groups)\n  return groups.length > 0 && groups.every((g) => g.collapsed)\n}\n\n/**\n * Whether the legend has groups — gates panel-level group actions.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectHasGroups(state: LegendState): boolean {\n  return Object.keys(state.groups).length > 0\n}\n\n/**\n * Visible layers grouped for the enabled-layers menu.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectVisibleLayersGrouped(\n  state: LegendState,\n): { group?: LegendGroup; layers: LegendLayer[] }[] {\n  const visible = (groupId: string | undefined) =>\n    selectLayersByGroup(state, groupId).filter((l) => l.visible)\n  const sections: { group?: LegendGroup; layers: LegendLayer[] }[] = []\n  for (const group of selectOrderedGroups(state)) {\n    const layers = visible(group.id)\n    if (layers.length > 0) sections.push({ group, layers })\n  }\n  const ungrouped = visible(undefined)\n  if (ungrouped.length > 0) sections.push({ layers: ungrouped })\n  return sections\n}\n\n/**\n * Whether a layer has any collapsible body — something the row's `Collapse`\n * can actually fold. A layer with no variables, sections, or helper note\n * renders an empty body, so there is nothing to collapse. Gates the row's\n * title-area collapse affordance (chevron + click).\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectLayerCollapsible(\n  state: LegendState,\n  layerId: string,\n): boolean {\n  const layer = state.layers[layerId]\n  if (!layer) return false\n  return (\n    layer.variables.length > 0 ||\n    (layer.sections?.length ?? 0) > 0 ||\n    // Truthiness matches the render condition — an empty-string note renders\n    // no footer, so it must not enable the collapse affordance.\n    Boolean(layer.helperText)\n  )\n}\n\n/**\n * Tri-state visibility — derived for groups from their member layers, and the\n * state contract of a controlled `Legend.VisibilityToggle` for any custom\n * element kind.\n */\nexport type LegendVisibility = 'visible' | 'hidden' | 'mixed'\n\n/**\n * Tri-state group visibility: `'visible'` when every member layer is visible\n * (also for empty groups), `'hidden'` when none is, `'mixed'` otherwise.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function selectGroupVisibility(\n  state: LegendState,\n  groupId: string,\n): LegendVisibility {\n  let anyVisible = false\n  let anyHidden = false\n  for (const layer of selectLayersByGroup(state, groupId)) {\n    if (layer.visible) anyVisible = true\n    else anyHidden = true\n  }\n  if (anyVisible && anyHidden) return 'mixed'\n  return anyHidden ? 'hidden' : 'visible'\n}\n","import { isValidElement } from 'react'\nimport { useStore, type StoreApi } from 'zustand'\nimport { createStore } from 'zustand/vanilla'\nimport { devtools } from 'zustand/middleware'\nimport { useShallow } from 'zustand/react/shallow'\nimport type {\n  LegendConfigSection,\n  LegendGroup,\n  LegendGroupInput,\n  LegendInit,\n  LegendLayer,\n  LegendLayerInput,\n  LegendState,\n  LegendStoreApi,\n} from './types'\nimport { selectLayersByGroup, selectOrderedGroups } from './selectors'\n\n// Per-panel legend store registry. One store per `<Legend.Provider id>`.\n// Mirrors the widgets-v2 registry pattern (keyed Map + refcounted mounts),\n// without the chart-pipeline machinery.\nconst legendStores = new Map<string, LegendStoreApi>()\nconst legendMountCounts = new Map<string, number>()\nconst warnedDuplicates = new Set<string>()\n\nconst isDev = (): boolean => {\n  try {\n    return Boolean(\n      (import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV,\n    )\n  } catch {\n    return false\n  }\n}\n\nconst clamp01 = (n: number): number => Math.min(1, Math.max(0, n))\n\n// ─── Pure state helpers ─────────────────────────────────────────────────────\n\n/**\n * Visibility↔collapse coupling. Hiding snapshots the current collapsed state\n * and collapses; showing restores the snapshot (manual choices persist) and\n * defaults to expanded. Idempotent: returns `null` when `visible` is already\n * the requested value, so a double-hide can't overwrite the real snapshot.\n */\nfunction visibilityPatch(\n  entity: {\n    visible: boolean\n    collapsed: boolean\n    collapsedBeforeHide?: boolean\n  },\n  visible: boolean,\n): {\n  visible: boolean\n  collapsed: boolean\n  collapsedBeforeHide: boolean | undefined\n} | null {\n  if (entity.visible === visible) return null\n  return visible\n    ? // Showing: restore the pre-hide collapsed state (default expand).\n      {\n        visible,\n        collapsed: entity.collapsedBeforeHide ?? false,\n        collapsedBeforeHide: undefined,\n      }\n    : // Hiding: snapshot, then collapse.\n      {\n        visible,\n        collapsed: true,\n        collapsedBeforeHide: entity.collapsed,\n      }\n}\n\n/**\n * Manual collapse. While hidden, the snapshot follows the manual choice so\n * the next show keeps it.\n */\nfunction collapsePatch(\n  entity: { visible: boolean },\n  collapsed: boolean,\n): { collapsed: boolean; collapsedBeforeHide?: boolean } {\n  return entity.visible\n    ? { collapsed }\n    : { collapsed, collapsedBeforeHide: collapsed }\n}\n\n/**\n * Reorder one entity within its **ordered** bucket: splice it out, insert at\n * the clamped index, and return the dense `order` rewrites (only the entries\n * whose order actually changes). `null` when the position doesn't change or\n * the id isn't in the bucket. Powers `moveLayer` / `moveGroup`.\n */\nfunction movePatch<T extends { id: string; order: number }>(\n  bucket: T[],\n  id: string,\n  toIndex: number,\n): Map<string, number> | null {\n  const fromIndex = bucket.findIndex((e) => e.id === id)\n  if (fromIndex === -1) return null\n  const clamped = Math.max(0, Math.min(bucket.length - 1, toIndex))\n  if (clamped === fromIndex) return null\n  const next = [...bucket]\n  const [moved] = next.splice(fromIndex, 1)\n  next.splice(clamped, 0, moved!)\n  const orders = new Map<string, number>()\n  next.forEach((entity, index) => {\n    if (entity.order !== index) orders.set(entity.id, index)\n  })\n  return orders.size > 0 ? orders : null\n}\n\nfunction updateLayer(\n  state: LegendState,\n  id: string,\n  patch: Partial<LegendLayer>,\n): Partial<LegendState> {\n  const layer = state.layers[id]\n  if (!layer) return {}\n  return { layers: { ...state.layers, [id]: { ...layer, ...patch } } }\n}\n\nfunction updateGroup(\n  state: LegendState,\n  id: string,\n  patch: Partial<LegendGroup>,\n): Partial<LegendState> {\n  const group = state.groups[id]\n  if (!group) return {}\n  return { groups: { ...state.groups, [id]: { ...group, ...patch } } }\n}\n\n/**\n * Merge incoming config-select sections while preserving the user's picked\n * `active` for any section id that still exists and whose pick is still among\n * the new `options` (the structure — ids, titles, options, order — always\n * follows the props). Returns the previous array when the merge lands on the\n * same content, so unchanged syncs keep entity identity (bail-out).\n */\nfunction mergeSections(\n  prev: LegendConfigSection[] | undefined,\n  next: LegendConfigSection[] | undefined,\n): LegendConfigSection[] | undefined {\n  if (!next || !prev || prev === next) return next\n  const merged = next.map((section) => {\n    const prevSection = prev.find((p) => p.id === section.id)\n    return prevSection &&\n      prevSection.active !== section.active &&\n      section.options.includes(prevSection.active)\n      ? { ...section, active: prevSection.active }\n      : section\n  })\n  const sameAsPrev =\n    prev.length === merged.length &&\n    merged.every((m, i) => {\n      const p = prev[i]!\n      return (\n        p.id === m.id &&\n        p.title === m.title &&\n        p.options === m.options &&\n        p.active === m.active\n      )\n    })\n  return sameAsPrev ? prev : merged\n}\n\n/**\n * Same-type, same-key React elements with shallow-equal props count as\n * equal, so a ReactNode field (e.g. `LegendGroup.icon`) re-created inline on\n * every render (`icon={<MyIcon />}`) doesn't look \"changed\" on every sync. A\n * different `key` is treated as a real change, same as a different type.\n */\nfunction reactElementEqual(a: unknown, b: unknown): boolean {\n  if (!isValidElement(a) || !isValidElement(b)) return false\n  if (a.type !== b.type || a.key !== b.key) return false\n  return shallowEqualEntity(\n    a.props as Record<string, unknown>,\n    b.props as Record<string, unknown>,\n  )\n}\n\n/**\n * Shallow equality over the union of both objects' keys — `Object.is` per\n * value, except React elements, which fall back to {@link reactElementEqual}.\n */\nfunction shallowEqualEntity<T extends object>(a: T, b: T): boolean {\n  const keys = new Set([...Object.keys(a), ...Object.keys(b)]) as Set<keyof T>\n  for (const key of keys) {\n    if (Object.is(a[key], b[key])) continue\n    if (!reactElementEqual(a[key], b[key])) return false\n  }\n  return true\n}\n\n/**\n * Reassign `order` to dense indexes `0..n-1` within each sibling bucket,\n * sorted by current order with ties broken by input position. This is the\n * only boundary where external (possibly duplicated) orders enter, so the\n * stored orders stay dense and unique within each bucket.\n */\nfunction normalizeOrders<T extends { order: number }>(\n  entries: { merged: T; index: number }[],\n  bucketOf: (e: T) => string | undefined,\n): void {\n  const buckets = new Map<string | undefined, { merged: T; index: number }[]>()\n  for (const entry of entries) {\n    const key = bucketOf(entry.merged)\n    const bucket = buckets.get(key)\n    if (bucket) bucket.push(entry)\n    else buckets.set(key, [entry])\n  }\n  for (const bucket of buckets.values()) {\n    bucket\n      .sort((a, b) => a.merged.order - b.merged.order || a.index - b.index)\n      .forEach((entry, i) => {\n        entry.merged.order = i\n      })\n  }\n}\n\n/**\n * Seed/merge one layer: static fields follow the input; interactive state\n * (`visible`/`opacity`/`collapsed`/`order`/`collapsedBeforeHide` + section\n * actives) sticks to the store entry when present. Shared by `_sync` (per\n * entry) and the imperative `setLegendLayer`.\n */\nfunction mergeLayerEntity(\n  prev: LegendLayer | undefined,\n  input: LegendLayerInput,\n  fallbackOrder: number,\n): LegendLayer {\n  return {\n    ...input,\n    visible: prev?.visible ?? input.visible ?? true,\n    opacity: prev?.opacity ?? input.opacity ?? 1,\n    collapsed: prev?.collapsed ?? input.collapsed ?? false,\n    collapsedBeforeHide: prev?.collapsedBeforeHide,\n    sections: mergeSections(prev?.sections, input.sections),\n    order: prev?.order ?? input.order ?? fallbackOrder,\n  } as LegendLayer\n}\n\n/**\n * Group counterpart of {@link mergeLayerEntity}. A group with no `prev`\n * state (first sync) defaults collapsed when none of its member layers is\n * visible yet — `hasVisibleLayer` is ignored once the group exists so a\n * user's manual expand/collapse always sticks.\n */\nfunction mergeGroupEntity(\n  prev: LegendGroup | undefined,\n  input: LegendGroupInput,\n  fallbackOrder: number,\n  hasVisibleLayer: boolean,\n): LegendGroup {\n  return {\n    ...input,\n    collapsed: prev?.collapsed ?? input.collapsed ?? !hasVisibleLayer,\n    collapsedBeforeHide: prev?.collapsedBeforeHide,\n    order: prev?.order ?? input.order ?? fallbackOrder,\n  } as LegendGroup\n}\n\n/**\n * Merge incoming definitions while preserving interactive state of known\n * entities: static fields (name, subtitle, variables, attributes, …) follow\n * the props; `visible`/`opacity`/`collapsed`/`order` stick to what's in the\n * store. New entities are seeded; vanished ones are dropped. Sibling orders\n * are normalized to dense indexes.\n *\n * Unchanged entities keep their previous object identity (`variables`\n * compared by reference), and when nothing changed at all the sync is a\n * no-op (`{}`), so stable consumer props never produce a state update.\n */\nfunction syncState(\n  state: LegendState,\n  layerInputs: LegendLayerInput[],\n  groupInputs: LegendGroupInput[],\n): Partial<LegendState> {\n  const layerEntries = layerInputs.map((input, index) => ({\n    index,\n    merged: mergeLayerEntity(state.layers[input.id], input, index),\n  }))\n  normalizeOrders(layerEntries, (l) => l.groupId)\n\n  const groupsWithVisibleLayer = new Set(\n    layerEntries\n      .filter(({ merged }) => merged.visible && merged.groupId != null)\n      .map(({ merged }) => merged.groupId!),\n  )\n  const groupEntries = groupInputs.map((input, index) => ({\n    index,\n    merged: mergeGroupEntity(\n      state.groups[input.id],\n      input,\n      index,\n      groupsWithVisibleLayer.has(input.id),\n    ),\n  }))\n  normalizeOrders(groupEntries, () => undefined)\n\n  // Reference preservation: reuse the previous entity object when nothing\n  // about it changed, so subscribers see stable identities.\n  let layersChanged = layerEntries.length !== Object.keys(state.layers).length\n  const layers: Record<string, LegendLayer> = {}\n  for (const { merged } of layerEntries) {\n    const prev = state.layers[merged.id]\n    if (prev && shallowEqualEntity(prev, merged)) {\n      layers[merged.id] = prev\n    } else {\n      layers[merged.id] = merged\n      layersChanged = true\n    }\n  }\n\n  let groupsChanged = groupEntries.length !== Object.keys(state.groups).length\n  const groups: Record<string, LegendGroup> = {}\n  for (const { merged } of groupEntries) {\n    const prev = state.groups[merged.id]\n    if (prev && shallowEqualEntity(prev, merged)) {\n      groups[merged.id] = prev\n    } else {\n      groups[merged.id] = merged\n      groupsChanged = true\n    }\n  }\n\n  if (!layersChanged && !groupsChanged) return {}\n  return {\n    layers: layersChanged ? layers : state.layers,\n    groups: groupsChanged ? groups : state.groups,\n  }\n}\n\n/**\n * Rebuild a layer/group record from a candidate map, normalizing dense order\n * per bucket and preserving the previous object identity for entries that are\n * unchanged. Returns `null` when nothing changed (so callers can bail with\n * `{}`).\n */\nfunction rebuildRecord<\n  T extends { id: string; order: number; groupId?: string },\n>(\n  prev: Record<string, T>,\n  next: Record<string, T>,\n  bucketOf: (e: T) => string | undefined,\n): Record<string, T> | null {\n  const entries = Object.values(next).map((e, index) => ({\n    index,\n    merged: { ...e },\n  }))\n  normalizeOrders(entries, bucketOf)\n  let changed = entries.length !== Object.keys(prev).length\n  const out: Record<string, T> = {}\n  for (const { merged } of entries) {\n    const before = prev[merged.id]\n    if (before && shallowEqualEntity(before, merged)) {\n      out[merged.id] = before\n    } else {\n      out[merged.id] = merged\n      changed = true\n    }\n  }\n  return changed ? out : null\n}\n\n/** Add or update a single layer (imperative `setLegendLayer`). */\nfunction upsertLayerState(\n  state: LegendState,\n  input: LegendLayerInput,\n): Partial<LegendState> {\n  const siblingCount = Object.values(state.layers).filter(\n    (l) => l.groupId === input.groupId && l.id !== input.id,\n  ).length\n  const merged = mergeLayerEntity(state.layers[input.id], input, siblingCount)\n  const layers = rebuildRecord(\n    state.layers,\n    { ...state.layers, [input.id]: merged },\n    (l) => l.groupId,\n  )\n  return layers ? { layers } : {}\n}\n\n/** Remove a single layer, re-densifying its sibling orders. */\nfunction removeLayerState(\n  state: LegendState,\n  id: string,\n): Partial<LegendState> {\n  if (!state.layers[id]) return {}\n  const next = { ...state.layers }\n  delete next[id]\n  const layers = rebuildRecord(state.layers, next, (l) => l.groupId)\n  return layers ? { layers } : {}\n}\n\n/** Add or update a single group (imperative `setLegendGroup`). */\nfunction upsertGroupState(\n  state: LegendState,\n  input: LegendGroupInput,\n): Partial<LegendState> {\n  const count = Object.values(state.groups).filter(\n    (g) => g.id !== input.id,\n  ).length\n  const hasVisibleLayer = Object.values(state.layers).some(\n    (l) => l.groupId === input.id && l.visible,\n  )\n  const merged = mergeGroupEntity(\n    state.groups[input.id],\n    input,\n    count,\n    hasVisibleLayer,\n  )\n  const groups = rebuildRecord(\n    state.groups,\n    { ...state.groups, [input.id]: merged },\n    () => undefined,\n  )\n  return groups ? { groups } : {}\n}\n\n/**\n * Remove a group; its member layers are un-grouped (`groupId` cleared) so they\n * survive as ungrouped rows. Re-densifies both group and layer orders.\n */\nfunction removeGroupState(\n  state: LegendState,\n  id: string,\n): Partial<LegendState> {\n  if (!state.groups[id]) return {}\n  const nextGroups = { ...state.groups }\n  delete nextGroups[id]\n  const groups = rebuildRecord(state.groups, nextGroups, () => undefined)\n\n  const members = Object.values(state.layers).filter((l) => l.groupId === id)\n  if (members.length === 0) return groups ? { groups } : {}\n\n  const nextLayers = { ...state.layers }\n  for (const member of members) {\n    nextLayers[member.id] = { ...member, groupId: undefined }\n  }\n  const layers = rebuildRecord(state.layers, nextLayers, (l) => l.groupId)\n  return {\n    ...(groups ? { groups } : {}),\n    ...(layers ? { layers } : {}),\n  }\n}\n\n// ─── Store factory ────────────────────────────────────────────────────────────\n\n/**\n * @internal — used by Provider; not part of the public API.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function createLegendStore(\n  id: string,\n  init: LegendInit = {},\n): LegendStoreApi {\n  // Seed through the same merge/normalize path as `_sync`, so a later sync\n  // with identical input is a guaranteed no-op (stable identities).\n  const seeded = syncState(\n    { layers: {}, groups: {} } as LegendState,\n    init.layers ?? [],\n    init.groups ?? [],\n  )\n\n  return createStore<LegendState>()(\n    devtools(\n      (set) => ({\n        layers: seeded.layers ?? {},\n        groups: seeded.groups ?? {},\n\n        setVisibility: (lid, visible) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              const patch = layer && visibilityPatch(layer, visible)\n              return patch ? updateLayer(s, lid, patch) : {}\n            },\n            false,\n            'setVisibility',\n          ),\n        setOpacity: (lid, opacity) =>\n          set(\n            (s) => updateLayer(s, lid, { opacity: clamp01(opacity) }),\n            false,\n            'setOpacity',\n          ),\n        setCollapsed: (lid, collapsed) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              return layer\n                ? updateLayer(s, lid, collapsePatch(layer, collapsed))\n                : {}\n            },\n            false,\n            'setCollapsed',\n          ),\n        setSectionValue: (lid, sectionId, value) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              const section = layer?.sections?.find((x) => x.id === sectionId)\n              if (\n                !layer?.sections ||\n                !section ||\n                section.active === value ||\n                !section.options.includes(value)\n              ) {\n                return {}\n              }\n              const sections = layer.sections.map((x) =>\n                x.id === sectionId ? { ...x, active: value } : x,\n              )\n              return updateLayer(s, lid, { sections })\n            },\n            false,\n            'setSectionValue',\n          ),\n\n        moveLayer: (lid, toIndex) =>\n          set(\n            (s) => {\n              const layer = s.layers[lid]\n              if (!layer) return {}\n              const bucket = selectLayersByGroup(s, layer.groupId)\n              const orders = movePatch(bucket, lid, toIndex)\n              if (!orders) return {}\n              const layers = { ...s.layers }\n              for (const [id, order] of orders) {\n                layers[id] = { ...layers[id]!, order }\n              }\n              return { layers }\n            },\n            false,\n            'moveLayer',\n          ),\n\n        setGroupVisibility: (gid, visible) =>\n          set(\n            (s) => {\n              const group = s.groups[gid]\n              if (!group) return {}\n              const members = Object.values(s.layers).filter(\n                (l) => l.groupId === gid,\n              )\n              const anyVisible = members.some((l) => l.visible)\n              // Idempotence on the derived state: hide needs a visible member,\n              // show needs a fully-hidden group (mixed acts in both directions\n              // except show-from-mixed still shows the hidden remainder).\n              if (members.length === 0 || (!visible && !anyVisible)) return {}\n\n              // Cascade: each member runs the standard visibility↔collapse\n              // coupling, so per-layer collapse snapshots survive a group\n              // hide/show; members already at the target are untouched.\n              const layers = { ...s.layers }\n              let layersChanged = false\n              for (const member of members) {\n                const patch = visibilityPatch(member, visible)\n                if (patch) {\n                  layers[member.id] = { ...member, ...patch }\n                  layersChanged = true\n                }\n              }\n              if (!layersChanged) return {}\n\n              // Group-level collapse coupling, only on real derived\n              // transitions: any-visible→hidden snapshots + collapses;\n              // hidden→visible restores the snapshot.\n              let groupPatch: Partial<LegendGroup> | null = null\n              if (!visible && anyVisible) {\n                groupPatch = {\n                  collapsed: true,\n                  collapsedBeforeHide: group.collapsed,\n                }\n              } else if (visible && !anyVisible) {\n                groupPatch = {\n                  collapsed: group.collapsedBeforeHide ?? false,\n                  collapsedBeforeHide: undefined,\n                }\n              }\n              return {\n                layers,\n                ...(groupPatch\n                  ? {\n                      groups: {\n                        ...s.groups,\n                        [gid]: { ...group, ...groupPatch },\n                      },\n                    }\n                  : {}),\n              }\n            },\n            false,\n            'setGroupVisibility',\n          ),\n        setGroupCollapsed: (gid, collapsed) =>\n          set(\n            (s) => {\n              const group = s.groups[gid]\n              if (!group) return {}\n              // Group visibility is derived from members; while the group is\n              // hidden the snapshot follows the manual choice (layer parity).\n              const members = Object.values(s.layers).filter(\n                (l) => l.groupId === gid,\n              )\n              const hidden =\n                members.length > 0 && members.every((l) => !l.visible)\n              return updateGroup(\n                s,\n                gid,\n                hidden\n                  ? { collapsed, collapsedBeforeHide: collapsed }\n                  : { collapsed },\n              )\n            },\n            false,\n            'setGroupCollapsed',\n          ),\n\n        moveGroup: (gid, toIndex) =>\n          set(\n            (s) => {\n              if (!s.groups[gid]) return {}\n              const orders = movePatch(selectOrderedGroups(s), gid, toIndex)\n              if (!orders) return {}\n              const groups = { ...s.groups }\n              for (const [id, order] of orders) {\n                groups[id] = { ...groups[id]!, order }\n              }\n              return { groups }\n            },\n            false,\n            'moveGroup',\n          ),\n\n        setLegendLayer: (input) =>\n          set((s) => upsertLayerState(s, input), false, 'setLegendLayer'),\n        removeLegendLayer: (lid) =>\n          set((s) => removeLayerState(s, lid), false, 'removeLegendLayer'),\n        setLegendGroup: (input) =>\n          set((s) => upsertGroupState(s, input), false, 'setLegendGroup'),\n        removeLegendGroup: (gid) =>\n          set((s) => removeGroupState(s, gid), false, 'removeLegendGroup'),\n\n        _sync: (layerInputs, groupInputs) =>\n          set((s) => syncState(s, layerInputs, groupInputs), false, '_sync'),\n      }),\n      { name: `legend-${id}`, enabled: isDev() },\n    ),\n  )\n}\n\n// ─── Registry ───────────────────────────────────────────────────────────────\n\n/** @experimental This API is new and may change in a future release. */\nexport function getLegendStore(id: string): LegendStoreApi {\n  const store = legendStores.get(id)\n  if (!store) throw new Error(`[legend] Legend store \"${id}\" not found.`)\n  return store\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function hasLegendStore(id: string): boolean {\n  return legendStores.has(id)\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function deleteLegendStore(id: string): void {\n  legendStores.delete(id)\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function clearAllLegendStores(): void {\n  legendStores.clear()\n  legendMountCounts.clear()\n  warnedDuplicates.clear()\n}\n\n/**\n * @internal — used by Provider's lazy init so children can resolve the store first render.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function setLegendStoreEntry(id: string, store: LegendStoreApi): void {\n  legendStores.set(id, store)\n}\n\n/**\n * @internal — registers a Provider mount and warns on duplicate ids in dev.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function registerLegendStore(id: string, store: LegendStoreApi): void {\n  legendStores.set(id, store)\n  const count = (legendMountCounts.get(id) ?? 0) + 1\n  legendMountCounts.set(id, count)\n  if (count > 1 && isDev() && !warnedDuplicates.has(id)) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[legend] Duplicate <Legend.Provider id=\"${id}\"> detected. ` +\n        `Multiple providers sharing an id will race on prop sync. ` +\n        `Use unique ids per legend panel.`,\n    )\n    warnedDuplicates.add(id)\n  }\n}\n\n/**\n * @internal — Provider unmount counterpart; removes the entry on last unmount.\n *\n * @experimental This API is new and may change in a future release.\n */\nexport function unregisterLegendStore(\n  id: string,\n  options: { keepAlive: boolean },\n): void {\n  const count = (legendMountCounts.get(id) ?? 1) - 1\n  if (count <= 0) {\n    legendMountCounts.delete(id)\n    if (!options.keepAlive) legendStores.delete(id)\n  } else {\n    legendMountCounts.set(id, count)\n  }\n}\n\n// ─── Hooks ────────────────────────────────────────────────────────────────────\n\n/** @experimental This API is new and may change in a future release. */\nexport function useLegendStore<T>(\n  id: string,\n  selector: (state: LegendState) => T,\n): T {\n  const store = getLegendStore(id) as unknown as StoreApi<LegendState>\n  return useStore(store, selector)\n}\n\n/** @experimental This API is new and may change in a future release. */\nexport function useLegendShallow<T>(\n  id: string,\n  selector: (state: LegendState) => T,\n): T {\n  const store = getLegendStore(id) as unknown as StoreApi<LegendState>\n  return useStore(store, useShallow(selector))\n}\n"],"mappings":";;;;;;;AAGA,IAAaE,IAAgBF,EAA6B,IAAI;AAG9D,SAAOG,IAAA;CACL,IAAAC,IAAWH,EAAWC,CAAa;CACnC,IAAIE,KAAM,MACR,MAAUC,MACR,0LAGF;CACD,OACMD;AAAE;;;ACbX,IAAMK,KAAwCE,GAAME,MAClDF,EAAED,QAAQG,EAAEH;AAOd,SAAgBI,EAAoBC,GAAmC;CACrE,OAAOC,OAAOC,OAAOF,EAAMG,MAAM,CAAC,CAACC,KAAKV,CAAO;AACjD;AAQA,SAAgBW,EACdL,GACAM,GACe;CACf,OAAOL,OAAOC,OAAOF,EAAMO,MAAM,CAAC,CAC/BC,QAAQC,MAAMA,EAAEH,YAAYA,CAAO,CAAC,CACpCF,KAAKV,CAAO;AACjB;AAOA,SAAgBgB,EAAoBV,GAAmC;CACrE,OAAOC,OAAOC,OAAOF,EAAMO,MAAM,CAAC,CAACH,KAAKV,CAAO;AACjD;AAQA,SAAgBiB,EAAyBX,GAA6B;CACpE,IAAMG,IAASF,OAAOC,OAAOF,EAAMG,MAAM;CACzC,OAAOA,EAAOS,SAAS,KAAKT,EAAOU,OAAOC,MAAMA,EAAEC,SAAS;AAC7D;AAOA,SAAgBC,EAAgBhB,GAA6B;CAC3D,OAAOC,OAAOgB,KAAKjB,EAAMG,MAAM,CAAC,CAACS,SAAS;AAC5C;AAOA,SAAgBM,EACdlB,GACkD;CAClD,IAAMoB,KAAWd,MACfD,EAAoBL,GAAOM,CAAO,CAAC,CAACE,QAAQC,MAAMA,EAAEW,OAAO,GACvDC,IAA6D,CAAA;CACnE,KAAK,IAAMF,KAASpB,EAAoBC,CAAK,GAAG;EAC9C,IAAMO,IAASa,EAAQD,EAAMG,EAAE;EAC/B,AAAIf,EAAOK,SAAS,KAAGS,EAASE,KAAK;GAAEJ;GAAOZ;EAAO,CAAC;CACxD;CACA,IAAMiB,IAAYJ,EAAQK,KAAAA,CAAS;CAEnC,OADID,EAAUZ,SAAS,KAAGS,EAASE,KAAK,EAAEhB,QAAQiB,EAAU,CAAC,GACtDH;AACT;AAUA,SAAgBK,EACd1B,GACA2B,GACS;CACT,IAAMC,IAAQ5B,EAAMO,OAAOoB;CAE3B,OADKC,IAEHA,EAAMC,UAAUjB,SAAS,MACxBgB,EAAMP,UAAUT,UAAU,KAAK,KAGhCkB,EAAQF,EAAMG,aANG;AAQrB;AAeA,SAAgBE,EACdjC,GACAM,GACkB;CAClB,IAAI4B,IAAa,IACbC,IAAY;CAChB,KAAK,IAAMP,KAASvB,EAAoBL,GAAOM,CAAO,GACpD,AAAIsB,EAAMR,UAASc,IAAa,KAC3BC,IAAY;CAGnB,OADID,KAAcC,IAAkB,UAC7BA,IAAY,WAAW;AAChC;;;AC1GA,IAAMiB,oBAAe,IAAIC,IAA4B,GAC/CC,oBAAoB,IAAID,IAAoB,GAC5CE,oBAAmB,IAAIC,IAAY,GAEnCC,UAAuB;CAC3B,IAAI;EACF,OAAOC;CAGT,QAAQ;EACN,OAAO;CACT;AACF,GAEMK,KAAWC,MAAsBC,KAAKC,IAAI,GAAGD,KAAKE,IAAI,GAAGH,CAAC,CAAC;AAUjE,SAASI,EACPC,GAKAC,GAKO;CAEP,OADID,EAAOC,YAAYA,IAAgB,OAChCA,IAEH;EACEA;EACAC,WAAWF,EAAOG,uBAAuB;EACzCA,qBAAqBC,KAAAA;CACvB,IAEA;EACEH;EACAC,WAAW;EACXC,qBAAqBH,EAAOE;CAC9B;AACN;AAMA,SAASG,EACPL,GACAE,GACuD;CACvD,OAAOF,EAAOC,UACV,EAAEC,aAAU,IACZ;EAAEA;EAAWC,qBAAqBD;CAAU;AAClD;AAQA,SAASI,EACPG,GACAF,GACAI,GAC4B;CAC5B,IAAMC,IAAYH,EAAOI,WAAWC,MAAMA,EAAEP,OAAOA,CAAE;CACrD,IAAIK,MAAc,IAAI,OAAO;CAC7B,IAAMG,IAAUnB,KAAKE,IAAI,GAAGF,KAAKC,IAAIY,EAAOO,SAAS,GAAGL,CAAO,CAAC;CAChE,IAAII,MAAYH,GAAW,OAAO;CAClC,IAAMK,IAAO,CAAC,GAAGR,CAAM,GACjB,CAACS,KAASD,EAAKE,OAAOP,GAAW,CAAC;CACxCK,EAAKE,OAAOJ,GAAS,GAAGG,CAAM;CAC9B,IAAME,oBAAS,IAAIpC,IAAoB;CAIvC,OAHAiC,EAAKI,SAASrB,GAAQsB,MAAU;EAC9B,AAAItB,EAAOQ,UAAUc,KAAOF,EAAOG,IAAIvB,EAAOO,IAAIe,CAAK;CACzD,CAAC,GACMF,EAAOI,OAAO,IAAIJ,IAAS;AACpC;AAEA,SAASK,EACPC,GACAnB,GACAoB,GACsB;CACtB,IAAME,IAAQH,EAAMI,OAAOvB;CAE3B,OADKsB,IACE,EAAEC,QAAQ;EAAE,GAAGJ,EAAMI;GAASvB,IAAK;GAAE,GAAGsB;GAAO,GAAGF;EAAM;CAAE,EAAE,IADhD,CAAC;AAEtB;AAEA,SAASI,EACPL,GACAnB,GACAoB,GACsB;CACtB,IAAMK,IAAQN,EAAMO,OAAO1B;CAE3B,OADKyB,IACE,EAAEC,QAAQ;EAAE,GAAGP,EAAMO;GAAS1B,IAAK;GAAE,GAAGyB;GAAO,GAAGL;EAAM;CAAE,EAAE,IADhD,CAAC;AAEtB;AASA,SAASO,EACPC,GACAlB,GACmC;CACnC,IAAI,CAACA,KAAQ,CAACkB,KAAQA,MAASlB,GAAM,OAAOA;CAC5C,IAAMmB,IAASnB,EAAKoB,KAAKC,MAAY;EACnC,IAAMC,IAAcJ,EAAKK,MAAMC,MAAMA,EAAElC,OAAO+B,EAAQ/B,EAAE;EACxD,OAAOgC,KACLA,EAAYG,WAAWJ,EAAQI,UAC/BJ,EAAQK,QAAQC,SAASL,EAAYG,MAAM,IACzC;GAAE,GAAGJ;GAASI,QAAQH,EAAYG;EAAO,IACzCJ;CACN,CAAC;CAYD,OAVEH,EAAKnB,WAAWoB,EAAOpB,UACvBoB,EAAOU,OAAOC,GAAGC,MAAM;EACrB,IAAMP,IAAIN,EAAKa;EACf,OACEP,EAAElC,OAAOwC,EAAExC,MACXkC,EAAEQ,UAAUF,EAAEE,SACdR,EAAEE,YAAYI,EAAEJ,WAChBF,EAAEC,WAAWK,EAAEL;CAEnB,CAAC,IACiBP,IAAOC;AAC7B;AAQA,SAASc,EAAkBC,GAAYC,GAAqB;CAG1D,OAFI,CAACrF,EAAeoF,CAAC,KAAK,CAACpF,EAAeqF,CAAC,KACvCD,EAAEE,SAASD,EAAEC,QAAQF,EAAEG,QAAQF,EAAEE,MAAY,KAC1CC,EACLJ,EAAEK,OACFJ,EAAEI,KACJ;AACF;AAMA,SAASD,EAAqCJ,GAAMC,GAAe;CACjE,IAAMM,oBAAO,IAAIvE,IAAI,CAAC,GAAGwE,OAAOD,KAAKP,CAAC,GAAG,GAAGQ,OAAOD,KAAKN,CAAC,CAAC,CAAC;CAC3D,KAAK,IAAME,KAAOI,GACZC,YAAOC,GAAGT,EAAEG,IAAMF,EAAEE,EAAI,KACxB,CAACJ,EAAkBC,EAAEG,IAAMF,EAAEE,EAAI,GAAG,OAAO;CAEjD,OAAO;AACT;AAQA,SAASO,EACPC,GACAC,GACM;CACN,IAAMC,oBAAU,IAAIhF,IAAwD;CAC5E,KAAK,IAAMiF,KAASH,GAAS;EAC3B,IAAMR,IAAMS,EAASE,EAAM7B,MAAM,GAC3B3B,IAASuD,EAAQE,IAAIZ,CAAG;EAC9B,AAAI7C,IAAQA,EAAO0D,KAAKF,CAAK,IACxBD,EAAQzC,IAAI+B,GAAK,CAACW,CAAK,CAAC;CAC/B;CACA,KAAK,IAAMxD,KAAUuD,EAAQI,OAAO,GAClC3D,EACG4D,MAAMlB,GAAGC,MAAMD,EAAEf,OAAO5B,QAAQ4C,EAAEhB,OAAO5B,SAAS2C,EAAE7B,QAAQ8B,EAAE9B,KAAK,CAAC,CACpED,SAAS4C,GAAOjB,MAAM;EACrBiB,EAAM7B,OAAO5B,QAAQwC;CACvB,CAAC;AAEP;AAQA,SAASsB,EACPnC,GACAoC,GACAC,GACa;CACb,OAAO;EACL,GAAGD;EACHtE,SAASkC,GAAMlC,WAAWsE,EAAMtE,WAAW;EAC3CwE,SAAStC,GAAMsC,WAAWF,EAAME,WAAW;EAC3CvE,WAAWiC,GAAMjC,aAAaqE,EAAMrE,aAAa;EACjDC,qBAAqBgC,GAAMhC;EAC3BuE,UAAUxC,EAAcC,GAAMuC,UAAUH,EAAMG,QAAQ;EACtDlE,OAAO2B,GAAM3B,SAAS+D,EAAM/D,SAASgE;CACvC;AACF;AAQA,SAASG,EACPxC,GACAoC,GACAC,GACAI,GACa;CACb,OAAO;EACL,GAAGL;EACHrE,WAAWiC,GAAMjC,aAAaqE,EAAMrE,aAAa,CAAC0E;EAClDzE,qBAAqBgC,GAAMhC;EAC3BK,OAAO2B,GAAM3B,SAAS+D,EAAM/D,SAASgE;CACvC;AACF;AAaA,SAASK,EACPnD,GACAoD,GACAC,GACsB;CACtB,IAAMC,IAAeF,EAAYzC,KAAKkC,GAAOjD,OAAW;EACtDA;EACAc,QAAQkC,EAAiB5C,EAAMI,OAAOyC,EAAMhE,KAAKgE,GAAOjD,CAAK;CAC/D,EAAE;CACFuC,EAAgBmB,IAAeC,MAAMA,EAAEC,OAAO;CAE9C,IAAMC,IAAyB,IAAIhG,IACjC6F,EACGI,QAAQ,EAAEhD,gBAAaA,EAAOnC,WAAWmC,EAAO8C,WAAW,IAAI,CAAC,CAChE7C,KAAK,EAAED,gBAAaA,EAAO8C,OAAQ,CACxC,GACMG,IAAeN,EAAY1C,KAAKkC,GAAOjD,OAAW;EACtDA;EACAc,QAAQuC,EACNjD,EAAMO,OAAOsC,EAAMhE,KACnBgE,GACAjD,GACA6D,EAAuBG,IAAIf,EAAMhE,EAAE,CACrC;CACF,EAAE;CACFsD,EAAgBwB,SAAoBjF,KAAAA,CAAS;CAI7C,IAAImF,IAAgBP,EAAahE,WAAW2C,OAAOD,KAAKhC,EAAMI,MAAM,CAAC,CAACd,QAChEc,IAAsC,CAAC;CAC7C,KAAK,IAAM,EAAEM,eAAY4C,GAAc;EACrC,IAAM7C,IAAOT,EAAMI,OAAOM,EAAO7B;EACjC,AAAI4B,KAAQoB,EAAmBpB,GAAMC,CAAM,IACzCN,EAAOM,EAAO7B,MAAM4B,KAEpBL,EAAOM,EAAO7B,MAAM6B,GACpBmD,IAAgB;CAEpB;CAEA,IAAIC,IAAgBH,EAAarE,WAAW2C,OAAOD,KAAKhC,EAAMO,MAAM,CAAC,CAACjB,QAChEiB,IAAsC,CAAC;CAC7C,KAAK,IAAM,EAAEG,eAAYiD,GAAc;EACrC,IAAMlD,IAAOT,EAAMO,OAAOG,EAAO7B;EACjC,AAAI4B,KAAQoB,EAAmBpB,GAAMC,CAAM,IACzCH,EAAOG,EAAO7B,MAAM4B,KAEpBF,EAAOG,EAAO7B,MAAM6B,GACpBoD,IAAgB;CAEpB;CAGA,OADI,CAACD,KAAiB,CAACC,IAAsB,CAAC,IACvC;EACL1D,QAAQyD,IAAgBzD,IAASJ,EAAMI;EACvCG,QAAQuD,IAAgBvD,IAASP,EAAMO;CACzC;AACF;AAQA,SAASwD,EAGPtD,GACAlB,GACA8C,GAC0B;CAC1B,IAAMD,IAAUH,OAAOS,OAAOnD,CAAI,CAAC,CAACoB,KAAKvB,GAAGQ,OAAW;EACrDA;EACAc,QAAQ,EAAE,GAAGtB,EAAE;CACjB,EAAE;CACF+C,EAAgBC,GAASC,CAAQ;CACjC,IAAI2B,IAAU5B,EAAQ9C,WAAW2C,OAAOD,KAAKvB,CAAI,CAAC,CAACnB,QAC7C2E,IAAyB,CAAC;CAChC,KAAK,IAAM,EAAEvD,eAAY0B,GAAS;EAChC,IAAM8B,IAASzD,EAAKC,EAAO7B;EAC3B,AAAIqF,KAAUrC,EAAmBqC,GAAQxD,CAAM,IAC7CuD,EAAIvD,EAAO7B,MAAMqF,KAEjBD,EAAIvD,EAAO7B,MAAM6B,GACjBsD,IAAU;CAEd;CACA,OAAOA,IAAUC,IAAM;AACzB;AAGA,SAASE,EACPnE,GACA6C,GACsB;CACtB,IAAMuB,IAAenC,OAAOS,OAAO1C,EAAMI,MAAM,CAAC,CAACsD,QAC9CH,MAAMA,EAAEC,YAAYX,EAAMW,WAAWD,EAAE1E,OAAOgE,EAAMhE,EACvD,CAAC,CAACS,QACIoB,IAASkC,EAAiB5C,EAAMI,OAAOyC,EAAMhE,KAAKgE,GAAOuB,CAAY,GACrEhE,IAAS2D,EACb/D,EAAMI,QACN;EAAE,GAAGJ,EAAMI;GAASyC,EAAMhE,KAAK6B;CAAO,IACrC6C,MAAMA,EAAEC,OACX;CACA,OAAOpD,IAAS,EAAEA,UAAO,IAAI,CAAC;AAChC;AAGA,SAASiE,EACPrE,GACAnB,GACsB;CACtB,IAAI,CAACmB,EAAMI,OAAOvB,IAAK,OAAO,CAAC;CAC/B,IAAMU,IAAO,EAAE,GAAGS,EAAMI,OAAO;CAC/B,OAAOb,EAAKV;CACZ,IAAMuB,IAAS2D,EAAc/D,EAAMI,QAAQb,IAAOgE,MAAMA,EAAEC,OAAO;CACjE,OAAOpD,IAAS,EAAEA,UAAO,IAAI,CAAC;AAChC;AAGA,SAASkE,EACPtE,GACA6C,GACsB;CACtB,IAAM0B,IAAQtC,OAAOS,OAAO1C,EAAMO,MAAM,CAAC,CAACmD,QACvCc,MAAMA,EAAE3F,OAAOgE,EAAMhE,EACxB,CAAC,CAACS,QACI4D,IAAkBjB,OAAOS,OAAO1C,EAAMI,MAAM,CAAC,CAACqE,MACjDlB,MAAMA,EAAEC,YAAYX,EAAMhE,MAAM0E,EAAEhF,OACrC,GACMmC,IAASuC,EACbjD,EAAMO,OAAOsC,EAAMhE,KACnBgE,GACA0B,GACArB,CACF,GACM3C,IAASwD,EACb/D,EAAMO,QACN;EAAE,GAAGP,EAAMO;GAASsC,EAAMhE,KAAK6B;CAAO,SAChChC,KAAAA,CACR;CACA,OAAO6B,IAAS,EAAEA,UAAO,IAAI,CAAC;AAChC;AAMA,SAASmE,EACP1E,GACAnB,GACsB;CACtB,IAAI,CAACmB,EAAMO,OAAO1B,IAAK,OAAO,CAAC;CAC/B,IAAM8F,IAAa,EAAE,GAAG3E,EAAMO,OAAO;CACrC,OAAOoE,EAAW9F;CAClB,IAAM0B,IAASwD,EAAc/D,EAAMO,QAAQoE,SAAkBjG,KAAAA,CAAS,GAEhEkG,IAAU3C,OAAOS,OAAO1C,EAAMI,MAAM,CAAC,CAACsD,QAAQH,MAAMA,EAAEC,YAAY3E,CAAE;CAC1E,IAAI+F,EAAQtF,WAAW,GAAG,OAAOiB,IAAS,EAAEA,UAAO,IAAI,CAAC;CAExD,IAAMsE,IAAa,EAAE,GAAG7E,EAAMI,OAAO;CACrC,KAAK,IAAM0E,KAAUF,GACnBC,EAAWC,EAAOjG,MAAM;EAAE,GAAGiG;EAAQtB,SAAS9E,KAAAA;CAAU;CAE1D,IAAM0B,IAAS2D,EAAc/D,EAAMI,QAAQyE,IAAatB,MAAMA,EAAEC,OAAO;CACvE,OAAO;EACL,GAAIjD,IAAS,EAAEA,UAAO,IAAI,CAAC;EAC3B,GAAIH,IAAS,EAAEA,UAAO,IAAI,CAAC;CAC7B;AACF;AASA,SAAgB2E,EACdlG,GACAmG,IAAmB,CAAC,GACJ;CAGhB,IAAMC,IAAS9B,EACb;EAAE/C,QAAQ,CAAC;EAAGG,QAAQ,CAAC;CAAE,GACzByE,EAAK5E,UAAU,CAAA,GACf4E,EAAKzE,UAAU,CAAA,CACjB;CAEA,OAAO/D,EAAyB,CAAC,CAC/BC,GACGoD,OAAS;EACRO,QAAQ6E,EAAO7E,UAAU,CAAC;EAC1BG,QAAQ0E,EAAO1E,UAAU,CAAC;EAE1B2E,gBAAgBC,GAAK5G,MACnBsB,GACGuF,MAAM;GACL,IAAMjF,IAAQiF,EAAEhF,OAAO+E,IACjBlF,IAAQE,KAAS9B,EAAgB8B,GAAO5B,CAAO;GACrD,OAAO0B,IAAQF,EAAYqF,GAAGD,GAAKlF,CAAK,IAAI,CAAC;EAC/C,GACA,IACA,eACF;EACFoF,aAAaF,GAAKpC,MAChBlD,GACGuF,MAAMrF,EAAYqF,GAAGD,GAAK,EAAEpC,SAAS/E,EAAQ+E,CAAO,EAAE,CAAC,GACxD,IACA,YACF;EACFuC,eAAeH,GAAK3G,MAClBqB,GACGuF,MAAM;GACL,IAAMjF,IAAQiF,EAAEhF,OAAO+E;GACvB,OAAOhF,IACHJ,EAAYqF,GAAGD,GAAKxG,EAAcwB,GAAO3B,CAAS,CAAC,IACnD,CAAC;EACP,GACA,IACA,cACF;EACF+G,kBAAkBJ,GAAKK,GAAWC,MAChC5F,GACGuF,MAAM;GACL,IAAMjF,IAAQiF,EAAEhF,OAAO+E,IACjBvE,IAAUT,GAAO6C,UAAUlC,MAAM4E,MAAMA,EAAE7G,OAAO2G,CAAS;GAY/D,OAVE,CAACrF,GAAO6C,YACR,CAACpC,KACDA,EAAQI,WAAWyE,KACnB,CAAC7E,EAAQK,QAAQC,SAASuE,CAAK,IAExB,CAAC,IAKH1F,EAAYqF,GAAGD,GAAK,EAAEnC,UAHZ7C,EAAM6C,SAASrC,KAAK+E,MACnCA,EAAE7G,OAAO2G,IAAY;IAAE,GAAGE;IAAG1E,QAAQyE;GAAM,IAAIC,CAEpB1C,EAAS,CAAC;EACzC,GACA,IACA,iBACF;EAEF2C,YAAYR,GAAKlG,MACfY,GACGuF,MAAM;GACL,IAAMjF,IAAQiF,EAAEhF,OAAO+E;GACvB,IAAI,CAAChF,GAAO,OAAO,CAAC;GAEpB,IAAMT,IAASd,EADAzB,EAAoBiI,GAAGjF,EAAMqD,OACnBzE,GAAQoG,GAAKlG,CAAO;GAC7C,IAAI,CAACS,GAAQ,OAAO,CAAC;GACrB,IAAMU,IAAS,EAAE,GAAGgF,EAAEhF,OAAO;GAC7B,KAAK,IAAM,CAACvB,GAAIC,MAAUY,GACxBU,EAAOvB,KAAM;IAAE,GAAGuB,EAAOvB;IAAMC;GAAM;GAEvC,OAAO,EAAEsB,UAAO;EAClB,GACA,IACA,WACF;EAEFwF,qBAAqBC,GAAKtH,MACxBsB,GACGuF,MAAM;GACL,IAAM9E,IAAQ8E,EAAE7E,OAAOsF;GACvB,IAAI,CAACvF,GAAO,OAAO,CAAC;GACpB,IAAMsE,IAAU3C,OAAOS,OAAO0C,EAAEhF,MAAM,CAAC,CAACsD,QACrCH,MAAMA,EAAEC,YAAYqC,CACvB,GACMC,IAAalB,EAAQH,MAAMlB,MAAMA,EAAEhF,OAAO;GAIhD,IAAIqG,EAAQtF,WAAW,KAAM,CAACf,KAAW,CAACuH,GAAa,OAAO,CAAC;GAK/D,IAAM1F,IAAS,EAAE,GAAGgF,EAAEhF,OAAO,GACzByD,IAAgB;GACpB,KAAK,IAAMiB,KAAUF,GAAS;IAC5B,IAAM3E,IAAQ5B,EAAgByG,GAAQvG,CAAO;IAC7C,AAAI0B,MACFG,EAAO0E,EAAOjG,MAAM;KAAE,GAAGiG;KAAQ,GAAG7E;IAAM,GAC1C4D,IAAgB;GAEpB;GACA,IAAI,CAACA,GAAe,OAAO,CAAC;GAK5B,IAAIkC,IAA0C;GAY9C,OAXI,CAACxH,KAAWuH,IACdC,IAAa;IACXvH,WAAW;IACXC,qBAAqB6B,EAAM9B;GAC7B,IACSD,KAAW,CAACuH,MACrBC,IAAa;IACXvH,WAAW8B,EAAM7B,uBAAuB;IACxCA,qBAAqBC,KAAAA;GACvB,IAEK;IACL0B;IACA,GAAI2F,IACA,EACExF,QAAQ;KACN,GAAG6E,EAAE7E;MACJsF,IAAM;MAAE,GAAGvF;MAAO,GAAGyF;KAAW;IACnC,EACF,IACA,CAAC;GACP;EACF,GACA,IACA,oBACF;EACFC,oBAAoBH,GAAKrH,MACvBqB,GACGuF,MAAM;GAEL,IAAI,CADUA,EAAE7E,OAAOsF,IACX,OAAO,CAAC;GAGpB,IAAMjB,IAAU3C,OAAOS,OAAO0C,EAAEhF,MAAM,CAAC,CAACsD,QACrCH,MAAMA,EAAEC,YAAYqC,CACvB;GAGA,OAAOxF,EACL+E,GACAS,GAHAjB,EAAQtF,SAAS,KAAKsF,EAAQxD,OAAOmC,MAAM,CAACA,EAAEhF,OAAO,IAKjD;IAAEC;IAAWC,qBAAqBD;GAAU,IAC5C,EAAEA,aAAU,CAClB;EACF,GACA,IACA,mBACF;EAEF0H,YAAYL,GAAK5G,MACfY,GACGuF,MAAM;GACL,IAAI,CAACA,EAAE7E,OAAOsF,IAAM,OAAO,CAAC;GAC5B,IAAMnG,IAASd,EAAUxB,EAAoBgI,CAAC,GAAGS,GAAK5G,CAAO;GAC7D,IAAI,CAACS,GAAQ,OAAO,CAAC;GACrB,IAAMa,IAAS,EAAE,GAAG6E,EAAE7E,OAAO;GAC7B,KAAK,IAAM,CAAC1B,GAAIC,MAAUY,GACxBa,EAAO1B,KAAM;IAAE,GAAG0B,EAAO1B;IAAMC;GAAM;GAEvC,OAAO,EAAEyB,UAAO;EAClB,GACA,IACA,WACF;EAEF4F,iBAAiBtD,MACfhD,GAAKuF,MAAMjB,EAAiBiB,GAAGvC,CAAK,GAAG,IAAO,gBAAgB;EAChEuD,oBAAoBjB,MAClBtF,GAAKuF,MAAMf,EAAiBe,GAAGD,CAAG,GAAG,IAAO,mBAAmB;EACjEkB,iBAAiBxD,MACfhD,GAAKuF,MAAMd,EAAiBc,GAAGvC,CAAK,GAAG,IAAO,gBAAgB;EAChEyD,oBAAoBT,MAClBhG,GAAKuF,MAAMV,EAAiBU,GAAGS,CAAG,GAAG,IAAO,mBAAmB;EAEjEU,QAAQnD,GAAaC,MACnBxD,GAAKuF,MAAMjC,EAAUiC,GAAGhC,GAAaC,CAAW,GAAG,IAAO,OAAO;CACrE,IACA;EAAEmD,MAAM,UAAU3H;EAAM4H,SAAS/I,EAAM;CAAE,CAC3C,CACF;AACF;AAKA,SAAgBgJ,EAAe7H,GAA4B;CACzD,IAAM8H,IAAQtJ,EAAamF,IAAI3D,CAAE;CACjC,IAAI,CAAC8H,GAAO,MAAUC,MAAM,0BAA0B/H,EAAE,aAAc;CACtE,OAAO8H;AACT;AAGA,SAAgBE,EAAehI,GAAqB;CAClD,OAAOxB,EAAauG,IAAI/E,CAAE;AAC5B;AAGA,SAAgBiI,EAAkBjI,GAAkB;CAClDxB,EAAa0J,OAAOlI,CAAE;AACxB;AAGA,SAAgBmI,IAA6B;CAG3CxJ,AAFAH,EAAa4J,MAAM,GACnB1J,EAAkB0J,MAAM,GACxBzJ,EAAiByJ,MAAM;AACzB;AAOA,SAAgBC,EAAoBrI,GAAY8H,GAA6B;CAC3EtJ,EAAawC,IAAIhB,GAAI8H,CAAK;AAC5B;AAOA,SAAgBQ,EAAoBtI,GAAY8H,GAA6B;CAC3EtJ,EAAawC,IAAIhB,GAAI8H,CAAK;CAC1B,IAAMpC,KAAShH,EAAkBiF,IAAI3D,CAAE,KAAK,KAAK;CAEjD,AADAtB,EAAkBsC,IAAIhB,GAAI0F,CAAK,GAC3BA,IAAQ,KAAK7G,EAAM,KAAK,CAACF,EAAiBoG,IAAI/E,CAAE,MAElDuI,QAAQC,KACN,2CAA2CxI,EAAE,uGAG/C,GACArB,EAAiB8J,IAAIzI,CAAE;AAE3B;AAOA,SAAgB0I,EACd1I,GACAoC,GACM;CACN,IAAMsD,KAAShH,EAAkBiF,IAAI3D,CAAE,KAAK,KAAK;CACjD,AAAI0F,KAAS,KACXhH,EAAkBwJ,OAAOlI,CAAE,GACtBoC,EAAQuG,aAAWnK,EAAa0J,OAAOlI,CAAE,KAE9CtB,EAAkBsC,IAAIhB,GAAI0F,CAAK;AAEnC;AAKA,SAAOkD,EAAA5I,GAAA6I,GAAA;CAAA,IAAAC,IAAAC,EAAA,CAAA,GAAAC;CAI+D,OAJ/DF,EAAA,OAAA9I,IAI2BgJ,IAAAF,EAAA,MAAlBE,IAAAnB,EAAe7H,CAAE,GAAC8I,EAAA,KAAA9I,GAAA8I,EAAA,KAAAE,IACzBvL,EAASqK,GAAOe,CAAQ;AAAC;AAIlC,SAAOI,EAAAjJ,GAAA6I,GAAA;CAAA,IAAAC,IAAAC,EAAA,CAAA,GAAAC;CAI+D,OAJ/DF,EAAA,OAAA9I,IAI2BgJ,IAAAF,EAAA,MAAlBE,IAAAnB,EAAe7H,CAAE,GAAC8I,EAAA,KAAA9I,GAAA8I,EAAA,KAAAE,IACzBvL,EAASqK,GAAOjK,EAAWgL,CAAQ,CAAC;AAAC"}