@deepseek-ai/dsh-client-ui-sidebar-right 0.1.5-alpha.1

package/lib/client.js

@@ -0,0 +1,3614 @@
+window.__ModuleLoader__.load({
+	id: "@deepseek-ai/dsh-client-ui-sidebar-right",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		//#region \0rolldown/runtime.js
+		var __create = Object.create;
+		var __defProp = Object.defineProperty;
+		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+		var __getOwnPropNames = Object.getOwnPropertyNames;
+		var __getProtoOf = Object.getPrototypeOf;
+		var __hasOwnProp = Object.prototype.hasOwnProperty;
+		var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+		var __copyProps = (to, from, except, desc) => {
+			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+				key = keys[i];
+				if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+			return to;
+		};
+		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+			value: mod,
+			enumerable: true
+		}) : target, mod));
+		//#endregion
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+		let react = require("react");
+		let react_dom = require("react-dom");
+		let _deepseek_ai_dsh_client_ui_dockkit = require("@deepseek-ai/dsh-client-ui-dockkit");
+		let _deepseek_ai_dsh_client_store = require("@deepseek-ai/dsh-client-store");
+		//#region \0dsh-css:/home/runner/work/deepseek-harness/deepseek-harness/packages/client/ui-sidebar-right/src/client/tabs/guide/GuideBody.module.css.mjs
+		const css$2 = ".geFEbW_guide{text-align:center;flex-direction:column;align-items:center;gap:8px;padding-top:24px;display:flex}.geFEbW_guideTitle{color:var(--dsw-alias-label-primary);font-size:var(--dsh-content-font-size,14px);margin:0;font-weight:500;line-height:1.6}.geFEbW_guideBody{color:var(--dsw-alias-label-secondary);font-size:var(--dsh-content-font-size-secondary,13px);margin:0;line-height:1.6}.geFEbW_entries{grid-template-columns:repeat(auto-fill,minmax(160px,1fr));gap:8px;width:100%;max-width:480px;margin-top:16px;display:grid}.geFEbW_entry{color:inherit;font:inherit;text-align:left;border:.5px solid var(--dsw-alias-border-l1);cursor:pointer;background:0 0;border-radius:8px;align-items:flex-start;gap:8px;padding:10px 12px;display:flex}.geFEbW_entry:hover{background:var(--dsw-alias-interactive-bg-hover)}.geFEbW_entryIcon{color:var(--dsw-alias-label-secondary);flex:none;margin-top:1px;display:flex}.geFEbW_entryText{flex-direction:column;gap:2px;min-width:0;display:flex}.geFEbW_entryTitle{color:var(--dsw-alias-label-primary);font-size:var(--dsh-content-font-size,14px);line-height:1.4}.geFEbW_entryDescription{color:var(--dsw-alias-label-secondary);font-size:var(--dsh-content-font-size-secondary,13px);line-height:1.4}";
+		const tagId$2 = "@deepseek-ai/dsh-client-ui-sidebar-right/GuideBody.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$2) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@deepseek-ai/dsh-client-ui-sidebar-right";
+			tag.dataset.pluginCss = tagId$2;
+			tag.textContent = css$2;
+			document.head.appendChild(tag);
+		}
+		var GuideBody_module_css_default = {
+			"entries": "geFEbW_entries",
+			"entry": "geFEbW_entry",
+			"entryDescription": "geFEbW_entryDescription",
+			"entryIcon": "geFEbW_entryIcon",
+			"entryText": "geFEbW_entryText",
+			"entryTitle": "geFEbW_entryTitle",
+			"guide": "geFEbW_guide",
+			"guideBody": "geFEbW_guideBody",
+			"guideTitle": "geFEbW_guideTitle"
+		};
+		//#endregion
+		//#region lib/types/client/tabs/guide/GuideBody.js
+		/** One entry box: the contributing type's glyph, heading, and line. */
+		function EntryBox({ entry, onPick }) {
+			const Icon = entry.icon;
+			return (0, react_jsx_runtime.jsxs)("button", {
+				type: "button",
+				className: GuideBody_module_css_default.entry,
+				"data-sidebar-right-guide-entry": entry.kind,
+				onClick: () => {
+					onPick(entry);
+				},
+				children: [Icon !== void 0 && (0, react_jsx_runtime.jsx)("span", {
+					className: GuideBody_module_css_default.entryIcon,
+					children: (0, react_jsx_runtime.jsx)(Icon, { size: 16 })
+				}), (0, react_jsx_runtime.jsxs)("span", {
+					className: GuideBody_module_css_default.entryText,
+					children: [(0, react_jsx_runtime.jsx)("span", {
+						className: GuideBody_module_css_default.entryTitle,
+						children: entry.title()
+					}), (0, react_jsx_runtime.jsx)("span", {
+						className: GuideBody_module_css_default.entryDescription,
+						children: entry.description()
+					})]
+				})]
+			});
+		}
+		/** The shipped guide: what the column is for, and the doors out of it. */
+		function ShippedGuide({ entries, onPick, t }) {
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: GuideBody_module_css_default.guide,
+				"data-sidebar-right-guide": true,
+				children: [
+					(0, react_jsx_runtime.jsx)("p", {
+						className: GuideBody_module_css_default.guideTitle,
+						children: t("guide.lead")
+					}),
+					(0, react_jsx_runtime.jsx)("p", {
+						className: GuideBody_module_css_default.guideBody,
+						children: t("guide.body")
+					}),
+					entries.length > 0 && (0, react_jsx_runtime.jsx)("div", {
+						className: GuideBody_module_css_default.entries,
+						children: entries.map((entry, index) => (0, react_jsx_runtime.jsx)(EntryBox, {
+							entry,
+							onPick
+						}, `${entry.kind}:${index}`))
+					})
+				]
+			});
+		}
+		/** The guide tab's body, replaceable through its chain child. */
+		function GuideBody({ useTabInfo, useGuideEntries, renderSlotChain, t }) {
+			const { tab } = useTabInfo();
+			return renderSlotChain("sidebar.right.tab.guide", {}, {
+				hookContext: useTabInfo,
+				fallback: (0, react_jsx_runtime.jsx)(ShippedGuide, {
+					entries: useGuideEntries((entries) => entries),
+					onPick: (entry) => {
+						tab.actions.openTab(entry.kind, { replaceTab: true });
+					},
+					t
+				})
+			});
+		}
+		//#endregion
+		//#region \0dsh-css:/home/runner/work/deepseek-harness/deepseek-harness/packages/client/ui-sidebar-right/src/client/shell/ExpandButton.module.css.mjs
+		const css$1 = "._1kL45W_placeholder{flex:none;width:32px;height:32px;display:inline-block}._1kL45W_button{width:32px;height:32px;color:var(--dsw-alias-label-secondary);cursor:pointer;background:0 0;border:none;border-radius:8px;flex:none;justify-content:center;align-items:center;padding:0;display:inline-flex}._1kL45W_button:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-hover)}._1kL45W_icon{transform:scaleX(-1)}";
+		const tagId$1 = "@deepseek-ai/dsh-client-ui-sidebar-right/ExpandButton.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$1) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@deepseek-ai/dsh-client-ui-sidebar-right";
+			tag.dataset.pluginCss = tagId$1;
+			tag.textContent = css$1;
+			document.head.appendChild(tag);
+		}
+		var ExpandButton_module_css_default = {
+			"button": "_1kL45W_button",
+			"icon": "_1kL45W_icon",
+			"placeholder": "_1kL45W_placeholder"
+		};
+		//#endregion
+		//#region lib/types/client/shell/ExpandButton.js
+		/** The expand control while the panel is collapsed; its footprint while it is shown. */
+		function ExpandButton({ sessionId, useStore, actions, t }) {
+			if (useStore((state) => state.bySession[sessionId]?.layout.expanded ?? false)) return (0, react_jsx_runtime.jsx)("span", {
+				className: ExpandButton_module_css_default.placeholder,
+				"aria-hidden": true,
+				"data-sidebar-right-expand-placeholder": true
+			});
+			return (0, react_jsx_runtime.jsx)("button", {
+				type: "button",
+				className: ExpandButton_module_css_default.button,
+				"aria-label": t("chrome.expand"),
+				title: t("chrome.expand"),
+				"data-sidebar-right-expand": true,
+				onClick: () => {
+					actions.setExpanded(sessionId, true);
+				},
+				children: (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconPanelLeftOutline16, { className: ExpandButton_module_css_default.icon })
+			});
+		}
+		//#endregion
+		//#region lib/types/client/contract/seed.js
+		/** The guide tab's kind. */
+		const GUIDE_KIND = "guide";
+		/**
+		* The address a page tab is recorded under: `sidebar://<kind>`. The scheme is
+		* this package's bookkeeping for `openTab`, spelled here and nowhere else; a
+		* caller names the kind and never sees or composes the address.
+		* @param kind - the page type's kind.
+		* @returns the page's address.
+		*/
+		function pageAddress(kind) {
+			return `sidebar://${kind}`;
+		}
+		/**
+		* Build the guide tab a new pane is seeded with.
+		*
+		* The title is captured at mint time because it goes into the surface's
+		* operation sequence, which records what happened and must not change meaning
+		* later. A language change relabels the type, not tabs already open.
+		* @param id - tab id minted by the caller.
+		* @param title - the guide type's display name at mint time.
+		* @returns the guide tab record.
+		*/
+		function makeGuideTab(id, title) {
+			return {
+				id,
+				kind: GUIDE_KIND,
+				contentId: pageAddress(GUIDE_KIND),
+				title
+			};
+		}
+		//#endregion
+		//#region lib/types/client/labels.js
+		/**
+		* Project the dictionary into the kit's label contract.
+		*
+		* Called during render, so a language change reaches the kit with the next one —
+		* the kit caches no copy to invalidate.
+		* @param t - namespace-bound translate.
+		* @returns every string the kit renders.
+		*/
+		function dockLabels(t) {
+			return {
+				emptyPane: t("dock.emptyPane"),
+				splitPane: t("dock.splitPane"),
+				splitPaneDisabled: t("dock.splitPaneDisabled"),
+				splitPaneNarrow: t("dock.splitPaneNarrow"),
+				closeTab: t("dock.closeTab"),
+				addTab: t("dock.addTab"),
+				dockFloat: t("dock.dockFloat"),
+				closeFloat: t("dock.closeFloat")
+			};
+		}
+		//#endregion
+		//#region \0dsh-css:/home/runner/work/deepseek-harness/deepseek-harness/packages/client/ui-sidebar-right/src/client/shell/SidebarRight.module.css.mjs
+		const css = ".P3OORG_panel{z-index:10;background:var(--dsw-alias-bg-base);border-left:.5px solid var(--dsw-alias-border-l1);visibility:hidden;min-width:0;transition:transform var(--ds-transition-duration-slow) var(--ds-ease-in-out), visibility 0s linear var(--ds-transition-duration-slow);flex-direction:column;display:flex;position:absolute;top:0;bottom:0;right:0;transform:translate(100%)}.P3OORG_panel[data-sidebar-right-open]{visibility:visible;transition:transform var(--ds-transition-duration-slow) var(--ds-ease-in-out);transform:none}.P3OORG_panel[data-sidebar-right-panel=fullscreen]{z-index:40;border:none;position:fixed;inset:0}@media (prefers-reduced-motion:reduce){.P3OORG_panel,.P3OORG_panel[data-sidebar-right-open]{transition:none}}.P3OORG_iconButton{width:24px;height:24px;color:var(--dsw-alias-label-secondary);cursor:pointer;background:0 0;border:none;border-radius:4px;flex:none;justify-content:center;align-items:center;padding:0;font-size:14px;line-height:1;display:flex}.P3OORG_iconButton:hover{color:var(--dsw-alias-label-primary);background:var(--dsw-alias-interactive-bg-hover)}.P3OORG_panelBody{flex:auto;min-height:0;display:flex}.P3OORG_unavailable{color:var(--dsw-alias-label-tertiary);font-size:var(--dsh-content-font-size-secondary,13px);margin:0}.P3OORG_floatHost{z-index:60;pointer-events:none;position:fixed;inset:0}";
+		const tagId = "@deepseek-ai/dsh-client-ui-sidebar-right/SidebarRight.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@deepseek-ai/dsh-client-ui-sidebar-right";
+			tag.dataset.pluginCss = tagId;
+			tag.textContent = css;
+			document.head.appendChild(tag);
+		}
+		var SidebarRight_module_css_default = {
+			"floatHost": "P3OORG_floatHost",
+			"iconButton": "P3OORG_iconButton",
+			"panel": "P3OORG_panel",
+			"panelBody": "P3OORG_panelBody",
+			"unavailable": "P3OORG_unavailable"
+		};
+		//#endregion
+		//#region lib/types/client/shell/SidebarRight.js
+		/**
+		* The Sidebar's seat in the frame, and the panel it draws.
+		*
+		* The frame owns the right column's geometry; this package owns one content
+		* tree at the column width or fixed across the viewport. A shown wide panel
+		* retains its track in fullscreen, preserving the conversation width. Below
+		* 768px fullscreen is derived from viewport width, without changing manual mode.
+		*
+		* The panel stays mounted while collapsed, translated off the frame's right
+		* edge, so opening and closing are one gesture in both presentations: a slide
+		* from and to that edge. Normal presentation moves the frame's tracks with
+		* the panel. A fullscreen opening reserves its underlying track only after
+		* the panel covers the frame, without animating those hidden columns.
+		*
+		* The panel has no header of its own: its two controls — presentation switch
+		* and collapse — ride the docking kit's chrome seat at the end of the top-right
+		* pane's tab strip, so the strip is the panel's whole top edge. The way back in
+		* while collapsed is not here either: it is one button in the conversation
+		* header (`ExpandButton.tsx`), because it exists only while this panel is
+		* hidden. Floating panels portal out because they must cross the column and the
+		* conversation, and the kit already positions them in viewport coordinates.
+		*
+		* Tab bodies do not live here. Each one is a registration under its type's kind,
+		* dispatched through the keyed `sidebar.right.pane.tab` seat (and a live chip
+		* title through `sidebar.right.pane.tab.title`), so a new tab type needs no edit
+		* to this file. What a body receives beyond the record — navigation, lifetime
+		* signal, actions — is read through the slot-owned useTabInfo hook. The Tab
+		* domain follows each session's store commits, including sessions off screen.
+		*/
+		/** The guide tab one pane holds, if any: a pane holds at most one. */
+		function guideIn(layout, paneId) {
+			return (0, _deepseek_ai_dsh_client_ui_dockkit.findPaneContentTab)(layout, paneId, pageAddress(GUIDE_KIND), GUIDE_KIND);
+		}
+		/**
+		* Build the kit's intent face for one session out of the store's actions.
+		* @param sessionId - the session the seat draws; every action is bound to it.
+		* @param actions - the seat's bound store actions.
+		* @param openTab - the navigation face's `openTab`, which the strip's add control asks for a guide through.
+		* @returns the intents the kit reports gestures to.
+		*/
+		function intentsFor(sessionId, actions, openTab) {
+			return {
+				focusTab: (tabId) => {
+					actions.focusTab(sessionId, tabId);
+				},
+				focusPane: (paneId) => {
+					actions.focusPane(sessionId, paneId);
+				},
+				splitPane: (paneId) => {
+					actions.splitPane(sessionId, paneId);
+				},
+				addTab: (paneId) => {
+					openTab(GUIDE_KIND, {
+						paneId,
+						revealIfOpened: false
+					});
+				},
+				closeTab: (tabId) => {
+					actions.closeTab(sessionId, tabId);
+				},
+				duplicateTab: (tabId) => {
+					actions.duplicateTab(sessionId, tabId);
+				},
+				floatTab: (tabId, rect) => {
+					actions.floatTab(sessionId, tabId, rect);
+				},
+				unfloatPane: (paneId) => {
+					actions.unfloatPane(sessionId, paneId);
+				},
+				placeTab: (tabId, toPaneId, index) => {
+					actions.placeTab(sessionId, tabId, toPaneId, index);
+				},
+				dropTab: (tabId, paneId, zone) => {
+					actions.dropTab(sessionId, tabId, paneId, zone);
+				},
+				moveFloat: (paneId, x, y) => {
+					actions.moveFloat(sessionId, paneId, x, y);
+				},
+				resizeFloat: (paneId, rect) => {
+					actions.resizeFloat(sessionId, paneId, rect);
+				},
+				resizeSplit: (splitId, sizes) => {
+					actions.resizeSplit(sessionId, splitId, sizes);
+				}
+			};
+		}
+		/**
+		* Dispatch one tab's body or title with stable framework hooks and record lifetime.
+		*/
+		function TabSlot({ renderSlot, occurrence, useTabTypes, useTabNavigation, useStore, fullscreen, tab, seat, fallback }) {
+			const { signal, tabActions } = occurrence(tab);
+			const definition = useTabTypes((types) => types.find((definition) => definition.kind === tab.kind));
+			const hookContext = (0, react.useMemo)(() => ({
+				tabId: tab.id,
+				title: seat === "sidebar.right.pane.tab.title",
+				fullscreen,
+				signal,
+				actions: tabActions,
+				useStore,
+				useTabNavigation
+			}), [
+				tab.id,
+				seat,
+				fullscreen,
+				signal,
+				tabActions,
+				useStore,
+				useTabNavigation
+			]);
+			return renderSlot(seat, {}, {
+				entryKey: definition?.id ?? tab.kind,
+				fallback,
+				hookContext
+			});
+		}
+		/**
+		* Dispatch a tab's body to its registered type.
+		*
+		* A kind with no registrant is a real state, not a defect: a session log can
+		* carry a tab whose type shipped in a plugin that is no longer mounted. Saying so
+		* is better than an empty pane.
+		*/
+		function bodiesFor(panel) {
+			const { t, ...rest } = panel;
+			return (tab) => (0, react_jsx_runtime.jsx)(TabSlot, {
+				...rest,
+				tab,
+				seat: "sidebar.right.pane.tab",
+				fallback: (0, react_jsx_runtime.jsx)("p", {
+					className: SidebarRight_module_css_default.unavailable,
+					"data-sidebar-right-unavailable": true,
+					children: t("tab.unavailable")
+				})
+			}, tab.id);
+		}
+		/** Dispatch a tab's title to its registered type; without one the chip shows the title captured at open time. */
+		function titlesFor(panel) {
+			return (tab) => (0, react_jsx_runtime.jsx)(TabSlot, {
+				...panel,
+				tab,
+				seat: "sidebar.right.pane.tab.title",
+				fallback: tab.title
+			}, tab.id);
+		}
+		/** Expand-to-viewport glyph. */
+		function FullscreenGlyph() {
+			return (0, react_jsx_runtime.jsx)("svg", {
+				width: "14",
+				height: "14",
+				viewBox: "0 0 14 14",
+				fill: "none",
+				"aria-hidden": "true",
+				children: (0, react_jsx_runtime.jsx)("path", {
+					d: "M5 1.5H1.5V5M9 1.5h3.5V5M1.5 9v3.5H5M12.5 9v3.5H9",
+					stroke: "currentColor",
+					strokeLinecap: "round"
+				})
+			});
+		}
+		/** Restore-from-fullscreen glyph. */
+		function ExitFullscreenGlyph() {
+			return (0, react_jsx_runtime.jsx)("svg", {
+				width: "14",
+				height: "14",
+				viewBox: "0 0 14 14",
+				fill: "none",
+				"aria-hidden": "true",
+				children: (0, react_jsx_runtime.jsx)("path", {
+					d: "M1.5 5H5V1.5M9 1.5V5h3.5M1.5 9H5v3.5M9 12.5V9h3.5",
+					stroke: "currentColor",
+					strokeLinecap: "round"
+				})
+			});
+		}
+		/** The collapse glyph. */
+		function CloseGlyph() {
+			return (0, react_jsx_runtime.jsx)("svg", {
+				width: "12",
+				height: "12",
+				viewBox: "0 0 12 12",
+				fill: "none",
+				"aria-hidden": "true",
+				children: (0, react_jsx_runtime.jsx)("path", {
+					d: "M2 2l8 8M10 2l-8 8",
+					stroke: "currentColor",
+					strokeWidth: "1.3",
+					strokeLinecap: "round"
+				})
+			});
+		}
+		/** The panel's two controls, placed by the kit at the top-right pane's strip end. */
+		function PanelChrome({ sessionId, fullscreen, autoFullscreen, actions, t }) {
+			const next = fullscreen ? "push" : "fullscreen";
+			return (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)("button", {
+				type: "button",
+				className: SidebarRight_module_css_default.iconButton,
+				"aria-label": fullscreen ? t("chrome.exitFullscreen") : t("chrome.toFullscreen"),
+				title: fullscreen ? t("chrome.exitFullscreen") : t("chrome.toFullscreen"),
+				"data-sidebar-right-mode": next,
+				onClick: () => {
+					if (fullscreen && autoFullscreen) actions.setExpanded(sessionId, false);
+					actions.setMode(sessionId, next);
+				},
+				children: fullscreen ? (0, react_jsx_runtime.jsx)(ExitFullscreenGlyph, {}) : (0, react_jsx_runtime.jsx)(FullscreenGlyph, {})
+			}), (0, react_jsx_runtime.jsx)("button", {
+				type: "button",
+				className: SidebarRight_module_css_default.iconButton,
+				"aria-label": t("chrome.collapse"),
+				title: t("chrome.collapse"),
+				"data-sidebar-right-toggle": true,
+				onClick: () => {
+					actions.toggleExpanded(sessionId);
+				},
+				children: (0, react_jsx_runtime.jsx)(CloseGlyph, {})
+			})] });
+		}
+		/**
+		* The panel: the docked surface with the two controls in its top-right strip,
+		* anchored to the frame's right edge and slid off it while collapsed.
+		*/
+		function SidebarPanel(panel) {
+			const { sessionId, surface, actions, t, renderSlot, openTab, width, reportRoom, fullscreen, autoFullscreen, panelRef } = panel;
+			const { expanded } = surface.layout;
+			return (0, react_jsx_runtime.jsx)("div", {
+				ref: panelRef,
+				className: SidebarRight_module_css_default.panel,
+				style: { width: fullscreen ? "100%" : width },
+				"data-sidebar-right-panel": fullscreen ? "fullscreen" : "push",
+				"data-sidebar-right-open": expanded || void 0,
+				"aria-hidden": !expanded || void 0,
+				children: (0, react_jsx_runtime.jsx)("div", {
+					className: SidebarRight_module_css_default.panelBody,
+					children: (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_dockkit.DockSurface, {
+						state: surface.layout,
+						canSplit: (0, _deepseek_ai_dsh_client_ui_dockkit.canSplit)(surface.layout) && (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(surface.layout).length < 2,
+						hideSplitAtCapacity: true,
+						dropZones: "horizontal",
+						minPaneFraction: .2,
+						canAddTab: (paneId) => guideIn(surface.layout, paneId) === void 0,
+						intents: intentsFor(sessionId, actions, openTab),
+						labels: dockLabels(t),
+						renderTab: bodiesFor(panel),
+						renderTabTitle: titlesFor(panel),
+						renderTabMenuItems: (tab, dismiss) => renderSlot("sidebar.right.tab.menu.item", {
+							tab,
+							dismiss
+						}),
+						chrome: (0, react_jsx_runtime.jsx)(PanelChrome, {
+							sessionId,
+							fullscreen,
+							autoFullscreen,
+							actions,
+							t
+						}),
+						onRoom: reportRoom
+					})
+				})
+			});
+		}
+		/** Portal the floating layer out of whichever seat rendered it. */
+		function Floats(panel) {
+			const { sessionId, surface, actions, t, openTab } = panel;
+			if (surface.layout.floats.length === 0) return null;
+			return (0, react_dom.createPortal)((0, react_jsx_runtime.jsx)("div", {
+				className: SidebarRight_module_css_default.floatHost,
+				"data-sidebar-right-float-host": true,
+				children: (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_dockkit.FloatLayer, {
+					state: surface.layout,
+					intents: intentsFor(sessionId, actions, openTab),
+					labels: dockLabels(t),
+					renderTab: bodiesFor(panel),
+					renderTabTitle: titlesFor(panel)
+				})
+			}), document.body);
+		}
+		/**
+		* The right column's occupant: the panel, anchored to the column's edge and
+		* shown or hidden by sliding, plus the floating layer. It is also where the
+		* frame learns the panel's presentation, and where `ctx.sidebarRight` learns
+		* which session it is acting on, because this is the seat that knows both.
+		*/
+		function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, useTabTypes, useTabNavigation, occurrence }) {
+			const surfaces = useStore((state) => state.bySession);
+			const surface = surfaces[sessionId];
+			const shown = surface !== void 0 && surface.layout.expanded;
+			const autoFullscreen = viewportWidth < 768;
+			const fullscreen = autoFullscreen || surface?.layout.mode === "fullscreen";
+			const panelRef = (0, react.useRef)(null);
+			const room = (0, react.useRef)(/* @__PURE__ */ new Map());
+			const reportRoom = (0, react.useCallback)((fits) => {
+				room.current = fits;
+			}, []);
+			const track = shown && !autoFullscreen;
+			(0, react.useEffect)(() => {
+				if (surface === void 0) actions.open(sessionId);
+			}, [
+				actions,
+				sessionId,
+				surface
+			]);
+			(0, react.useLayoutEffect)(() => {
+				if (shown && !fullscreen && !canShow) actions.setExpanded(sessionId, false);
+			}, [
+				actions,
+				sessionId,
+				shown,
+				fullscreen,
+				canShow
+			]);
+			(0, react.useLayoutEffect)(() => {
+				let disposed = false;
+				const reportWhenCovered = () => {
+					if (disposed) return;
+					const entering = shown && fullscreen ? panelRef.current.getAnimations().filter((animation) => "transitionProperty" in animation && animation.transitionProperty === "transform" && animation.playState !== "finished" && animation.playState !== "idle") : [];
+					if (entering.length === 0) {
+						syncPresentation({
+							shown,
+							track,
+							fullscreen
+						});
+						return;
+					}
+					Promise.allSettled(entering.map((animation) => animation.finished)).then(reportWhenCovered);
+				};
+				reportWhenCovered();
+				return () => {
+					disposed = true;
+				};
+			}, [
+				sessionId,
+				shown,
+				track,
+				fullscreen,
+				syncPresentation
+			]);
+			(0, react.useLayoutEffect)(() => () => {
+				syncPresentation({
+					shown: false,
+					track: false,
+					fullscreen: false
+				});
+			}, [syncPresentation]);
+			(0, react.useEffect)(() => bindService({
+				sessionId,
+				actions,
+				surfaces,
+				canSplitPane: (paneId) => room.current.get(paneId)?.row !== false
+			}), [
+				bindService,
+				sessionId,
+				actions,
+				surfaces
+			]);
+			if (surface === void 0) return null;
+			const panel = {
+				sessionId,
+				actions,
+				t,
+				renderSlot,
+				surface,
+				openTab,
+				useTabTypes,
+				useTabNavigation,
+				useStore,
+				occurrence,
+				fullscreen,
+				autoFullscreen,
+				reportRoom
+			};
+			return (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)(SidebarPanel, {
+				...panel,
+				width,
+				panelRef
+			}), (0, react_jsx_runtime.jsx)(Floats, { ...panel })] });
+		}
+		//#endregion
+		//#region lib/types/client/tab-domain.js
+		/** Every session's occurrences. */
+		var TabDomain = class {
+			navigator;
+			pin;
+			bySession = /* @__PURE__ */ new Map();
+			/**
+			* @param navigator - where tab actions go, aimed at the tab's session; the navigation controller.
+			* @param pin - `ctx.resources.pin`, called once per occurrence at its first sync.
+			*/
+			constructor(navigator, pin) {
+				this.navigator = navigator;
+				this.pin = pin;
+			}
+			/**
+			* Reconcile one session's occurrences with its committed layout.
+			*
+			* Called by the seat after every commit, and only then: aborting a vanished
+			* record runs the types' cleanup, which writes their stores.
+			* @param sessionId - the session whose layout committed.
+			* @param layout - that session's layout as committed.
+			*/
+			sync(sessionId, layout) {
+				const held = this.session(sessionId);
+				for (const [tabId, occurrence] of held) {
+					if (layout.tabs[tabId] !== void 0) continue;
+					held.delete(tabId);
+					occurrence.controller.abort();
+				}
+				for (const tab of Object.values(layout.tabs)) {
+					const occurrence = held.get(tab.id) ?? this.hold(sessionId, tab.id, {
+						address: tab.contentId,
+						params: void 0,
+						revision: 0
+					});
+					const pane = (0, _deepseek_ai_dsh_client_ui_dockkit.findTabPane)(layout, tab.id);
+					occurrence.paneId = pane.host === "dock" ? pane.id : void 0;
+					if (occurrence.pinned) continue;
+					occurrence.pinned = true;
+					this.pin(occurrence.navigation.getSnapshot().address, occurrence.signal);
+				}
+			}
+			/**
+			* Read an occurrence created by navigation or committed-store reconciliation.
+			* @param sessionId - the session the record is in.
+			* @param tab - the record being drawn.
+			* @returns its occurrence.
+			* @throws when the record has not been reconciled or has disappeared.
+			*/
+			occurrence(sessionId, tab) {
+				const occurrence = this.bySession.get(sessionId)?.get(tab.id);
+				if (occurrence === void 0) throw new Error(`sidebarRight: tab "${tab.id}" has no committed occurrence in session "${sessionId}"`);
+				return occurrence;
+			}
+			/**
+			* Record that an `open` settled on a tab.
+			*
+			* A record the layout has not yet shown the seat gets its occurrence here, so
+			* the body's first render already carries the opener's `params`.
+			* @param sessionId - the session opened into.
+			* @param tabId - the tab the open settled on.
+			* @param target - the address and the opener's params.
+			*/
+			navigate(sessionId, tabId, target) {
+				const existing = this.session(sessionId).get(tabId);
+				if (existing === void 0) {
+					this.hold(sessionId, tabId, {
+						...target,
+						revision: 1
+					});
+					return;
+				}
+				existing.navigation.set({
+					...target,
+					revision: existing.navigation.getSnapshot().revision + 1
+				});
+			}
+			/** Abort every occurrence of every session; the package is unloading. */
+			dispose() {
+				for (const held of this.bySession.values()) for (const occurrence of held.values()) occurrence.controller.abort();
+				this.bySession.clear();
+			}
+			session(sessionId) {
+				let held = this.bySession.get(sessionId);
+				if (held === void 0) {
+					held = /* @__PURE__ */ new Map();
+					this.bySession.set(sessionId, held);
+				}
+				return held;
+			}
+			hold(sessionId, tabId, navigation) {
+				const controller = new AbortController();
+				const { navigator } = this;
+				const place = (placement) => ({
+					...placement.replaceTab === true ? { replaceTab: tabId } : held.paneId === void 0 ? {} : { paneId: held.paneId },
+					...placement.paneId === void 0 ? {} : { paneId: placement.paneId },
+					...placement.revealIfOpened === void 0 ? {} : { revealIfOpened: placement.revealIfOpened }
+				});
+				const held = {
+					sessionId,
+					tabId,
+					controller,
+					signal: controller.signal,
+					navigation: (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(navigation),
+					paneId: void 0,
+					pinned: false,
+					tabActions: {
+						openResource: (address, options = {}) => {
+							navigator.openResourceIn(sessionId, address, {
+								...place(options),
+								params: options.params
+							});
+						},
+						openTab: (kind, options = {}) => {
+							navigator.openTabIn(sessionId, kind, {
+								...place(options),
+								params: options.params
+							});
+						},
+						close: () => {
+							navigator.closeIn(sessionId, tabId);
+						}
+					}
+				};
+				this.session(sessionId).set(tabId, held);
+				return held;
+			}
+		};
+		//#endregion
+		//#region lib/types/client/service.js
+		/**
+		* Create the public controller and the plugin-private store adoption callback.
+		* Adoption subscribes without reconciling; the first store commit creates occurrences.
+		* @param tabs - registered tab types.
+		* @param pin - resource retention for an occurrence's lifetime.
+		* @returns the controller and a callback releasing exactly its own adoption.
+		*/
+		function createSidebarRightController(tabs, pin) {
+			const adopted = /* @__PURE__ */ new Map();
+			const controller = new SidebarRightController(tabs, pin, adopted);
+			return {
+				controller,
+				adopt(sessionId, store) {
+					adopted.get(sessionId)?.unsubscribe();
+					const sync = () => {
+						const surface = store.getSnapshot().bySession[sessionId];
+						if (surface !== void 0) controller.tabDomain.sync(sessionId, surface.layout);
+					};
+					const adoption = {
+						store,
+						unsubscribe: store.subscribe(sync)
+					};
+					adopted.set(sessionId, adoption);
+					return () => {
+						adoption.unsubscribe();
+						if (adopted.get(sessionId) === adoption) adopted.delete(sessionId);
+					};
+				}
+			};
+		}
+		/** The scheme every resource address carries; anything else is not a resource this face opens. */
+		const RESOURCE_SCHEME = "dsh-resource://";
+		/** Cross-plugin right-Sidebar face (ctx.sidebarRight). */
+		var SidebarRightController = class {
+			tabs;
+			adopted;
+			binding;
+			/**
+			* The Tab domain this controller navigates into; synced from each adopted
+			* store's commits, read by the seat for each body's owner share.
+			*/
+			tabDomain;
+			/**
+			* @param tabs - the tab-type registry consulted to claim an address.
+			* @param pin - `ctx.resources.pin`, which the Tab domain holds addresses with.
+			* @param adopted - plugin-owned session stores used by occurrence actions.
+			*/
+			constructor(tabs, pin, adopted = /* @__PURE__ */ new Map()) {
+				this.tabs = tabs;
+				this.adopted = adopted;
+				this.tabDomain = new TabDomain(this, pin);
+			}
+			/**
+			* Adopt the mounted seat's binding, replacing any previous one.
+			*
+			* Called from the seat while it is mounted, and released when it leaves.
+			* @param binding - the mounted seat's session, actions, and the store's surfaces.
+			* @returns a release callback that clears exactly this binding.
+			*/
+			bind(binding) {
+				this.binding = binding;
+				return () => {
+					if (this.binding === binding) this.binding = void 0;
+				};
+			}
+			/**
+			* Open a resource: claim it, place it, reveal the column, record the navigation.
+			* @param address - a `dsh-resource://<type>/…` address.
+			* @param options - placement, the opening type, and navigation parameters.
+			*/
+			openResource(address, options = {}) {
+				const { sessionId, actions } = this.require();
+				this.placeResource(sessionId, actions, address, options);
+			}
+			/**
+			* Open a page type by kind at the address this package records pages under.
+			* @param kind - the page type's kind.
+			* @param options - placement and that kind's navigation parameters.
+			*/
+			openTab(kind, options = {}) {
+				const { sessionId, actions } = this.require();
+				this.placeTab(sessionId, actions, kind, options);
+			}
+			/**
+			* Open a resource in one session, for a tab's own action; nothing happens
+			* for a session whose store was never adopted or whose adoption was released.
+			* Not part of `ISidebarRight`: the Tab domain's path.
+			* @param sessionId - the session the acting tab is in.
+			* @param address - a `dsh-resource://<type>/…` address.
+			* @param options - placement, the opening type, and navigation parameters.
+			*/
+			openResourceIn(sessionId, address, options = {}) {
+				const actions = this.actionsFor(sessionId);
+				if (actions !== void 0) this.placeResource(sessionId, actions, address, options);
+			}
+			/**
+			* Open a page type in one session, for a tab's own action; nothing happens
+			* for a session whose store was never adopted or whose adoption was released.
+			* Not part of `ISidebarRight`: the Tab domain's path.
+			* @param sessionId - the session the acting tab is in.
+			* @param kind - the page type's kind.
+			* @param options - placement and that kind's navigation parameters.
+			*/
+			openTabIn(sessionId, kind, options = {}) {
+				const actions = this.actionsFor(sessionId);
+				if (actions !== void 0) this.placeTab(sessionId, actions, kind, options);
+			}
+			/**
+			* Close a tab of one session, for the tab's own action; nothing happens
+			* for a session whose store was never adopted or whose adoption was released.
+			* Not part of `ISidebarRight`: the Tab domain's path.
+			* @param sessionId - the session the tab is in.
+			* @param tabId - the tab to close.
+			*/
+			closeIn(sessionId, tabId) {
+				const actions = this.actionsFor(sessionId);
+				if (actions !== void 0) actions.closeTab(sessionId, tabId);
+			}
+			/** Claim a resource and place it in one session; an address outside the scheme or one no type claims throws. */
+			placeResource(sessionId, actions, address, options) {
+				if (!address.startsWith(RESOURCE_SCHEME)) throw new Error(`sidebarRight: no registered tab type claims "${address}"`);
+				this.place(sessionId, actions, this.tabs.claim(address, options.kind), address, options, options.params);
+			}
+			/** Place a page type in one session at the address pages are recorded under; an unregistered kind throws. */
+			placeTab(sessionId, actions, kind, options) {
+				const definition = this.tabs.get(kind);
+				if (definition === void 0) throw new Error(`sidebarRight: no tab type is registered as "${kind}"`);
+				const address = pageAddress(kind);
+				this.place(sessionId, actions, {
+					kind,
+					contentId: address,
+					title: definition.title(address)
+				}, address, options, options.params);
+			}
+			/** The steps both opens share: one store intent, and the navigation record for the tab it settles on. */
+			place(sessionId, actions, claim, address, placement, params) {
+				actions.openContent(sessionId, {
+					kind: claim.kind,
+					contentId: claim.contentId,
+					title: claim.title,
+					...placement.paneId === void 0 ? {} : { paneId: placement.paneId },
+					...placement.replaceTab === void 0 ? {} : { replaceTab: placement.replaceTab },
+					...placement.revealIfOpened === void 0 ? {} : { revealIfOpened: placement.revealIfOpened }
+				}, (tabId) => {
+					this.tabDomain.navigate(sessionId, tabId, {
+						address,
+						params
+					});
+				});
+			}
+			/**
+			* Close one tab of the mounted session.
+			* @param tabId - the tab to close.
+			*/
+			close(tabId) {
+				const { sessionId, actions } = this.require();
+				actions.closeTab(sessionId, tabId);
+			}
+			/**
+			* The active tab of the active pane.
+			* @returns the record, or `undefined` with no mounted surface.
+			*/
+			active() {
+				const layout = this.mounted()?.layout;
+				if (layout === void 0) return void 0;
+				const { activeTabId } = (0, _deepseek_ai_dsh_client_ui_dockkit.getPane)(layout, layout.activePaneId);
+				return Object.values(layout.tabs).find((tab) => tab.id === activeTabId);
+			}
+			/**
+			* Whether the column is currently showing its panel.
+			* @returns `true` while expanded; `false` while collapsed or with no mounted surface.
+			*/
+			isExpanded() {
+				return this.mounted()?.layout.expanded ?? false;
+			}
+			/** Collapse an expanded column, or expand a collapsed one. */
+			toggleExpanded() {
+				const { sessionId, actions } = this.require();
+				actions.toggleExpanded(sessionId);
+			}
+			/**
+			* Focus a tab and the pane holding it; a missing tab is left alone.
+			* @param tabId - the tab to focus.
+			*/
+			focus(tabId) {
+				const { sessionId, actions } = this.require();
+				if (this.mounted()?.layout.tabs[tabId] === void 0) return;
+				actions.focusTab(sessionId, tabId);
+			}
+			/**
+			* Split a docked pane to its right when the budget and the room rule allow.
+			* @param paneId - the pane to split; defaults to the active docked pane.
+			* @returns the new pane's id, or `undefined` when nothing was split.
+			*/
+			split(paneId) {
+				const { sessionId, actions, canSplitPane } = this.require();
+				const layout = this.mounted()?.layout;
+				if (layout === void 0) return void 0;
+				const target = paneId ?? (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(layout);
+				const node = layout.nodes[target];
+				if (node === void 0 || node.kind !== "pane" || node.host !== "dock") return void 0;
+				if (!(0, _deepseek_ai_dsh_client_ui_dockkit.canSplit)(layout) || (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(layout).length >= 2 || !canSplitPane(target)) return void 0;
+				let created;
+				actions.splitPane(sessionId, target, (id) => {
+					created = id;
+				});
+				return created;
+			}
+			/**
+			* Take a docked tab out into a floating panel; a missing or floating tab is left alone.
+			* @param tabId - the tab to float.
+			* @param rect - the panel's rectangle; defaults to the cascade from the last panel.
+			*/
+			float(tabId, rect) {
+				const { sessionId, actions } = this.require();
+				const layout = this.mounted()?.layout;
+				if (layout === void 0 || layout.tabs[tabId] === void 0) return;
+				if ((0, _deepseek_ai_dsh_client_ui_dockkit.findTabPane)(layout, tabId).host !== "dock") return;
+				actions.floatTab(sessionId, tabId, rect);
+			}
+			/**
+			* Return a floating panel's tab to the active docked pane; a missing or docked pane is left alone.
+			* @param paneId - the floating pane.
+			*/
+			dock(paneId) {
+				const { sessionId, actions } = this.require();
+				const node = this.mounted()?.layout.nodes[paneId];
+				if (node === void 0 || node.kind !== "pane" || node.host !== "float") return;
+				actions.unfloatPane(sessionId, paneId);
+			}
+			/**
+			* Step the mounted session's surface back one intent.
+			*
+			* @internal Not part of the product: the sequence is an architectural fact
+			* with no user-facing control yet. Kept reachable for tests.
+			*/
+			_undo() {
+				const { sessionId, actions } = this.require();
+				actions.undo(sessionId);
+			}
+			/**
+			* Step the mounted session's surface forward one intent.
+			*
+			* @internal See `_undo`.
+			*/
+			_redo() {
+				const { sessionId, actions } = this.require();
+				actions.redo(sessionId);
+			}
+			/** The mounted session's surface; `undefined` without a seat or before its first open. */
+			mounted() {
+				const { binding } = this;
+				return binding === void 0 ? void 0 : binding.surfaces[binding.sessionId];
+			}
+			/**
+			* The store actions a tab's own action on `sessionId` runs through: that
+			* session's adopted store. `undefined` — nothing to act on — for a session
+			* whose store was never minted or whose adoption was released.
+			*/
+			actionsFor(sessionId) {
+				return this.adopted.get(sessionId)?.store.actions;
+			}
+			require() {
+				if (this.binding === void 0) throw new Error("sidebarRight: no session surface is mounted");
+				return this.binding;
+			}
+		};
+		//#endregion
+		//#region ../../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/constants.js
+		var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const WIN_SLASH = "\\\\/";
+			const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+			const DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+			/**
+			* Posix glob regex
+			*/
+			const DOT_LITERAL = "\\.";
+			const PLUS_LITERAL = "\\+";
+			const QMARK_LITERAL = "\\?";
+			const SLASH_LITERAL = "\\/";
+			const ONE_CHAR = "(?=.)";
+			const QMARK = "[^/]";
+			const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+			const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+			const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+			const POSIX_CHARS = {
+				DOT_LITERAL,
+				PLUS_LITERAL,
+				QMARK_LITERAL,
+				SLASH_LITERAL,
+				ONE_CHAR,
+				QMARK,
+				END_ANCHOR,
+				DOTS_SLASH,
+				NO_DOT: `(?!${DOT_LITERAL})`,
+				NO_DOTS: `(?!${START_ANCHOR}${DOTS_SLASH})`,
+				NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`,
+				NO_DOTS_SLASH: `(?!${DOTS_SLASH})`,
+				QMARK_NO_DOT: `[^.${SLASH_LITERAL}]`,
+				STAR: `${QMARK}*?`,
+				START_ANCHOR,
+				SEP: "/"
+			};
+			/**
+			* Windows glob regex
+			*/
+			const WINDOWS_CHARS = {
+				...POSIX_CHARS,
+				SLASH_LITERAL: `[${WIN_SLASH}]`,
+				QMARK: WIN_NO_SLASH,
+				STAR: `${WIN_NO_SLASH}*?`,
+				DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+				NO_DOT: `(?!${DOT_LITERAL})`,
+				NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+				NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+				NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+				QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+				START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+				END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+				SEP: "\\"
+			};
+			module.exports = {
+				DEFAULT_MAX_EXTGLOB_RECURSION,
+				MAX_LENGTH: 1024 * 64,
+				POSIX_REGEX_SOURCE: {
+					__proto__: null,
+					alnum: "a-zA-Z0-9",
+					alpha: "a-zA-Z",
+					ascii: "\\x00-\\x7F",
+					blank: " \\t",
+					cntrl: "\\x00-\\x1F\\x7F",
+					digit: "0-9",
+					graph: "\\x21-\\x7E",
+					lower: "a-z",
+					print: "\\x20-\\x7E ",
+					punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+					space: " \\t\\r\\n\\v\\f",
+					upper: "A-Z",
+					word: "A-Za-z0-9_",
+					xdigit: "A-Fa-f0-9"
+				},
+				REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+				REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+				REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+				REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+				REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+				REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+				REPLACEMENTS: {
+					__proto__: null,
+					"***": "*",
+					"**/**": "**",
+					"**/**/**": "**"
+				},
+				CHAR_0: 48,
+				CHAR_9: 57,
+				CHAR_UPPERCASE_A: 65,
+				CHAR_LOWERCASE_A: 97,
+				CHAR_UPPERCASE_Z: 90,
+				CHAR_LOWERCASE_Z: 122,
+				CHAR_LEFT_PARENTHESES: 40,
+				CHAR_RIGHT_PARENTHESES: 41,
+				CHAR_ASTERISK: 42,
+				CHAR_AMPERSAND: 38,
+				CHAR_AT: 64,
+				CHAR_BACKWARD_SLASH: 92,
+				CHAR_CARRIAGE_RETURN: 13,
+				CHAR_CIRCUMFLEX_ACCENT: 94,
+				CHAR_COLON: 58,
+				CHAR_COMMA: 44,
+				CHAR_DOT: 46,
+				CHAR_DOUBLE_QUOTE: 34,
+				CHAR_EQUAL: 61,
+				CHAR_EXCLAMATION_MARK: 33,
+				CHAR_FORM_FEED: 12,
+				CHAR_FORWARD_SLASH: 47,
+				CHAR_GRAVE_ACCENT: 96,
+				CHAR_HASH: 35,
+				CHAR_HYPHEN_MINUS: 45,
+				CHAR_LEFT_ANGLE_BRACKET: 60,
+				CHAR_LEFT_CURLY_BRACE: 123,
+				CHAR_LEFT_SQUARE_BRACKET: 91,
+				CHAR_LINE_FEED: 10,
+				CHAR_NO_BREAK_SPACE: 160,
+				CHAR_PERCENT: 37,
+				CHAR_PLUS: 43,
+				CHAR_QUESTION_MARK: 63,
+				CHAR_RIGHT_ANGLE_BRACKET: 62,
+				CHAR_RIGHT_CURLY_BRACE: 125,
+				CHAR_RIGHT_SQUARE_BRACKET: 93,
+				CHAR_SEMICOLON: 59,
+				CHAR_SINGLE_QUOTE: 39,
+				CHAR_SPACE: 32,
+				CHAR_TAB: 9,
+				CHAR_UNDERSCORE: 95,
+				CHAR_VERTICAL_LINE: 124,
+				CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+				/**
+				* Create EXTGLOB_CHARS
+				*/
+				extglobChars(chars) {
+					return {
+						"!": {
+							type: "negate",
+							open: "(?:(?!(?:",
+							close: `))${chars.STAR})`
+						},
+						"?": {
+							type: "qmark",
+							open: "(?:",
+							close: ")?"
+						},
+						"+": {
+							type: "plus",
+							open: "(?:",
+							close: ")+"
+						},
+						"*": {
+							type: "star",
+							open: "(?:",
+							close: ")*"
+						},
+						"@": {
+							type: "at",
+							open: "(?:",
+							close: ")"
+						}
+					};
+				},
+				/**
+				* Create GLOB_CHARS
+				*/
+				globChars(win32) {
+					return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+				}
+			};
+		}));
+		//#endregion
+		//#region ../../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/utils.js
+		var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+			const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
+			exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+			exports.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+			exports.isRegexChar = (str) => str.length === 1 && exports.hasRegexChars(str);
+			exports.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+			exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+			exports.isWindows = () => {
+				if (typeof navigator !== "undefined" && navigator.platform) {
+					const platform = navigator.platform.toLowerCase();
+					return platform === "win32" || platform === "windows";
+				}
+				if (typeof process !== "undefined" && process.platform) return process.platform === "win32";
+				return false;
+			};
+			exports.removeBackslashes = (str) => {
+				return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+					return match === "\\" ? "" : match;
+				});
+			};
+			exports.escapeLast = (input, char, lastIdx) => {
+				const idx = input.lastIndexOf(char, lastIdx);
+				if (idx === -1) return input;
+				if (input[idx - 1] === "\\") return exports.escapeLast(input, char, idx - 1);
+				return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+			};
+			exports.removePrefix = (input, state = {}) => {
+				let output = input;
+				if (output.startsWith("./")) {
+					output = output.slice(2);
+					state.prefix = "./";
+				}
+				return output;
+			};
+			exports.wrapOutput = (input, state = {}, options = {}) => {
+				let output = `${options.contains ? "" : "^"}(?:${input})${options.contains ? "" : "$"}`;
+				if (state.negated === true) output = `(?:^(?!${output}).*$)`;
+				return output;
+			};
+			exports.basename = (path, { windows } = {}) => {
+				const segs = path.split(windows ? /[\\/]/ : "/");
+				const last = segs[segs.length - 1];
+				if (last === "") return segs[segs.length - 2];
+				return last;
+			};
+		}));
+		//#endregion
+		//#region ../../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/scan.js
+		var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const utils = require_utils();
+			const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
+			const isPathSeparator = (code) => {
+				return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+			};
+			const depth = (token) => {
+				if (token.isPrefix !== true) token.depth = token.isGlobstar ? Infinity : 1;
+			};
+			/**
+			* Quickly scans a glob pattern and returns an object with a handful of
+			* useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+			* `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+			* with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+			*
+			* ```js
+			* const pm = require('picomatch');
+			* console.log(pm.scan('foo/bar/*.js'));
+			* { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+			* ```
+			* @param {String} `str`
+			* @param {Object} `options`
+			* @return {Object} Returns an object with tokens and regex source string.
+			* @api public
+			*/
+			const scan = (input, options) => {
+				const opts = options || {};
+				const length = input.length - 1;
+				const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+				const slashes = [];
+				const tokens = [];
+				const parts = [];
+				let str = input;
+				let index = -1;
+				let start = 0;
+				let lastIndex = 0;
+				let isBrace = false;
+				let isBracket = false;
+				let isGlob = false;
+				let isExtglob = false;
+				let isGlobstar = false;
+				let braceEscaped = false;
+				let backslashes = false;
+				let negated = false;
+				let negatedExtglob = false;
+				let finished = false;
+				let braces = 0;
+				let prev;
+				let code;
+				let token = {
+					value: "",
+					depth: 0,
+					isGlob: false
+				};
+				const eos = () => index >= length;
+				const peek = () => str.charCodeAt(index + 1);
+				const advance = () => {
+					prev = code;
+					return str.charCodeAt(++index);
+				};
+				while (index < length) {
+					code = advance();
+					let next;
+					if (code === CHAR_BACKWARD_SLASH) {
+						backslashes = token.backslashes = true;
+						code = advance();
+						if (code === CHAR_LEFT_CURLY_BRACE) braceEscaped = true;
+						continue;
+					}
+					if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+						braces++;
+						while (eos() !== true && (code = advance())) {
+							if (code === CHAR_BACKWARD_SLASH) {
+								backslashes = token.backslashes = true;
+								advance();
+								continue;
+							}
+							if (code === CHAR_LEFT_CURLY_BRACE) {
+								braces++;
+								continue;
+							}
+							if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+								isBrace = token.isBrace = true;
+								isGlob = token.isGlob = true;
+								finished = true;
+								if (scanToEnd === true) continue;
+								break;
+							}
+							if (braceEscaped !== true && code === CHAR_COMMA) {
+								isBrace = token.isBrace = true;
+								isGlob = token.isGlob = true;
+								finished = true;
+								if (scanToEnd === true) continue;
+								break;
+							}
+							if (code === CHAR_RIGHT_CURLY_BRACE) {
+								braces--;
+								if (braces === 0) {
+									braceEscaped = false;
+									isBrace = token.isBrace = true;
+									finished = true;
+									break;
+								}
+							}
+						}
+						if (scanToEnd === true) continue;
+						break;
+					}
+					if (code === CHAR_FORWARD_SLASH) {
+						slashes.push(index);
+						tokens.push(token);
+						token = {
+							value: "",
+							depth: 0,
+							isGlob: false
+						};
+						if (finished === true) continue;
+						if (prev === CHAR_DOT && index === start + 1) {
+							start += 2;
+							continue;
+						}
+						lastIndex = index + 1;
+						continue;
+					}
+					if (opts.noext !== true) {
+						if ((code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) === true && peek() === CHAR_LEFT_PARENTHESES) {
+							isGlob = token.isGlob = true;
+							isExtglob = token.isExtglob = true;
+							finished = true;
+							if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
+							if (scanToEnd === true) {
+								while (eos() !== true && (code = advance())) {
+									if (code === CHAR_BACKWARD_SLASH) {
+										backslashes = token.backslashes = true;
+										code = advance();
+										continue;
+									}
+									if (code === CHAR_RIGHT_PARENTHESES) {
+										isGlob = token.isGlob = true;
+										finished = true;
+										break;
+									}
+								}
+								continue;
+							}
+							break;
+						}
+					}
+					if (code === CHAR_ASTERISK) {
+						if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) continue;
+						break;
+					}
+					if (code === CHAR_QUESTION_MARK) {
+						isGlob = token.isGlob = true;
+						finished = true;
+						if (scanToEnd === true) continue;
+						break;
+					}
+					if (code === CHAR_LEFT_SQUARE_BRACKET) {
+						while (eos() !== true && (next = advance())) {
+							if (next === CHAR_BACKWARD_SLASH) {
+								backslashes = token.backslashes = true;
+								advance();
+								continue;
+							}
+							if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+								isBracket = token.isBracket = true;
+								isGlob = token.isGlob = true;
+								finished = true;
+								break;
+							}
+						}
+						if (scanToEnd === true) continue;
+						break;
+					}
+					if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+						negated = token.negated = true;
+						start++;
+						continue;
+					}
+					if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+						isGlob = token.isGlob = true;
+						if (scanToEnd === true) {
+							while (eos() !== true && (code = advance())) {
+								if (code === CHAR_LEFT_PARENTHESES) {
+									backslashes = token.backslashes = true;
+									code = advance();
+									continue;
+								}
+								if (code === CHAR_RIGHT_PARENTHESES) {
+									finished = true;
+									break;
+								}
+							}
+							continue;
+						}
+						break;
+					}
+					if (isGlob === true) {
+						finished = true;
+						if (scanToEnd === true) continue;
+						break;
+					}
+				}
+				if (opts.noext === true) {
+					isExtglob = false;
+					isGlob = false;
+				}
+				let base = str;
+				let prefix = "";
+				let glob = "";
+				if (start > 0) {
+					prefix = str.slice(0, start);
+					str = str.slice(start);
+					lastIndex -= start;
+				}
+				if (base && isGlob === true && lastIndex > 0) {
+					base = str.slice(0, lastIndex);
+					glob = str.slice(lastIndex);
+				} else if (isGlob === true) {
+					base = "";
+					glob = str;
+				} else base = str;
+				if (base && base !== "" && base !== "/" && base !== str) {
+					if (isPathSeparator(base.charCodeAt(base.length - 1))) base = base.slice(0, -1);
+				}
+				if (opts.unescape === true) {
+					if (glob) glob = utils.removeBackslashes(glob);
+					if (base && backslashes === true) base = utils.removeBackslashes(base);
+				}
+				const state = {
+					prefix,
+					input,
+					start,
+					base,
+					glob,
+					isBrace,
+					isBracket,
+					isGlob,
+					isExtglob,
+					isGlobstar,
+					negated,
+					negatedExtglob
+				};
+				if (opts.tokens === true) {
+					state.maxDepth = 0;
+					if (!isPathSeparator(code)) tokens.push(token);
+					state.tokens = tokens;
+				}
+				if (opts.parts === true || opts.tokens === true) {
+					let prevIndex;
+					for (let idx = 0; idx < slashes.length; idx++) {
+						const n = prevIndex ? prevIndex + 1 : start;
+						const i = slashes[idx];
+						const value = input.slice(n, i);
+						if (opts.tokens) {
+							if (idx === 0 && start !== 0) {
+								tokens[idx].isPrefix = true;
+								tokens[idx].value = prefix;
+							} else tokens[idx].value = value;
+							depth(tokens[idx]);
+							state.maxDepth += tokens[idx].depth;
+						}
+						if (idx !== 0 || value !== "") parts.push(value);
+						prevIndex = i;
+					}
+					if (prevIndex && prevIndex + 1 < input.length) {
+						const value = input.slice(prevIndex + 1);
+						parts.push(value);
+						if (opts.tokens) {
+							tokens[tokens.length - 1].value = value;
+							depth(tokens[tokens.length - 1]);
+							state.maxDepth += tokens[tokens.length - 1].depth;
+						}
+					}
+					state.slashes = slashes;
+					state.parts = parts;
+				}
+				return state;
+			};
+			module.exports = scan;
+		}));
+		//#endregion
+		//#region ../../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/parse.js
+		var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const constants = require_constants();
+			const utils = require_utils();
+			/**
+			* Constants
+			*/
+			const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+			/**
+			* Helpers
+			*/
+			const expandRange = (args, options) => {
+				if (typeof options.expandRange === "function") return options.expandRange(...args, options);
+				args.sort();
+				const value = `[${args.join("-")}]`;
+				try {
+					new RegExp(value);
+				} catch (ex) {
+					return args.map((v) => utils.escapeRegex(v)).join("..");
+				}
+				return value;
+			};
+			/**
+			* Create the message for a syntax error
+			*/
+			const syntaxError = (type, char) => {
+				return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+			};
+			const splitTopLevel = (input) => {
+				const parts = [];
+				let bracket = 0;
+				let paren = 0;
+				let quote = 0;
+				let value = "";
+				let escaped = false;
+				for (const ch of input) {
+					if (escaped === true) {
+						value += ch;
+						escaped = false;
+						continue;
+					}
+					if (ch === "\\") {
+						value += ch;
+						escaped = true;
+						continue;
+					}
+					if (ch === "\"") {
+						quote = quote === 1 ? 0 : 1;
+						value += ch;
+						continue;
+					}
+					if (quote === 0) {
+						if (ch === "[") bracket++;
+						else if (ch === "]" && bracket > 0) bracket--;
+						else if (bracket === 0) {
+							if (ch === "(") paren++;
+							else if (ch === ")" && paren > 0) paren--;
+							else if (ch === "|" && paren === 0) {
+								parts.push(value);
+								value = "";
+								continue;
+							}
+						}
+					}
+					value += ch;
+				}
+				parts.push(value);
+				return parts;
+			};
+			const isPlainBranch = (branch) => {
+				let escaped = false;
+				for (const ch of branch) {
+					if (escaped === true) {
+						escaped = false;
+						continue;
+					}
+					if (ch === "\\") {
+						escaped = true;
+						continue;
+					}
+					if (/[?*+@!()[\]{}]/.test(ch)) return false;
+				}
+				return true;
+			};
+			const normalizeSimpleBranch = (branch) => {
+				let value = branch.trim();
+				let changed = true;
+				while (changed === true) {
+					changed = false;
+					if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+						value = value.slice(2, -1);
+						changed = true;
+					}
+				}
+				if (!isPlainBranch(value)) return;
+				return value.replace(/\\(.)/g, "$1");
+			};
+			const hasRepeatedCharPrefixOverlap = (branches) => {
+				const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+				for (let i = 0; i < values.length; i++) for (let j = i + 1; j < values.length; j++) {
+					const a = values[i];
+					const b = values[j];
+					const char = a[0];
+					if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) continue;
+					if (a === b || a.startsWith(b) || b.startsWith(a)) return true;
+				}
+				return false;
+			};
+			const parseRepeatedExtglob = (pattern, requireEnd = true) => {
+				if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") return;
+				let bracket = 0;
+				let paren = 0;
+				let quote = 0;
+				let escaped = false;
+				for (let i = 1; i < pattern.length; i++) {
+					const ch = pattern[i];
+					if (escaped === true) {
+						escaped = false;
+						continue;
+					}
+					if (ch === "\\") {
+						escaped = true;
+						continue;
+					}
+					if (ch === "\"") {
+						quote = quote === 1 ? 0 : 1;
+						continue;
+					}
+					if (quote === 1) continue;
+					if (ch === "[") {
+						bracket++;
+						continue;
+					}
+					if (ch === "]" && bracket > 0) {
+						bracket--;
+						continue;
+					}
+					if (bracket > 0) continue;
+					if (ch === "(") {
+						paren++;
+						continue;
+					}
+					if (ch === ")") {
+						paren--;
+						if (paren === 0) {
+							if (requireEnd === true && i !== pattern.length - 1) return;
+							return {
+								type: pattern[0],
+								body: pattern.slice(2, i),
+								end: i
+							};
+						}
+					}
+				}
+			};
+			const getStarExtglobSequenceOutput = (pattern) => {
+				let index = 0;
+				const chars = [];
+				while (index < pattern.length) {
+					const match = parseRepeatedExtglob(pattern.slice(index), false);
+					if (!match || match.type !== "*") return;
+					const branches = splitTopLevel(match.body).map((branch) => branch.trim());
+					if (branches.length !== 1) return;
+					const branch = normalizeSimpleBranch(branches[0]);
+					if (!branch || branch.length !== 1) return;
+					chars.push(branch);
+					index += match.end + 1;
+				}
+				if (chars.length < 1) return;
+				return `${chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`}*`;
+			};
+			const repeatedExtglobRecursion = (pattern) => {
+				let depth = 0;
+				let value = pattern.trim();
+				let match = parseRepeatedExtglob(value);
+				while (match) {
+					depth++;
+					value = match.body.trim();
+					match = parseRepeatedExtglob(value);
+				}
+				return depth;
+			};
+			const analyzeRepeatedExtglob = (body, options) => {
+				if (options.maxExtglobRecursion === false) return { risky: false };
+				const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+				const branches = splitTopLevel(body).map((branch) => branch.trim());
+				if (branches.length > 1) {
+					if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) return { risky: true };
+				}
+				for (const branch of branches) {
+					const safeOutput = getStarExtglobSequenceOutput(branch);
+					if (safeOutput) return {
+						risky: true,
+						safeOutput
+					};
+					if (repeatedExtglobRecursion(branch) > max) return { risky: true };
+				}
+				return { risky: false };
+			};
+			/**
+			* Parse the given input string.
+			* @param {String} input
+			* @param {Object} options
+			* @return {Object}
+			*/
+			const parse = (input, options) => {
+				if (typeof input !== "string") throw new TypeError("Expected a string");
+				input = REPLACEMENTS[input] || input;
+				const opts = { ...options };
+				const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+				let len = input.length;
+				if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+				const bos = {
+					type: "bos",
+					value: "",
+					output: opts.prepend || ""
+				};
+				const tokens = [bos];
+				const capture = opts.capture ? "" : "?:";
+				const PLATFORM_CHARS = constants.globChars(opts.windows);
+				const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+				const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
+				const globstar = (opts) => {
+					return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+				};
+				const nodot = opts.dot ? "" : NO_DOT;
+				const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+				let star = opts.bash === true ? globstar(opts) : STAR;
+				if (opts.capture) star = `(${star})`;
+				if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
+				const state = {
+					input,
+					index: -1,
+					start: 0,
+					dot: opts.dot === true,
+					consumed: "",
+					output: "",
+					prefix: "",
+					backtrack: false,
+					negated: false,
+					brackets: 0,
+					braces: 0,
+					parens: 0,
+					quotes: 0,
+					globstar: false,
+					tokens
+				};
+				input = utils.removePrefix(input, state);
+				len = input.length;
+				const extglobs = [];
+				const braces = [];
+				const stack = [];
+				let prev = bos;
+				let value;
+				/**
+				* Tokenizing helpers
+				*/
+				const eos = () => state.index === len - 1;
+				const peek = state.peek = (n = 1) => input[state.index + n];
+				const advance = state.advance = () => input[++state.index] || "";
+				const remaining = () => input.slice(state.index + 1);
+				const consume = (value = "", num = 0) => {
+					state.consumed += value;
+					state.index += num;
+				};
+				const append = (token) => {
+					state.output += token.output != null ? token.output : token.value;
+					consume(token.value);
+				};
+				const negate = () => {
+					let count = 1;
+					while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+						advance();
+						state.start++;
+						count++;
+					}
+					if (count % 2 === 0) return false;
+					state.negated = true;
+					state.start++;
+					return true;
+				};
+				const increment = (type) => {
+					state[type]++;
+					stack.push(type);
+				};
+				const decrement = (type) => {
+					state[type]--;
+					stack.pop();
+				};
+				/**
+				* Push tokens onto the tokens array. This helper speeds up
+				* tokenizing by 1) helping us avoid backtracking as much as possible,
+				* and 2) helping us avoid creating extra tokens when consecutive
+				* characters are plain text. This improves performance and simplifies
+				* lookbehinds.
+				*/
+				const push = (tok) => {
+					if (prev.type === "globstar") {
+						const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+						const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+						if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+							state.output = state.output.slice(0, -prev.output.length);
+							prev.type = "star";
+							prev.value = "*";
+							prev.output = star;
+							state.output += prev.output;
+						}
+					}
+					if (extglobs.length && tok.type !== "paren") extglobs[extglobs.length - 1].inner += tok.value;
+					if (tok.value || tok.output) append(tok);
+					if (prev && prev.type === "text" && tok.type === "text") {
+						prev.output = (prev.output || prev.value) + tok.value;
+						prev.value += tok.value;
+						return;
+					}
+					tok.prev = prev;
+					tokens.push(tok);
+					prev = tok;
+				};
+				const extglobOpen = (type, value) => {
+					const token = {
+						...EXTGLOB_CHARS[value],
+						conditions: 1,
+						inner: ""
+					};
+					token.prev = prev;
+					token.parens = state.parens;
+					token.output = state.output;
+					token.startIndex = state.index;
+					token.tokensIndex = tokens.length;
+					const output = (opts.capture ? "(" : "") + token.open;
+					increment("parens");
+					push({
+						type,
+						value,
+						output: state.output ? "" : ONE_CHAR
+					});
+					push({
+						type: "paren",
+						extglob: true,
+						value: advance(),
+						output
+					});
+					extglobs.push(token);
+				};
+				const extglobClose = (token) => {
+					const literal = input.slice(token.startIndex, state.index + 1);
+					const analysis = analyzeRepeatedExtglob(input.slice(token.startIndex + 2, state.index), opts);
+					if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+						const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+						const open = tokens[token.tokensIndex];
+						open.type = "text";
+						open.value = literal;
+						open.output = safeOutput || utils.escapeRegex(literal);
+						for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+							tokens[i].value = "";
+							tokens[i].output = "";
+							delete tokens[i].suffix;
+						}
+						state.output = token.output + open.output;
+						state.backtrack = true;
+						push({
+							type: "paren",
+							extglob: true,
+							value,
+							output: ""
+						});
+						decrement("parens");
+						return;
+					}
+					let output = token.close + (opts.capture ? ")" : "");
+					let rest;
+					if (token.type === "negate") {
+						let extglobStar = star;
+						if (token.inner && token.inner.length > 1 && token.inner.includes("/")) extglobStar = globstar(opts);
+						if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
+						if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) output = token.close = `)${parse(rest, {
+							...options,
+							fastpaths: false
+						}).output})${extglobStar})`;
+						if (token.prev.type === "bos") state.negatedExtglob = true;
+					}
+					push({
+						type: "paren",
+						extglob: true,
+						value,
+						output
+					});
+					decrement("parens");
+				};
+				/**
+				* Fast paths
+				*/
+				if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+					let backslashes = false;
+					let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+						if (first === "\\") {
+							backslashes = true;
+							return m;
+						}
+						if (first === "?") {
+							if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+							if (index === 0) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+							return QMARK.repeat(chars.length);
+						}
+						if (first === ".") return DOT_LITERAL.repeat(chars.length);
+						if (first === "*") {
+							if (esc) return esc + first + (rest ? star : "");
+							return star;
+						}
+						return esc ? m : `\\${m}`;
+					});
+					if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
+					else output = output.replace(/\\+/g, (m) => {
+						return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+					});
+					if (output === input && opts.contains === true) {
+						state.output = input;
+						return state;
+					}
+					state.output = utils.wrapOutput(output, state, options);
+					return state;
+				}
+				/**
+				* Tokenize input until we reach end-of-string
+				*/
+				while (!eos()) {
+					value = advance();
+					if (value === "\0") continue;
+					/**
+					* Escaped characters
+					*/
+					if (value === "\\") {
+						const next = peek();
+						if (next === "/" && opts.bash !== true) continue;
+						if (next === "." || next === ";") continue;
+						if (!next) {
+							value += "\\";
+							push({
+								type: "text",
+								value
+							});
+							continue;
+						}
+						const match = /^\\+/.exec(remaining());
+						let slashes = 0;
+						if (match && match[0].length > 2) {
+							slashes = match[0].length;
+							state.index += slashes;
+							if (slashes % 2 !== 0) value += "\\";
+						}
+						if (opts.unescape === true) value = advance();
+						else value += advance();
+						if (state.brackets === 0) {
+							push({
+								type: "text",
+								value
+							});
+							continue;
+						}
+					}
+					/**
+					* If we're inside a regex character class, continue
+					* until we reach the closing bracket.
+					*/
+					if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+						if (opts.posix !== false && value === ":") {
+							const inner = prev.value.slice(1);
+							if (inner.includes("[")) {
+								prev.posix = true;
+								if (inner.includes(":")) {
+									const idx = prev.value.lastIndexOf("[");
+									const pre = prev.value.slice(0, idx);
+									const posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+									if (posix) {
+										prev.value = pre + posix;
+										state.backtrack = true;
+										advance();
+										if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR;
+										continue;
+									}
+								}
+							}
+						}
+						if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
+						if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
+						if (opts.posix === true && value === "!" && prev.value === "[") value = "^";
+						prev.value += value;
+						append({ value });
+						continue;
+					}
+					/**
+					* If we're inside a quoted string, continue
+					* until we reach the closing double quote.
+					*/
+					if (state.quotes === 1 && value !== "\"") {
+						value = utils.escapeRegex(value);
+						prev.value += value;
+						append({ value });
+						continue;
+					}
+					/**
+					* Double quotes
+					*/
+					if (value === "\"") {
+						state.quotes = state.quotes === 1 ? 0 : 1;
+						if (opts.keepQuotes === true) push({
+							type: "text",
+							value
+						});
+						continue;
+					}
+					/**
+					* Parentheses
+					*/
+					if (value === "(") {
+						increment("parens");
+						push({
+							type: "paren",
+							value
+						});
+						continue;
+					}
+					if (value === ")") {
+						if (state.parens === 0 && opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "("));
+						const extglob = extglobs[extglobs.length - 1];
+						if (extglob && state.parens === extglob.parens + 1) {
+							extglobClose(extglobs.pop());
+							continue;
+						}
+						push({
+							type: "paren",
+							value,
+							output: state.parens ? ")" : "\\)"
+						});
+						decrement("parens");
+						continue;
+					}
+					/**
+					* Square brackets
+					*/
+					if (value === "[") {
+						if (opts.nobracket === true || !remaining().includes("]")) {
+							if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+							value = `\\${value}`;
+						} else increment("brackets");
+						push({
+							type: "bracket",
+							value
+						});
+						continue;
+					}
+					if (value === "]") {
+						if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+							push({
+								type: "text",
+								value,
+								output: `\\${value}`
+							});
+							continue;
+						}
+						if (state.brackets === 0) {
+							if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "["));
+							push({
+								type: "text",
+								value,
+								output: `\\${value}`
+							});
+							continue;
+						}
+						decrement("brackets");
+						const prevValue = prev.value.slice(1);
+						if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
+						prev.value += value;
+						append({ value });
+						if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) continue;
+						const escaped = utils.escapeRegex(prev.value);
+						state.output = state.output.slice(0, -prev.value.length);
+						if (opts.literalBrackets === true) {
+							state.output += escaped;
+							prev.value = escaped;
+							continue;
+						}
+						prev.value = `(${capture}${escaped}|${prev.value})`;
+						state.output += prev.value;
+						continue;
+					}
+					/**
+					* Braces
+					*/
+					if (value === "{" && opts.nobrace !== true) {
+						increment("braces");
+						const open = {
+							type: "brace",
+							value,
+							output: "(",
+							outputIndex: state.output.length,
+							tokensIndex: state.tokens.length
+						};
+						braces.push(open);
+						push(open);
+						continue;
+					}
+					if (value === "}") {
+						const brace = braces[braces.length - 1];
+						if (opts.nobrace === true || !brace) {
+							push({
+								type: "text",
+								value,
+								output: value
+							});
+							continue;
+						}
+						let output = ")";
+						if (brace.dots === true) {
+							const arr = tokens.slice();
+							const range = [];
+							for (let i = arr.length - 1; i >= 0; i--) {
+								tokens.pop();
+								if (arr[i].type === "brace") break;
+								if (arr[i].type !== "dots") range.unshift(arr[i].value);
+							}
+							output = expandRange(range, opts);
+							state.backtrack = true;
+						}
+						if (brace.comma !== true && brace.dots !== true) {
+							const out = state.output.slice(0, brace.outputIndex);
+							const toks = state.tokens.slice(brace.tokensIndex);
+							brace.value = brace.output = "\\{";
+							value = output = "\\}";
+							state.output = out;
+							for (const t of toks) state.output += t.output || t.value;
+						}
+						push({
+							type: "brace",
+							value,
+							output
+						});
+						decrement("braces");
+						braces.pop();
+						continue;
+					}
+					/**
+					* Pipes
+					*/
+					if (value === "|") {
+						if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+						push({
+							type: "text",
+							value
+						});
+						continue;
+					}
+					/**
+					* Commas
+					*/
+					if (value === ",") {
+						let output = value;
+						const brace = braces[braces.length - 1];
+						if (brace && stack[stack.length - 1] === "braces") {
+							brace.comma = true;
+							output = "|";
+						}
+						push({
+							type: "comma",
+							value,
+							output
+						});
+						continue;
+					}
+					/**
+					* Slashes
+					*/
+					if (value === "/") {
+						if (prev.type === "dot" && state.index === state.start + 1) {
+							state.start = state.index + 1;
+							state.consumed = "";
+							state.output = "";
+							tokens.pop();
+							prev = bos;
+							continue;
+						}
+						push({
+							type: "slash",
+							value,
+							output: SLASH_LITERAL
+						});
+						continue;
+					}
+					/**
+					* Dots
+					*/
+					if (value === ".") {
+						if (state.braces > 0 && prev.type === "dot") {
+							if (prev.value === ".") prev.output = DOT_LITERAL;
+							const brace = braces[braces.length - 1];
+							prev.type = "dots";
+							prev.output += value;
+							prev.value += value;
+							brace.dots = true;
+							continue;
+						}
+						if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+							push({
+								type: "text",
+								value,
+								output: DOT_LITERAL
+							});
+							continue;
+						}
+						push({
+							type: "dot",
+							value,
+							output: DOT_LITERAL
+						});
+						continue;
+					}
+					/**
+					* Question marks
+					*/
+					if (value === "?") {
+						if (!(prev && prev.value === "(") && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+							extglobOpen("qmark", value);
+							continue;
+						}
+						if (prev && prev.type === "paren") {
+							const next = peek();
+							let output = value;
+							if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+							push({
+								type: "text",
+								value,
+								output
+							});
+							continue;
+						}
+						if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+							push({
+								type: "qmark",
+								value,
+								output: QMARK_NO_DOT
+							});
+							continue;
+						}
+						push({
+							type: "qmark",
+							value,
+							output: QMARK
+						});
+						continue;
+					}
+					/**
+					* Exclamation
+					*/
+					if (value === "!") {
+						if (opts.noextglob !== true && peek() === "(") {
+							if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+								extglobOpen("negate", value);
+								continue;
+							}
+						}
+						if (opts.nonegate !== true && state.index === 0) {
+							negate();
+							continue;
+						}
+					}
+					/**
+					* Plus
+					*/
+					if (value === "+") {
+						if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+							extglobOpen("plus", value);
+							continue;
+						}
+						if (prev && prev.value === "(" || opts.regex === false) {
+							push({
+								type: "plus",
+								value,
+								output: PLUS_LITERAL
+							});
+							continue;
+						}
+						if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+							push({
+								type: "plus",
+								value
+							});
+							continue;
+						}
+						push({
+							type: "plus",
+							value: PLUS_LITERAL
+						});
+						continue;
+					}
+					/**
+					* Plain text
+					*/
+					if (value === "@") {
+						if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+							push({
+								type: "at",
+								extglob: true,
+								value,
+								output: ""
+							});
+							continue;
+						}
+						push({
+							type: "text",
+							value
+						});
+						continue;
+					}
+					/**
+					* Plain text
+					*/
+					if (value !== "*") {
+						if (value === "$" || value === "^") value = `\\${value}`;
+						const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+						if (match) {
+							value += match[0];
+							state.index += match[0].length;
+						}
+						push({
+							type: "text",
+							value
+						});
+						continue;
+					}
+					/**
+					* Stars
+					*/
+					if (prev && (prev.type === "globstar" || prev.star === true)) {
+						prev.type = "star";
+						prev.star = true;
+						prev.value += value;
+						prev.output = star;
+						state.backtrack = true;
+						state.globstar = true;
+						consume(value);
+						continue;
+					}
+					let rest = remaining();
+					if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+						extglobOpen("star", value);
+						continue;
+					}
+					if (prev.type === "star") {
+						if (opts.noglobstar === true) {
+							consume(value);
+							continue;
+						}
+						const prior = prev.prev;
+						const before = prior.prev;
+						const isStart = prior.type === "slash" || prior.type === "bos";
+						const afterStar = before && (before.type === "star" || before.type === "globstar");
+						if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+							push({
+								type: "star",
+								value,
+								output: ""
+							});
+							continue;
+						}
+						const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+						const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+						if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+							push({
+								type: "star",
+								value,
+								output: ""
+							});
+							continue;
+						}
+						while (rest.slice(0, 3) === "/**") {
+							const after = input[state.index + 4];
+							if (after && after !== "/") break;
+							rest = rest.slice(3);
+							consume("/**", 3);
+						}
+						if (prior.type === "bos" && eos()) {
+							prev.type = "globstar";
+							prev.value += value;
+							prev.output = globstar(opts);
+							state.output = prev.output;
+							state.globstar = true;
+							consume(value);
+							continue;
+						}
+						if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+							state.output = state.output.slice(0, -(prior.output + prev.output).length);
+							prior.output = `(?:${prior.output}`;
+							prev.type = "globstar";
+							prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+							prev.value += value;
+							state.globstar = true;
+							state.output += prior.output + prev.output;
+							consume(value);
+							continue;
+						}
+						if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+							const end = rest[1] !== void 0 ? "|$" : "";
+							state.output = state.output.slice(0, -(prior.output + prev.output).length);
+							prior.output = `(?:${prior.output}`;
+							prev.type = "globstar";
+							prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+							prev.value += value;
+							state.output += prior.output + prev.output;
+							state.globstar = true;
+							consume(value + advance());
+							push({
+								type: "slash",
+								value: "/",
+								output: ""
+							});
+							continue;
+						}
+						if (prior.type === "bos" && rest[0] === "/") {
+							prev.type = "globstar";
+							prev.value += value;
+							prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+							state.output = prev.output;
+							state.globstar = true;
+							consume(value + advance());
+							push({
+								type: "slash",
+								value: "/",
+								output: ""
+							});
+							continue;
+						}
+						state.output = state.output.slice(0, -prev.output.length);
+						prev.type = "globstar";
+						prev.output = globstar(opts);
+						prev.value += value;
+						state.output += prev.output;
+						state.globstar = true;
+						consume(value);
+						continue;
+					}
+					const token = {
+						type: "star",
+						value,
+						output: star
+					};
+					if (opts.bash === true) {
+						token.output = ".*?";
+						if (prev.type === "bos" || prev.type === "slash") token.output = nodot + token.output;
+						push(token);
+						continue;
+					}
+					if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+						token.output = value;
+						push(token);
+						continue;
+					}
+					if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+						if (prev.type === "dot") {
+							state.output += NO_DOT_SLASH;
+							prev.output += NO_DOT_SLASH;
+						} else if (opts.dot === true) {
+							state.output += NO_DOTS_SLASH;
+							prev.output += NO_DOTS_SLASH;
+						} else {
+							state.output += nodot;
+							prev.output += nodot;
+						}
+						if (peek() !== "*") {
+							state.output += ONE_CHAR;
+							prev.output += ONE_CHAR;
+						}
+					}
+					push(token);
+				}
+				while (state.brackets > 0) {
+					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+					state.output = utils.escapeLast(state.output, "[");
+					decrement("brackets");
+				}
+				while (state.parens > 0) {
+					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+					state.output = utils.escapeLast(state.output, "(");
+					decrement("parens");
+				}
+				while (state.braces > 0) {
+					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+					state.output = utils.escapeLast(state.output, "{");
+					decrement("braces");
+				}
+				if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
+					type: "maybe_slash",
+					value: "",
+					output: `${SLASH_LITERAL}?`
+				});
+				if (state.backtrack === true) {
+					state.output = "";
+					for (const token of state.tokens) {
+						state.output += token.output != null ? token.output : token.value;
+						if (token.suffix) state.output += token.suffix;
+					}
+				}
+				return state;
+			};
+			/**
+			* Fast paths for creating regular expressions for common glob patterns.
+			* This can significantly speed up processing and has very little downside
+			* impact when none of the fast paths match.
+			*/
+			parse.fastpaths = (input, options) => {
+				const opts = { ...options };
+				const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+				const len = input.length;
+				if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+				input = REPLACEMENTS[input] || input;
+				const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(opts.windows);
+				const nodot = opts.dot ? NO_DOTS : NO_DOT;
+				const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+				const capture = opts.capture ? "" : "?:";
+				const state = {
+					negated: false,
+					prefix: ""
+				};
+				let star = opts.bash === true ? ".*?" : STAR;
+				if (opts.capture) star = `(${star})`;
+				const globstar = (opts) => {
+					if (opts.noglobstar === true) return star;
+					return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+				};
+				const create = (str) => {
+					switch (str) {
+						case "*": return `${nodot}${ONE_CHAR}${star}`;
+						case ".*": return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+						case "*.*": return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+						case "*/*": return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+						case "**": return nodot + globstar(opts);
+						case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+						case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+						case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+						default: {
+							const match = /^(.*?)\.(\w+)$/.exec(str);
+							if (!match) return;
+							const source = create(match[1]);
+							if (!source) return;
+							return source + DOT_LITERAL + match[2];
+						}
+					}
+				};
+				let source = create(utils.removePrefix(input, state));
+				if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL}?`;
+				return source;
+			};
+			module.exports = parse;
+		}));
+		//#endregion
+		//#region ../../../node_modules/.pnpm/picomatch@4.0.4/node_modules/picomatch/lib/picomatch.js
+		var require_picomatch = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+			const scan = require_scan();
+			const parse = require_parse();
+			const utils = require_utils();
+			const constants = require_constants();
+			const isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+			/**
+			* Creates a matcher function from one or more glob patterns. The
+			* returned function takes a string to match as its first argument,
+			* and returns true if the string is a match. The returned matcher
+			* function also takes a boolean as the second argument that, when true,
+			* returns an object with additional information.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* // picomatch(glob[, options]);
+			*
+			* const isMatch = picomatch('*.!(*a)');
+			* console.log(isMatch('a.a')); //=> false
+			* console.log(isMatch('a.b')); //=> true
+			* ```
+			* @name picomatch
+			* @param {String|Array} `globs` One or more glob patterns.
+			* @param {Object=} `options`
+			* @return {Function=} Returns a matcher function.
+			* @api public
+			*/
+			const picomatch = (glob, options, returnState = false) => {
+				if (Array.isArray(glob)) {
+					const fns = glob.map((input) => picomatch(input, options, returnState));
+					const arrayMatcher = (str) => {
+						for (const isMatch of fns) {
+							const state = isMatch(str);
+							if (state) return state;
+						}
+						return false;
+					};
+					return arrayMatcher;
+				}
+				const isState = isObject(glob) && glob.tokens && glob.input;
+				if (glob === "" || typeof glob !== "string" && !isState) throw new TypeError("Expected pattern to be a non-empty string");
+				const opts = options || {};
+				const posix = opts.windows;
+				const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+				const state = regex.state;
+				delete regex.state;
+				let isIgnored = () => false;
+				if (opts.ignore) {
+					const ignoreOpts = {
+						...options,
+						ignore: null,
+						onMatch: null,
+						onResult: null
+					};
+					isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+				}
+				const matcher = (input, returnObject = false) => {
+					const { isMatch, match, output } = picomatch.test(input, regex, options, {
+						glob,
+						posix
+					});
+					const result = {
+						glob,
+						state,
+						regex,
+						posix,
+						input,
+						output,
+						match,
+						isMatch
+					};
+					if (typeof opts.onResult === "function") opts.onResult(result);
+					if (isMatch === false) {
+						result.isMatch = false;
+						return returnObject ? result : false;
+					}
+					if (isIgnored(input)) {
+						if (typeof opts.onIgnore === "function") opts.onIgnore(result);
+						result.isMatch = false;
+						return returnObject ? result : false;
+					}
+					if (typeof opts.onMatch === "function") opts.onMatch(result);
+					return returnObject ? result : true;
+				};
+				if (returnState) matcher.state = state;
+				return matcher;
+			};
+			/**
+			* Test `input` with the given `regex`. This is used by the main
+			* `picomatch()` function to test the input string.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* // picomatch.test(input, regex[, options]);
+			*
+			* console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+			* // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+			* ```
+			* @param {String} `input` String to test.
+			* @param {RegExp} `regex`
+			* @return {Object} Returns an object with matching info.
+			* @api public
+			*/
+			picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+				if (typeof input !== "string") throw new TypeError("Expected input to be a string");
+				if (input === "") return {
+					isMatch: false,
+					output: ""
+				};
+				const opts = options || {};
+				const format = opts.format || (posix ? utils.toPosixSlashes : null);
+				let match = input === glob;
+				let output = match && format ? format(input) : input;
+				if (match === false) {
+					output = format ? format(input) : input;
+					match = output === glob;
+				}
+				if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch.matchBase(input, regex, options, posix);
+				else match = regex.exec(output);
+				return {
+					isMatch: Boolean(match),
+					match,
+					output
+				};
+			};
+			/**
+			* Match the basename of a filepath.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* // picomatch.matchBase(input, glob[, options]);
+			* console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+			* ```
+			* @param {String} `input` String to test.
+			* @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+			* @return {Boolean}
+			* @api public
+			*/
+			picomatch.matchBase = (input, glob, options) => {
+				return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input));
+			};
+			/**
+			* Returns true if **any** of the given glob `patterns` match the specified `string`.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* // picomatch.isMatch(string, patterns[, options]);
+			*
+			* console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+			* console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+			* ```
+			* @param {String|Array} str The string to test.
+			* @param {String|Array} patterns One or more glob patterns to use for matching.
+			* @param {Object} [options] See available [options](#options).
+			* @return {Boolean} Returns true if any patterns match `str`
+			* @api public
+			*/
+			picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+			/**
+			* Parse a glob pattern to create the source string for a regular
+			* expression.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* const result = picomatch.parse(pattern[, options]);
+			* ```
+			* @param {String} `pattern`
+			* @param {Object} `options`
+			* @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+			* @api public
+			*/
+			picomatch.parse = (pattern, options) => {
+				if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
+				return parse(pattern, {
+					...options,
+					fastpaths: false
+				});
+			};
+			/**
+			* Scan a glob pattern to separate the pattern into segments.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* // picomatch.scan(input[, options]);
+			*
+			* const result = picomatch.scan('!./foo/*.js');
+			* console.log(result);
+			* { prefix: '!./',
+			*   input: '!./foo/*.js',
+			*   start: 3,
+			*   base: 'foo',
+			*   glob: '*.js',
+			*   isBrace: false,
+			*   isBracket: false,
+			*   isGlob: true,
+			*   isExtglob: false,
+			*   isGlobstar: false,
+			*   negated: true }
+			* ```
+			* @param {String} `input` Glob pattern to scan.
+			* @param {Object} `options`
+			* @return {Object} Returns an object with
+			* @api public
+			*/
+			picomatch.scan = (input, options) => scan(input, options);
+			/**
+			* Compile a regular expression from the `state` object returned by the
+			* [parse()](#parse) method.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* const state = picomatch.parse('*.js');
+			* // picomatch.compileRe(state[, options]);
+			*
+			* console.log(picomatch.compileRe(state));
+			* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+			* ```
+			* @param {Object} `state`
+			* @param {Object} `options`
+			* @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+			* @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+			* @return {RegExp}
+			* @api public
+			*/
+			picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+				if (returnOutput === true) return state.output;
+				const opts = options || {};
+				const prepend = opts.contains ? "" : "^";
+				const append = opts.contains ? "" : "$";
+				let source = `${prepend}(?:${state.output})${append}`;
+				if (state && state.negated === true) source = `^(?!${source}).*$`;
+				const regex = picomatch.toRegex(source, options);
+				if (returnState === true) regex.state = state;
+				return regex;
+			};
+			/**
+			* Create a regular expression from a parsed glob pattern.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* // picomatch.makeRe(state[, options]);
+			*
+			* const result = picomatch.makeRe('*.js');
+			* console.log(result);
+			* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+			* ```
+			* @param {String} `state` The object returned from the `.parse` method.
+			* @param {Object} `options`
+			* @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+			* @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+			* @return {RegExp} Returns a regex created from the given pattern.
+			* @api public
+			*/
+			picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+				if (!input || typeof input !== "string") throw new TypeError("Expected a non-empty string");
+				let parsed = {
+					negated: false,
+					fastpaths: true
+				};
+				if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) parsed.output = parse.fastpaths(input, options);
+				if (!parsed.output) parsed = parse(input, options);
+				return picomatch.compileRe(parsed, options, returnOutput, returnState);
+			};
+			/**
+			* Create a regular expression from the given regex source string.
+			*
+			* ```js
+			* const picomatch = require('picomatch');
+			* // picomatch.toRegex(source[, options]);
+			*
+			* const { output } = picomatch.parse('*.js');
+			* console.log(picomatch.toRegex(output));
+			* //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+			* ```
+			* @param {String} `source` Regular expression source string.
+			* @param {Object} `options`
+			* @return {RegExp}
+			* @api public
+			*/
+			picomatch.toRegex = (source, options) => {
+				try {
+					const opts = options || {};
+					return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+				} catch (err) {
+					if (options && options.debug === true) throw err;
+					return /$^/;
+				}
+			};
+			/**
+			* Picomatch constants.
+			* @return {Object}
+			*/
+			picomatch.constants = constants;
+			/**
+			* Expose "picomatch"
+			*/
+			module.exports = picomatch;
+		}));
+		//#endregion
+		//#region lib/types/client/tab-registry.js
+		var import_posix = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+			module.exports = require_picomatch();
+		})))(), 1);
+		/** Rank of each band, highest first. */
+		const RANKS = {
+			extension: 3,
+			builtin: 2,
+			fallback: 1
+		};
+		/** The band a definition that names none is in. */
+		const DEFAULT_BAND = "extension";
+		/**
+		* Whether a band may join a held kind: an `extension` and a `builtin` pair up
+		* once, and a `fallback` shares its kind with nothing.
+		*/
+		function coexists(slot, band) {
+			return band !== "fallback" && slot.inForce.band !== "fallback" && slot.inForce.band !== band && slot.shadowed === void 0;
+		}
+		/**
+		* The address's URI path: what a pattern with no scheme separator matches
+		* against. `dsh-resource://file/session/s1/home/me/b.md` gives `/session/s1/home/me/b.md`;
+		* `sidebar://guide` gives `''`; an address that is not a URI gives nothing.
+		*/
+		function pathOf(address) {
+			try {
+				return new URL(address).pathname;
+			} catch {
+				return;
+			}
+		}
+		/** Compile one declared pattern into the test the router runs. */
+		function matcherFor(pattern) {
+			const whole = pattern.includes(":");
+			const match = (0, import_posix.default)(pattern, {
+				nocase: true,
+				dot: true,
+				...whole ? {} : { basename: true }
+			});
+			return (address) => {
+				if (whole) return match(address);
+				const path = pathOf(address);
+				return path !== void 0 && match(path);
+			};
+		}
+		/**
+		* The registered tab types.
+		*
+		* Registration order is part of the contract: it breaks ties between types that
+		* recognize an address equally well.
+		*/
+		var SidebarRightTabRegistry = class {
+			ctx;
+			kinds = /* @__PURE__ */ new Map();
+			ids = /* @__PURE__ */ new Set();
+			listeners = /* @__PURE__ */ new Set();
+			registrations = 0;
+			cached = [];
+			guideEntries = [];
+			/** @param ctx - Context whose effects own the contributed types. */
+			constructor(ctx) {
+				this.ctx = ctx;
+			}
+			/**
+			* Register one tab type for the caller's lifetime.
+			*
+			* The caller holds the returned disposer inside its own `ctx.effect`, so a
+			* type's registration lives exactly as long as the plugin that contributed it.
+			* An `extension` may register a kind a `builtin` already holds and takes it
+			* over until it unregisters; a second registration in the same band, or any
+			* registration meeting a `fallback` of the same kind, is a wiring mistake, and
+			* so is an `id` already in use.
+			* @param definition - the contributed type.
+			* @returns idempotent disposer.
+			* @throws when the id is taken, or the kind is already registered in a way this one cannot coexist with.
+			*/
+			register(definition) {
+				const { id, kind } = definition;
+				const band = definition.priority ?? DEFAULT_BAND;
+				if (this.ids.has(id)) throw new Error(`sidebarRight: tab type id "${id}" is already registered`);
+				const held = this.kinds.get(kind);
+				if (held !== void 0 && !coexists(held, band)) throw new Error(`sidebarRight: tab kind "${kind}" is already registered (${held.inForce.band})`);
+				this.registrations += 1;
+				const entry = {
+					definition,
+					band,
+					matchers: (definition.patterns ?? []).map((pattern) => ({
+						pattern,
+						test: matcherFor(pattern)
+					})),
+					order: this.registrations
+				};
+				const dispose = this.ctx.effect(() => {
+					this.ids.add(id);
+					const slot = this.enter(kind, entry);
+					this.refresh();
+					return () => {
+						this.ids.delete(id);
+						this.leave(kind, slot, entry);
+						this.refresh();
+					};
+				}, `sidebarRight.tabs.register(${JSON.stringify(id)})`);
+				return () => {
+					dispose();
+				};
+			}
+			/** Add a registration to its kind's slot, the higher band in force; `coexists` has already admitted it. */
+			enter(kind, entry) {
+				const held = this.kinds.get(kind);
+				if (held === void 0) {
+					const slot = {
+						inForce: entry,
+						shadowed: void 0
+					};
+					this.kinds.set(kind, slot);
+					return slot;
+				}
+				if (RANKS[entry.band] > RANKS[held.inForce.band]) {
+					held.shadowed = held.inForce;
+					held.inForce = entry;
+				} else held.shadowed = entry;
+				return held;
+			}
+			/** Remove a registration from its kind's slot: a shadowed builtin resumes, and an emptied kind is freed. */
+			leave(kind, slot, entry) {
+				if (slot.inForce !== entry) slot.shadowed = void 0;
+				else if (slot.shadowed === void 0) this.kinds.delete(kind);
+				else {
+					slot.inForce = slot.shadowed;
+					slot.shadowed = void 0;
+				}
+			}
+			/** Every kind's registration in force, in registration order. */
+			active() {
+				return [...this.kinds.values()].map((slot) => slot.inForce).sort((left, right) => left.order - right.order);
+			}
+			/**
+			* Registered types in registration order.
+			* @returns reference-stable entries.
+			*/
+			entries() {
+				return this.cached;
+			}
+			/**
+			* Every type in force's guide entries, in `order`, each naming the kind it opens.
+			* @returns reference-stable entries.
+			*/
+			guide() {
+				return this.guideEntries;
+			}
+			/**
+			* The type in force for a kind.
+			* @param kind - the type discriminator.
+			* @returns the type, or `undefined` when nothing registered it.
+			*/
+			get(kind) {
+				return this.kinds.get(kind)?.inForce.definition;
+			}
+			/**
+			* Every type that would open an address, best first.
+			*
+			* Ranked by priority band, then by the length of the pattern that matched,
+			* then by registration order. Types whose `canOpen` vetoes are absent.
+			* @param address - the address a caller wants opened.
+			* @returns the ranked types; empty when nothing recognizes the address.
+			*/
+			candidates(address) {
+				const ranked = [];
+				for (const { definition, band, matchers, order } of this.active()) {
+					let length = -1;
+					for (const matcher of matchers) if (matcher.test(address) && matcher.pattern.length > length) length = matcher.pattern.length;
+					if (length < 0) continue;
+					if (definition.canOpen !== void 0 && !definition.canOpen(address)) continue;
+					ranked.push({
+						definition,
+						rank: RANKS[band],
+						length,
+						order
+					});
+				}
+				ranked.sort((left, right) => right.rank - left.rank || right.length - left.length || left.order - right.order);
+				return ranked.map((entry) => entry.definition);
+			}
+			/**
+			* Decide which type opens an address, and as what.
+			*
+			* Without `kind`, the best candidate wins. With `kind`, that type opens the
+			* address if its `canOpen` agrees — its globs are not consulted, because
+			* naming the type IS the decision.
+			*
+			* An address no type will open is a wiring mistake, not a user error, so this
+			* throws rather than reporting absence.
+			* @param address - the address a caller wants opened.
+			* @param kind - a type named by the caller, overriding the ranking.
+			* @returns the claiming type and the record to open.
+			*/
+			claim(address, kind) {
+				if (kind !== void 0) {
+					const definition = this.get(kind);
+					if (definition === void 0) throw new Error(`sidebarRight: no tab type is registered as "${kind}"`);
+					if (definition.canOpen !== void 0 && !definition.canOpen(address)) throw new Error(`sidebarRight: tab type "${kind}" refuses "${address}"`);
+					return {
+						kind,
+						contentId: address,
+						title: definition.title(address)
+					};
+				}
+				const [chosen] = this.candidates(address);
+				if (chosen === void 0) throw new Error(`sidebarRight: no registered tab type claims "${address}"`);
+				return {
+					kind: chosen.kind,
+					contentId: address,
+					title: chosen.title(address)
+				};
+			}
+			/**
+			* Observe low-frequency registry changes.
+			* @param listener - synchronous invalidation callback.
+			* @returns unsubscribe callback.
+			*/
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			}
+			refresh() {
+				this.cached = this.active().map((entry) => entry.definition);
+				this.guideEntries = this.cached.flatMap((definition) => (definition.guide ?? []).map((entry) => ({
+					...entry,
+					kind: definition.kind
+				}))).sort((left, right) => left.order - right.order);
+				(0, _deepseek_ai_dsh_client_store.notifySubscribers)(this.listeners, "[ui-sidebar-right] tab registry");
+			}
+		};
+		//#endregion
+		//#region lib/types/client/stores.js
+		/**
+		* The store shell over the docking kit: one surface per session, held as plain
+		* data so the kit's pure functions are the only thing that ever computes a
+		* layout.
+		*
+		* Every action follows the same steps — mint the ids the intent needs, ask the
+		* kit's planner what operations carry it out, let the settle planner keep every
+		* pane populated, record it all as one history entry — and then assigns the
+		* session's whole surface back in one go. Nothing here reaches into a draft to
+		* edit a layout in place, which is what keeps the kit testable without a store
+		* and keeps snapshot identity honest.
+		*
+		* The settle step is this product's rule, not the kit's: a docked pane never
+		* stays empty, and the last pane reseeds the guide tab, so there is always at
+		* least one tab to look at.
+		*
+		* A focus that changes nothing — a tab already active in its already-active
+		* pane, a pane already active — plans nothing and records nothing, whoever
+		* asks: the kit's chip click and `ctx.sidebarRight.focus` alike.
+		*
+		* So is the guide's uniqueness: a pane holds at most one guide tab. Opening the
+		* guide into a pane that has one focuses it, and a guide dragged, dropped, or
+		* docked into such a pane merges into it — the arriving guide closes and the
+		* pane's own is focused. The kit plans none of this; it is decided here before
+		* its planners run.
+		*/
+		/** A mint that counts, so the surface can carry its position forward. */
+		function counting(from) {
+			let counter = from;
+			const mint = ((prefix) => {
+				counter += 1;
+				return `${prefix}${counter}`;
+			});
+			return {
+				mint,
+				used: () => counter
+			};
+		}
+		/**
+		* The surface a session starts with: collapsed, one pane, one guide tab.
+		* @param seedTitle - the guide type's display name at mint time.
+		* @returns the initial surface.
+		*/
+		function createSurface(seedTitle) {
+			const counter = counting(0);
+			return {
+				layout: (0, _deepseek_ai_dsh_client_ui_dockkit.createInitialState)({ next: counter.mint }, (id) => makeGuideTab(id, seedTitle())),
+				history: _deepseek_ai_dsh_client_ui_dockkit.EMPTY_HISTORY,
+				minted: counter.used()
+			};
+		}
+		/** The guide tab a pane holds, if any. */
+		function paneGuide(state, paneId) {
+			return (0, _deepseek_ai_dsh_client_ui_dockkit.findPaneContentTab)(state, paneId, pageAddress(GUIDE_KIND), GUIDE_KIND);
+		}
+		/** Whether a tab is the guide, which a pane holds at most once and which is therefore never copied. */
+		function isGuide(state, tabId) {
+			return state.tabs[tabId]?.kind === GUIDE_KIND;
+		}
+		/** Focus a tab: nothing to plan while it is its pane's active tab and its pane is the active one. */
+		function planFocusTab(state, tabId) {
+			const pane = (0, _deepseek_ai_dsh_client_ui_dockkit.findTabPane)(state, tabId);
+			return pane.activeTabId === tabId && state.activePaneId === pane.id ? [] : [{
+				type: "focusTab",
+				tabId
+			}];
+		}
+		/** Focus a pane: nothing to plan while it is the active one. */
+		function planFocusPane(state, paneId) {
+			return state.activePaneId === paneId ? [] : [{
+				type: "focusPane",
+				paneId
+			}];
+		}
+		/**
+		* Plan a tab's arrival in a docked pane: a guide arriving where one already is
+		* merges into it, anything else plans as the kit does.
+		* @param state - current layout.
+		* @param tabId - the arriving tab.
+		* @param toPaneId - the pane it arrives in.
+		* @param otherwise - the kit's plan for the move.
+		* @returns the operations.
+		*/
+		function arriving(state, tabId, toPaneId, otherwise) {
+			if (!isGuide(state, tabId)) return otherwise();
+			const existing = paneGuide(state, toPaneId);
+			if (existing === void 0 || existing === tabId) return otherwise();
+			return [{
+				type: "closeTab",
+				tabId
+			}, {
+				type: "focusTab",
+				tabId: existing
+			}];
+		}
+		/**
+		* Run one planner against a surface, settle what it left behind, and record the
+		* whole intent as one history entry.
+		* @param surface - the session's current surface.
+		* @param plan - the kit planner to consult.
+		* @param seedTitle - the guide type's display name, for a reseeded root pane.
+		* @returns the next surface, or the same one when the intent changes nothing.
+		*/
+		function advance(surface, plan, seedTitle) {
+			const counter = counting(surface.minted);
+			const planned = plan(surface.layout, counter.mint);
+			if (planned.length === 0) return surface;
+			const settled = (0, _deepseek_ai_dsh_client_ui_dockkit.planSettle)((0, _deepseek_ai_dsh_client_ui_dockkit.replay)(surface.layout, planned), counter.mint, (id) => makeGuideTab(id, seedTitle()));
+			const stepped = (0, _deepseek_ai_dsh_client_ui_dockkit.record)(surface.history, surface.layout, [...planned, ...settled]);
+			return {
+				layout: stepped.state,
+				history: stepped.history,
+				minted: counter.used()
+			};
+		}
+		/**
+		* Replace one session's surface, leaving every other session by reference.
+		*
+		* A session with no surface yet gets its initial one even when the intent
+		* changes nothing: materializing is itself the change.
+		*/
+		function seat(state, sessionId, seedTitle, next) {
+			const existing = state.bySession[sessionId];
+			const updated = next(existing ?? createSurface(seedTitle));
+			return updated === existing ? state.bySession : {
+				...state.bySession,
+				[sessionId]: updated
+			};
+		}
+		/** Step a surface through the history in one direction. */
+		function stepped(surface, step) {
+			const moved = step(surface.history, surface.layout);
+			return moved === void 0 ? surface : {
+				...surface,
+				layout: moved.state,
+				history: moved.history
+			};
+		}
+		/**
+		* Create the Sidebar store handle.
+		*
+		* The seed title arrives as a thunk rather than a string: a pane is seeded
+		* whenever one is created, which can be long after the store was built and in a
+		* language the user has since changed to.
+		* @param seedTitle - the guide type's display name, read at each mint.
+		* @returns the handle (spec, type, identity, and factory in one).
+		*/
+		function createSidebarRightStore(seedTitle) {
+			return (0, _deepseek_ai_dsh_client_store.defineStore)({
+				init: () => ({ bySession: {} }),
+				actions: {
+					open: (d, sessionId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (surface) => surface);
+					},
+					setExpanded: (d, sessionId, expanded) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => (0, _deepseek_ai_dsh_client_ui_dockkit.planSetExpanded)(state, expanded), seedTitle));
+					},
+					toggleExpanded: (d, sessionId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => (0, _deepseek_ai_dsh_client_ui_dockkit.planSetExpanded)(state, !state.expanded), seedTitle));
+					},
+					setMode: (d, sessionId, mode) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => (0, _deepseek_ai_dsh_client_ui_dockkit.planSetMode)(state, mode), seedTitle));
+					},
+					splitPane: (d, sessionId, paneId, settled) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => {
+							const next = advance(s, (state, mint) => (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(state).length >= 2 ? [] : (0, _deepseek_ai_dsh_client_ui_dockkit.planSplitPane)(state, mint, paneId, (id) => makeGuideTab(id, seedTitle())), seedTitle);
+							if (settled !== void 0 && next !== s) {
+								const before = new Set((0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(s.layout));
+								for (const id of (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(next.layout)) if (!before.has(id)) settled(id);
+							}
+							return next;
+						});
+					},
+					openContent: (d, sessionId, intent, settled) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state, mint) => {
+							const { kind, contentId, title, replaceTab: replace } = intent;
+							const ops = [...(0, _deepseek_ai_dsh_client_ui_dockkit.planSetExpanded)(state, true)];
+							const replaced = replace === void 0 ? void 0 : (0, _deepseek_ai_dsh_client_ui_dockkit.findTabPane)(state, replace);
+							const lent = replace !== void 0 && replaced !== void 0 && replaced.host === "dock" ? replaced : void 0;
+							const paneId = lent?.id ?? intent.paneId;
+							const index = lent === void 0 || replace === void 0 ? void 0 : lent.tabs.indexOf(replace);
+							const held = kind === "guide" ? paneGuide(state, paneId ?? (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(state)) : void 0;
+							const planned = held !== void 0 ? {
+								ops: [{
+									type: "focusTab",
+									tabId: held
+								}],
+								tabId: held
+							} : (0, _deepseek_ai_dsh_client_ui_dockkit.planOpenContent)(state, mint, {
+								kind,
+								contentId,
+								title,
+								...paneId === void 0 ? {} : { paneId },
+								...index === void 0 ? {} : { index },
+								...intent.revealIfOpened === void 0 ? {} : { revealIfOpened: intent.revealIfOpened }
+							});
+							ops.push(...planned.ops);
+							if (replace !== void 0 && replace !== planned.tabId) ops.push({
+								type: "closeTab",
+								tabId: replace
+							});
+							settled(planned.tabId);
+							return ops;
+						}, seedTitle));
+					},
+					duplicateTab: (d, sessionId, tabId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state, mint) => isGuide(state, tabId) ? [] : (0, _deepseek_ai_dsh_client_ui_dockkit.planDuplicateTab)(state, mint, tabId).ops, seedTitle));
+					},
+					closeTab: (d, sessionId, tabId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => state.tabs[tabId] === void 0 ? [] : [{
+							type: "closeTab",
+							tabId
+						}], seedTitle));
+					},
+					focusTab: (d, sessionId, tabId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => planFocusTab(state, tabId), seedTitle));
+					},
+					focusPane: (d, sessionId, paneId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => planFocusPane(state, paneId), seedTitle));
+					},
+					placeTab: (d, sessionId, tabId, toPaneId, index) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => arriving(state, tabId, toPaneId, () => (0, _deepseek_ai_dsh_client_ui_dockkit.planPlaceTab)(state, tabId, toPaneId, index)), seedTitle));
+					},
+					dropTab: (d, sessionId, tabId, paneId, zone) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state, mint) => {
+							if (zone === "top" || zone === "bottom") return [];
+							if (zone !== "center" && (0, _deepseek_ai_dsh_client_ui_dockkit.dockPaneIds)(state).length >= 2) return [];
+							const plan = () => (0, _deepseek_ai_dsh_client_ui_dockkit.planDropTab)(state, mint, tabId, paneId, zone);
+							return zone === "center" ? arriving(state, tabId, paneId, plan) : plan();
+						}, seedTitle));
+					},
+					floatTab: (d, sessionId, tabId, rect) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state, mint) => (0, _deepseek_ai_dsh_client_ui_dockkit.planFloatTab)(state, mint, tabId, rect).ops, seedTitle));
+					},
+					unfloatPane: (d, sessionId, paneId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, (state) => {
+							const guide = paneGuide(state, paneId);
+							const plan = () => (0, _deepseek_ai_dsh_client_ui_dockkit.planUnfloatPane)(state, paneId);
+							return guide === void 0 ? plan() : arriving(state, guide, (0, _deepseek_ai_dsh_client_ui_dockkit.activeDockPaneId)(state), plan);
+						}, seedTitle));
+					},
+					moveFloat: (d, sessionId, paneId, x, y) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, () => [{
+							type: "moveFloat",
+							paneId,
+							x,
+							y
+						}], seedTitle));
+					},
+					resizeFloat: (d, sessionId, paneId, rect) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, () => [{
+							type: "resizeFloat",
+							paneId,
+							rect
+						}], seedTitle));
+					},
+					resizeSplit: (d, sessionId, splitId, sizes) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => advance(s, () => (0, _deepseek_ai_dsh_client_ui_dockkit.planResizeSplit)(splitId, sizes, .2), seedTitle));
+					},
+					undo: (d, sessionId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => stepped(s, _deepseek_ai_dsh_client_ui_dockkit.stepBack));
+					},
+					redo: (d, sessionId) => {
+						d.bySession = seat(d, sessionId, seedTitle, (s) => stepped(s, _deepseek_ai_dsh_client_ui_dockkit.stepForward));
+					}
+				}
+			});
+		}
+		//#endregion
+		//#region lib/types/client/locales.js
+		/**
+		* `sidebarRight` namespace dictionaries.
+		*
+		* Everything a user reads in this column is here, including the strings handed
+		* to the docking kit — the kit renders no copy of its own, so its whole
+		* vocabulary is this package's to own and translate.
+		*/
+		/** Simplified Chinese dictionary and key-set source of truth. */
+		const zh = {
+			"chrome.expand": "展开侧栏",
+			"chrome.collapse": "收起侧栏",
+			"chrome.toFullscreen": "全屏显示侧栏",
+			"chrome.exitFullscreen": "退出侧栏全屏",
+			"dock.emptyPane": "空面板",
+			"dock.splitPane": "向右分栏",
+			"dock.splitPaneDisabled": "已达两格上限",
+			"dock.splitPaneNarrow": "栏宽不足，拖宽侧栏后再分栏",
+			"dock.closeTab": "关闭",
+			"dock.addTab": "新标签页",
+			"dock.dockFloat": "收回到侧栏",
+			"dock.closeFloat": "关闭",
+			"tab.guide.title": "开始",
+			"tab.unavailable": "这类内容还没有可用的查看方式。",
+			"guide.lead": "侧栏用来放你想一直看着的东西。",
+			"guide.body": "会话里的文件和产物会开在这一栏，也可以从下面的入口打开。"
+		};
+		/** English dictionary, checked against the Chinese key set. */
+		const en = {
+			"chrome.expand": "Open the sidebar",
+			"chrome.collapse": "Close the sidebar",
+			"chrome.toFullscreen": "Show the sidebar fullscreen",
+			"chrome.exitFullscreen": "Exit sidebar fullscreen",
+			"dock.emptyPane": "Empty pane",
+			"dock.splitPane": "Split to the right",
+			"dock.splitPaneDisabled": "Two panes is the limit",
+			"dock.splitPaneNarrow": "Not enough width to split; widen the sidebar",
+			"dock.closeTab": "Close",
+			"dock.addTab": "New tab",
+			"dock.dockFloat": "Send back to the sidebar",
+			"dock.closeFloat": "Close",
+			"tab.guide.title": "Start",
+			"tab.unavailable": "Nothing here can view this kind of content yet.",
+			"guide.lead": "The sidebar holds what you want to keep looking at.",
+			"guide.body": "Files and artifacts from the conversation open in this column; the entries below open more."
+		};
+		//#endregion
+		//#region lib/types/client/tabs/guide/definition.js
+		/** The shipped guide implementation's identity: the key its body registers under. */
+		const GUIDE_ID = "@deepseek-ai/dsh-client-ui-sidebar-right/guide";
+		/**
+		* The guide type's registry definition.
+		*
+		* A page type: it recognizes no resource address, because a guide views
+		* nothing, and is opened by kind; `builtin` is the ordinary band for a type
+		* shipped here.
+		* @param t - namespace-bound translate, read fresh on every title call.
+		* @returns the definition to register.
+		*/
+		function guideDefinition(t) {
+			return {
+				id: GUIDE_ID,
+				kind: GUIDE_KIND,
+				priority: "builtin",
+				title: () => t("tab.guide.title")
+			};
+		}
+		//#endregion
+		//#region lib/types/client/tab-info.js
+		/** Slot-owned tab information derived from framework-bound store and navigation hooks. */
+		/**
+		* Bind a tab occurrence without subscribing or creating records during factory evaluation.
+		* @param standard - framework session identity.
+		* @param context - stable record lifetime and framework-bound readers.
+		* @returns the tab information hook.
+		*/
+		const tabInfoFactory = (standard, context) => {
+			const { sessionId } = standard;
+			const { tabId, title, fullscreen, signal, actions, useStore, useTabNavigation } = context;
+			return function useTabInfo() {
+				const layout = useStore((state) => state.bySession[sessionId]?.layout);
+				const navigation = useTabNavigation(tabId);
+				return (0, react.useMemo)(() => {
+					const tab = layout?.tabs[tabId];
+					if (layout === void 0 || tab === void 0 || navigation === void 0) throw new Error(`sidebarRight: tab "${tabId}" is not committed in session "${sessionId}"`);
+					const pane = (0, _deepseek_ai_dsh_client_ui_dockkit.findTabPane)(layout, tabId);
+					return {
+						sidebar: {
+							expanded: layout.expanded,
+							fullscreen
+						},
+						panel: { id: pane.id },
+						tab: {
+							...tab,
+							visible: pane.host === "float" || layout.expanded && (title || pane.activeTabId === tabId),
+							navigation,
+							signal,
+							actions
+						}
+					};
+				}, [
+					layout,
+					navigation,
+					tabId,
+					title,
+					fullscreen,
+					signal,
+					actions
+				]);
+			};
+		};
+		/**
+		* Forward the framework-bound tab hook to a guide replacement.
+		* @param _standard - the guide's framework standard props.
+		* @param useTabInfo - the enclosing tab's framework-bound reader.
+		* @returns the same reader for the replacement.
+		*/
+		const guideTabInfoFactory = (_standard, useTabInfo) => useTabInfo;
+		//#endregion
+		//#region lib/types/client/index.js
+		/** This package's copy namespace. */
+		const NS = "sidebarRight";
+		/** Required browser services: the slot registry, the frame's panel actions, copy, and the resource model. */
+		const inject = [
+			"slots",
+			"layout",
+			"locale",
+			"resources"
+		];
+		/**
+		* Client plugin body: provide the registry and the navigation face, register the
+		* panel seat and the rail seat over one store with their extension children, and
+		* register the guide type through the same public two-stage path any other type
+		* uses.
+		* @param ctx - client root context carrying the slot registry, the frame's face, and copy.
+		*/
+		function apply(ctx) {
+			const t = ctx.locale.bind(NS);
+			const tabs = new SidebarRightTabRegistry(ctx);
+			const { controller, adopt } = createSidebarRightController(tabs, (address, signal) => {
+				ctx.resources.pin(address, signal);
+			});
+			const disposeRegistry = ctx.reflect.provide("sidebarRightTabs", tabs);
+			const disposeService = ctx.reflect.provide("sidebarRight", controller);
+			ctx.effect(() => () => {
+				controller.tabDomain.dispose();
+				disposeService();
+				disposeRegistry();
+			}, "ui-sidebar-right: service faces");
+			ctx.effect(() => ctx.locale.register(NS, {
+				zh,
+				en
+			}), "ui-sidebar-right: dictionaries");
+			ctx.effect(() => {
+				const handle = createSidebarRightStore(() => t("tab.guide.title"));
+				const adoptions = [];
+				const store = {
+					...handle,
+					create: (scopeKey) => {
+						const instance = handle.create(scopeKey);
+						if (scopeKey !== void 0) adoptions.push(adopt(scopeKey, instance));
+						return instance;
+					}
+				};
+				const layout = ctx.layout;
+				const injected = {
+					syncPresentation({ shown, track, fullscreen }) {
+						if (shown) layout.openRightbar(track, fullscreen);
+						else layout.closeRightbar();
+					},
+					bindService: (binding) => controller.bind(binding),
+					openTab: (kind, options) => {
+						controller.openTab(kind, options);
+					},
+					hooks: { tabTypes: {
+						subscribe: (listener) => tabs.subscribe(listener),
+						getSnapshot: () => tabs.entries()
+					} }
+				};
+				const disposeTypes = [tabs.register(guideDefinition(t))];
+				const disposeSeat = ctx.slots.inject("rightbar", () => ctx.slots.register({
+					name: "rightbar",
+					locale: NS,
+					children: {
+						"sidebar.right.pane.tab": {
+							kind: "keyed",
+							scope: "session",
+							inject: { hooks: { tabInfo: tabInfoFactory } }
+						},
+						"sidebar.right.pane.tab.title": {
+							kind: "keyed",
+							scope: "session",
+							inject: { hooks: { tabInfo: tabInfoFactory } }
+						},
+						"sidebar.right.tab.menu.item": {
+							kind: "list",
+							scope: "session"
+						}
+					},
+					store,
+					inject: (sessionId) => ({
+						...injected,
+						keyedHooks: { tabNavigation: (key) => controller.tabDomain.occurrence(sessionId, { id: key }).navigation },
+						occurrence: (tab) => controller.tabDomain.occurrence(sessionId, tab)
+					})
+				}, RightbarSeat));
+				const disposeExpand = ctx.slots.inject("conversation.session.header.corner", () => ctx.slots.register({
+					name: "conversation.session.header.corner",
+					locale: NS,
+					store
+				}, ExpandButton));
+				const guideInjected = { hooks: { guideEntries: {
+					subscribe: (listener) => tabs.subscribe(listener),
+					getSnapshot: () => tabs.guide()
+				} } };
+				const disposeGuide = ctx.slots.inject("sidebar.right.pane.tab", () => ctx.slots.register({
+					name: "sidebar.right.pane.tab",
+					key: GUIDE_ID,
+					locale: NS,
+					children: { "sidebar.right.tab.guide": {
+						kind: "chain",
+						scope: "session",
+						inject: { hooks: { tabInfo: guideTabInfoFactory } }
+					} },
+					inject: () => guideInjected
+				}, GuideBody));
+				return () => {
+					disposeGuide();
+					disposeExpand();
+					disposeSeat();
+					for (const dispose of disposeTypes.reverse()) dispose();
+					for (const release of adoptions) release();
+				};
+			}, "ui-sidebar-right: seats and shipped tab type");
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map