@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/preview/_chunks/runtime-DrTjJkPY.js

@@ -0,0 +1,3872 @@
+import { n as __esmMin, r as __exportAll } from "./runtime-BdGkqNEt.js";
+import { at as init_dist, ct as stringify, it as invariant, lt as dedent, ot as isJSON, rt as init_tiny_invariant, st as parse, ut as init_esm } from "./runtime-BZSnICCg.js";
+import { n as init_storybook_error, t as StorybookError } from "./runtime-BwSxqk3t.js";
+import { A as matchesHostname, M as init_universal_store, O as LOOPBACK_HOSTNAMES, f as init_preview$7, h as preview_default$6, j as UniversalStore, k as init_local_hosts, m as init_preview$6, p as preview_default$7 } from "./runtime-iXdo8CR8.js";
+import { f as require_tiny_isequal, h as scope, m as init_dist$1 } from "./runtime-BTPtVY1p.js";
+import { c as useMemo, d as ImplicitActionsDuringRendering, f as InvalidChannelPageError, l as addons$1, p as init_preview_errors, r as init_preview_api$1, s as useEffect } from "./runtime-CsV4HZPV.js";
+import { o as init_preview$8, s as preview_default$8 } from "./runtime-CxZK_Ln3.js";
+import { h as processError, m as init_error } from "./runtime-q3wt0e_N.js";
+import { n as preview_default$9, o as onMockCall, r as init_test, t as init_preview$9 } from "./runtime-DuHdxMFA.js";
+//#region src/manager-errors.ts
+var UniversalStoreFollowerTimeoutError, OpenServiceStaticSnapshotLoadError, OpenServiceStaticSnapshotInvalidError;
+function init_manager_errors() {
+	return (init_manager_errors = __esmMin((() => {
+		init_storybook_error();
+		UniversalStoreFollowerTimeoutError = class extends StorybookError {
+			constructor(followerId) {
+				super({
+					name: "UniversalStoreFollowerTimeoutError",
+					category: "MANAGER_UNIVERSAL-STORE",
+					code: 1,
+					message: `Timed out waiting for leader state for UniversalStore follower with id: '${followerId}'. Ensure a leader with the same id exists and is reachable before creating a follower.`
+				});
+			}
+		};
+		OpenServiceStaticSnapshotLoadError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceStaticSnapshotLoadError",
+					category: "MANAGER_OPEN-SERVICE",
+					code: 1,
+					message: `Failed to load open-service static snapshot "${data.logicalPath}" from "${data.url}" for "${data.serviceId}.${data.queryName}".`,
+					cause: data.cause
+				});
+				this.data = data;
+			}
+		};
+		OpenServiceStaticSnapshotInvalidError = class extends StorybookError {
+			constructor(data) {
+				super({
+					name: "OpenServiceStaticSnapshotInvalidError",
+					category: "MANAGER_OPEN-SERVICE",
+					code: 2,
+					message: `Open-service static snapshot "${data.logicalPath}" from "${data.url}" for "${data.serviceId}.${data.queryName}" must be a plain object.`
+				});
+				this.data = data;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/channels/main.ts
+var isMulti, generateRandomId, Channel;
+function init_main() {
+	return (init_main = __esmMin((() => {
+		isMulti = (args) => {
+			return args.transports !== void 0;
+		};
+		generateRandomId = () => {
+			return Math.random().toString(16).slice(2);
+		};
+		Channel = class {
+			constructor(input = {}) {
+				this.sender = generateRandomId();
+				this.events = {};
+				this.data = {};
+				this.transports = [];
+				this.isAsync = input.async || false;
+				if (isMulti(input)) {
+					this.transports = input.transports || [];
+					this.transports.forEach((t) => {
+						t.setHandler((event) => this.handleEvent(event));
+					});
+				} else this.transports = input.transport ? [input.transport] : [];
+				this.transports.forEach((t) => {
+					t.setHandler((event) => this.handleEvent(event));
+				});
+			}
+			get hasTransport() {
+				return this.transports.length > 0;
+			}
+			addListener(eventName, listener) {
+				this.events[eventName] = this.events[eventName] || [];
+				this.events[eventName].push(listener);
+			}
+			emit(eventName, ...args) {
+				const event = {
+					type: eventName,
+					args,
+					from: this.sender
+				};
+				let options = {};
+				if (args.length >= 1 && args[0] && args[0].options) options = args[0].options;
+				const handler = () => {
+					this.transports.forEach((t) => {
+						t.send(event, options);
+					});
+					this.handleEvent(event);
+				};
+				if (this.isAsync) setImmediate(handler);
+				else handler();
+			}
+			last(eventName) {
+				return this.data[eventName];
+			}
+			eventNames() {
+				return Object.keys(this.events);
+			}
+			listenerCount(eventName) {
+				const listeners = this.listeners(eventName);
+				return listeners ? listeners.length : 0;
+			}
+			listeners(eventName) {
+				return this.events[eventName] || void 0;
+			}
+			once(eventName, listener) {
+				const onceListener = this.onceListener(eventName, listener);
+				this.addListener(eventName, onceListener);
+			}
+			removeAllListeners(eventName) {
+				if (!eventName) this.events = {};
+				else if (this.events[eventName]) delete this.events[eventName];
+			}
+			removeListener(eventName, listener) {
+				const listeners = this.listeners(eventName);
+				if (listeners) this.events[eventName] = listeners.filter((l) => l !== listener);
+			}
+			on(eventName, listener) {
+				this.addListener(eventName, listener);
+			}
+			off(eventName, listener) {
+				this.removeListener(eventName, listener);
+			}
+			/**
+			* Deliver an event to local listeners without sending it to this channel's transports.
+			*/
+			receive(event) {
+				this.handleEvent(event);
+			}
+			handleEvent(event) {
+				const listeners = this.listeners(event.type);
+				if (listeners && listeners.length) listeners.forEach((fn) => {
+					fn.apply(event, event.args);
+				});
+				this.data[event.type] = event.args;
+			}
+			onceListener(eventName, listener) {
+				const onceListener = (...args) => {
+					this.removeListener(eventName, onceListener);
+					return listener(...args);
+				};
+				return onceListener;
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/client-logger/index.ts
+var client_logger_exports = /* @__PURE__ */ __exportAll({
+	deprecate: () => deprecate,
+	logger: () => logger,
+	once: () => once,
+	pretty: () => pretty
+});
+var LOGLEVEL, levels, currentLogLevelNumber, logger, logged, once, deprecate, pretty;
+function init_client_logger() {
+	return (init_client_logger = __esmMin((() => {
+		init_dist$1();
+		({LOGLEVEL} = scope);
+		levels = {
+			trace: 1,
+			debug: 2,
+			info: 3,
+			warn: 4,
+			error: 5,
+			silent: 10
+		};
+		currentLogLevelNumber = levels[LOGLEVEL] || levels.info;
+		logger = {
+			trace: (message, ...rest) => {
+				if (currentLogLevelNumber <= levels.trace) console.trace(message, ...rest);
+			},
+			debug: (message, ...rest) => {
+				if (currentLogLevelNumber <= levels.debug) console.debug(message, ...rest);
+			},
+			info: (message, ...rest) => {
+				if (currentLogLevelNumber <= levels.info) console.info(message, ...rest);
+			},
+			warn: (message, ...rest) => {
+				if (currentLogLevelNumber <= levels.warn) console.warn(message, ...rest);
+			},
+			error: (message, ...rest) => {
+				if (currentLogLevelNumber <= levels.error) console.error(message, ...rest);
+			},
+			log: (message, ...rest) => {
+				if (currentLogLevelNumber < levels.silent) console.log(message, ...rest);
+			}
+		};
+		logged = /* @__PURE__ */ new Set();
+		once = (type) => (message, ...rest) => {
+			if (logged.has(message)) return;
+			logged.add(message);
+			return logger[type](message, ...rest);
+		};
+		once.clear = () => logged.clear();
+		once.trace = once("trace");
+		once.debug = once("debug");
+		once.info = once("info");
+		once.warn = once("warn");
+		once.error = once("error");
+		once.log = once("log");
+		deprecate = once("warn");
+		pretty = (type) => (...args) => {
+			const argArray = [];
+			if (args.length) {
+				const startTagRe = /<span\s+style=(['"])([^'"]*)\1\s*>/gi;
+				const endTagRe = /<\/span>/gi;
+				let reResultArray;
+				argArray.push(args[0].replace(startTagRe, "%c").replace(endTagRe, "%c"));
+				while (reResultArray = startTagRe.exec(args[0])) {
+					argArray.push(reResultArray[2]);
+					argArray.push("");
+				}
+				for (let j = 1; j < args.length; j++) argArray.push(args[j]);
+			}
+			logger[type].apply(logger, argArray);
+		};
+		pretty.trace = pretty("trace");
+		pretty.debug = pretty("debug");
+		pretty.info = pretty("info");
+		pretty.warn = pretty("warn");
+		pretty.error = pretty("error");
+	})))();
+}
+//#endregion
+//#region src/core-events/index.ts
+var core_events_exports = /* @__PURE__ */ __exportAll({
+	AI_PROMPT_NUDGE: () => AI_PROMPT_NUDGE,
+	AI_SETUP_ANALYTICS_REQUEST: () => AI_SETUP_ANALYTICS_REQUEST,
+	AI_SETUP_ANALYTICS_RESPONSE: () => AI_SETUP_ANALYTICS_RESPONSE,
+	ARGTYPES_INFO_REQUEST: () => ARGTYPES_INFO_REQUEST,
+	ARGTYPES_INFO_RESPONSE: () => ARGTYPES_INFO_RESPONSE,
+	CHANNEL_CREATED: () => CHANNEL_CREATED,
+	CHANNEL_WS_DISCONNECT: () => CHANNEL_WS_DISCONNECT,
+	CONFIG_ERROR: () => CONFIG_ERROR,
+	CURRENT_STORY_WAS_SET: () => CURRENT_STORY_WAS_SET,
+	DOCS_PREPARED: () => DOCS_PREPARED,
+	DOCS_RENDERED: () => DOCS_RENDERED,
+	FORCE_REMOUNT: () => FORCE_REMOUNT,
+	FORCE_RE_RENDER: () => FORCE_RE_RENDER,
+	GHOST_STORIES_REQUEST: () => GHOST_STORIES_REQUEST,
+	GHOST_STORIES_RESPONSE: () => GHOST_STORIES_RESPONSE,
+	GLOBALS_UPDATED: () => GLOBALS_UPDATED,
+	MANAGER_INERT_ATTRIBUTE_CHANGED: () => MANAGER_INERT_ATTRIBUTE_CHANGED,
+	NAVIGATE_URL: () => NAVIGATE_URL,
+	OPEN_IN_EDITOR_REQUEST: () => OPEN_IN_EDITOR_REQUEST,
+	OPEN_IN_EDITOR_RESPONSE: () => OPEN_IN_EDITOR_RESPONSE,
+	PLAY_FUNCTION_THREW_EXCEPTION: () => PLAY_FUNCTION_THREW_EXCEPTION,
+	PRELOAD_ENTRIES: () => PRELOAD_ENTRIES,
+	PREVIEW_BUILDER_PROGRESS: () => PREVIEW_BUILDER_PROGRESS,
+	PREVIEW_INITIALIZED: () => PREVIEW_INITIALIZED,
+	PREVIEW_KEYDOWN: () => PREVIEW_KEYDOWN,
+	REGISTER_SUBSCRIPTION: () => REGISTER_SUBSCRIPTION,
+	REQUEST_WHATS_NEW_DATA: () => REQUEST_WHATS_NEW_DATA,
+	RESET_STORY_ARGS: () => RESET_STORY_ARGS,
+	RESULT_WHATS_NEW_DATA: () => RESULT_WHATS_NEW_DATA,
+	SAVE_STORY_REQUEST: () => SAVE_STORY_REQUEST,
+	SAVE_STORY_RESPONSE: () => SAVE_STORY_RESPONSE,
+	SELECT_STORY: () => SELECT_STORY,
+	SET_CONFIG: () => SET_CONFIG,
+	SET_CURRENT_STORY: () => SET_CURRENT_STORY,
+	SET_FILTER: () => SET_FILTER,
+	SET_GLOBALS: () => SET_GLOBALS,
+	SET_INDEX: () => SET_INDEX,
+	SET_STORIES: () => SET_STORIES,
+	SET_WHATS_NEW_CACHE: () => SET_WHATS_NEW_CACHE,
+	SHARED_STATE_CHANGED: () => SHARED_STATE_CHANGED,
+	SHARED_STATE_SET: () => SHARED_STATE_SET,
+	SHARE_ISOLATE_MODE: () => SHARE_ISOLATE_MODE,
+	SIDEBAR_FILTER_CHANGED: () => SIDEBAR_FILTER_CHANGED,
+	STORIES_COLLAPSE_ALL: () => STORIES_COLLAPSE_ALL,
+	STORIES_EXPAND_ALL: () => STORIES_EXPAND_ALL,
+	STORY_ARGS_UPDATED: () => STORY_ARGS_UPDATED,
+	STORY_CHANGED: () => STORY_CHANGED,
+	STORY_ERRORED: () => STORY_ERRORED,
+	STORY_FINISHED: () => STORY_FINISHED,
+	STORY_HOT_UPDATED: () => STORY_HOT_UPDATED,
+	STORY_INDEX_INVALIDATED: () => STORY_INDEX_INVALIDATED,
+	STORY_MISSING: () => STORY_MISSING,
+	STORY_PREPARED: () => STORY_PREPARED,
+	STORY_RENDERED: () => STORY_RENDERED,
+	STORY_RENDER_PHASE_CHANGED: () => STORY_RENDER_PHASE_CHANGED,
+	STORY_SPECIFIED: () => STORY_SPECIFIED,
+	STORY_THREW_EXCEPTION: () => STORY_THREW_EXCEPTION,
+	STORY_UNCHANGED: () => STORY_UNCHANGED,
+	TELEMETRY_ERROR: () => TELEMETRY_ERROR,
+	TOGGLE_WHATS_NEW_NOTIFICATIONS: () => TOGGLE_WHATS_NEW_NOTIFICATIONS,
+	UNHANDLED_ERRORS_WHILE_PLAYING: () => UNHANDLED_ERRORS_WHILE_PLAYING,
+	UPDATE_GLOBALS: () => UPDATE_GLOBALS,
+	UPDATE_QUERY_PARAMS: () => UPDATE_QUERY_PARAMS,
+	UPDATE_STORY_ARGS: () => UPDATE_STORY_ARGS,
+	default: () => events
+});
+var events, CHANNEL_WS_DISCONNECT, CHANNEL_CREATED, CONFIG_ERROR, CURRENT_STORY_WAS_SET, DOCS_PREPARED, DOCS_RENDERED, FORCE_RE_RENDER, FORCE_REMOUNT, GLOBALS_UPDATED, NAVIGATE_URL, PLAY_FUNCTION_THREW_EXCEPTION, UNHANDLED_ERRORS_WHILE_PLAYING, PRELOAD_ENTRIES, PREVIEW_INITIALIZED, PREVIEW_BUILDER_PROGRESS, PREVIEW_KEYDOWN, REGISTER_SUBSCRIPTION, RESET_STORY_ARGS, SELECT_STORY, SET_CONFIG, SET_CURRENT_STORY, SET_FILTER, SET_GLOBALS, SET_INDEX, SET_STORIES, SHARED_STATE_CHANGED, SHARED_STATE_SET, STORIES_COLLAPSE_ALL, STORIES_EXPAND_ALL, STORY_ARGS_UPDATED, STORY_CHANGED, STORY_ERRORED, STORY_INDEX_INVALIDATED, STORY_MISSING, STORY_PREPARED, STORY_RENDER_PHASE_CHANGED, STORY_RENDERED, STORY_FINISHED, STORY_SPECIFIED, STORY_THREW_EXCEPTION, STORY_UNCHANGED, STORY_HOT_UPDATED, UPDATE_GLOBALS, UPDATE_QUERY_PARAMS, UPDATE_STORY_ARGS, REQUEST_WHATS_NEW_DATA, RESULT_WHATS_NEW_DATA, SET_WHATS_NEW_CACHE, TOGGLE_WHATS_NEW_NOTIFICATIONS, TELEMETRY_ERROR, SAVE_STORY_REQUEST, SAVE_STORY_RESPONSE, ARGTYPES_INFO_REQUEST, ARGTYPES_INFO_RESPONSE, GHOST_STORIES_REQUEST, GHOST_STORIES_RESPONSE, AI_SETUP_ANALYTICS_RESPONSE, AI_SETUP_ANALYTICS_REQUEST, OPEN_IN_EDITOR_REQUEST, OPEN_IN_EDITOR_RESPONSE, MANAGER_INERT_ATTRIBUTE_CHANGED, SHARE_ISOLATE_MODE, AI_PROMPT_NUDGE, SIDEBAR_FILTER_CHANGED;
+function init_core_events() {
+	return (init_core_events = __esmMin((() => {
+		events = /* @__PURE__ */ function(events) {
+			events["CHANNEL_WS_DISCONNECT"] = "channelWSDisconnect";
+			events["CHANNEL_CREATED"] = "channelCreated";
+			events["CONFIG_ERROR"] = "configError";
+			events["STORY_INDEX_INVALIDATED"] = "storyIndexInvalidated";
+			events["STORY_SPECIFIED"] = "storySpecified";
+			events["SET_CONFIG"] = "setConfig";
+			events["SET_STORIES"] = "setStories";
+			events["SET_INDEX"] = "setIndex";
+			events["SET_CURRENT_STORY"] = "setCurrentStory";
+			events["CURRENT_STORY_WAS_SET"] = "currentStoryWasSet";
+			events["FORCE_RE_RENDER"] = "forceReRender";
+			events["FORCE_REMOUNT"] = "forceRemount";
+			events["PRELOAD_ENTRIES"] = "preloadStories";
+			events["STORY_PREPARED"] = "storyPrepared";
+			events["DOCS_PREPARED"] = "docsPrepared";
+			events["STORY_CHANGED"] = "storyChanged";
+			events["STORY_UNCHANGED"] = "storyUnchanged";
+			events["STORY_RENDERED"] = "storyRendered";
+			events["STORY_FINISHED"] = "storyFinished";
+			events["STORY_MISSING"] = "storyMissing";
+			events["STORY_ERRORED"] = "storyErrored";
+			events["STORY_THREW_EXCEPTION"] = "storyThrewException";
+			events["STORY_RENDER_PHASE_CHANGED"] = "storyRenderPhaseChanged";
+			events["STORY_HOT_UPDATED"] = "storyHotUpdated";
+			events["PLAY_FUNCTION_THREW_EXCEPTION"] = "playFunctionThrewException";
+			events["UNHANDLED_ERRORS_WHILE_PLAYING"] = "unhandledErrorsWhilePlaying";
+			events["UPDATE_STORY_ARGS"] = "updateStoryArgs";
+			events["STORY_ARGS_UPDATED"] = "storyArgsUpdated";
+			events["RESET_STORY_ARGS"] = "resetStoryArgs";
+			events["SET_FILTER"] = "setFilter";
+			events["SET_GLOBALS"] = "setGlobals";
+			events["UPDATE_GLOBALS"] = "updateGlobals";
+			events["GLOBALS_UPDATED"] = "globalsUpdated";
+			events["REGISTER_SUBSCRIPTION"] = "registerSubscription";
+			events["PREVIEW_INITIALIZED"] = "previewInitialized";
+			events["PREVIEW_KEYDOWN"] = "previewKeydown";
+			events["PREVIEW_BUILDER_PROGRESS"] = "preview_builder_progress";
+			events["SELECT_STORY"] = "selectStory";
+			events["STORIES_COLLAPSE_ALL"] = "storiesCollapseAll";
+			events["STORIES_EXPAND_ALL"] = "storiesExpandAll";
+			events["DOCS_RENDERED"] = "docsRendered";
+			events["SHARED_STATE_CHANGED"] = "sharedStateChanged";
+			events["SHARED_STATE_SET"] = "sharedStateSet";
+			events["NAVIGATE_URL"] = "navigateUrl";
+			events["UPDATE_QUERY_PARAMS"] = "updateQueryParams";
+			events["REQUEST_WHATS_NEW_DATA"] = "requestWhatsNewData";
+			events["RESULT_WHATS_NEW_DATA"] = "resultWhatsNewData";
+			events["SET_WHATS_NEW_CACHE"] = "setWhatsNewCache";
+			events["TOGGLE_WHATS_NEW_NOTIFICATIONS"] = "toggleWhatsNewNotifications";
+			events["TELEMETRY_ERROR"] = "telemetryError";
+			events["SAVE_STORY_REQUEST"] = "saveStoryRequest";
+			events["SAVE_STORY_RESPONSE"] = "saveStoryResponse";
+			events["ARGTYPES_INFO_REQUEST"] = "argtypesInfoRequest";
+			events["ARGTYPES_INFO_RESPONSE"] = "argtypesInfoResponse";
+			events["GHOST_STORIES_REQUEST"] = "ghostStoriesRequest";
+			events["GHOST_STORIES_RESPONSE"] = "ghostStoriesResponse";
+			events["AI_SETUP_ANALYTICS_RESPONSE"] = "aiSetupAnalyticsResponse";
+			events["AI_SETUP_ANALYTICS_REQUEST"] = "aiSetupAnalyticsRequest";
+			events["OPEN_IN_EDITOR_REQUEST"] = "openInEditorRequest";
+			events["OPEN_IN_EDITOR_RESPONSE"] = "openInEditorResponse";
+			events["MANAGER_INERT_ATTRIBUTE_CHANGED"] = "managerInertAttributeChanged";
+			events["SHARE_ISOLATE_MODE"] = "shareIsolateMode";
+			events["AI_PROMPT_NUDGE"] = "aiPromptNudge";
+			events["SIDEBAR_FILTER_CHANGED"] = "sidebarFilterChanged";
+			return events;
+		}(events || {});
+		({CHANNEL_WS_DISCONNECT, CHANNEL_CREATED, CONFIG_ERROR, CURRENT_STORY_WAS_SET, DOCS_PREPARED, DOCS_RENDERED, FORCE_RE_RENDER, FORCE_REMOUNT, GLOBALS_UPDATED, NAVIGATE_URL, PLAY_FUNCTION_THREW_EXCEPTION, UNHANDLED_ERRORS_WHILE_PLAYING, PRELOAD_ENTRIES, PREVIEW_INITIALIZED, PREVIEW_BUILDER_PROGRESS, PREVIEW_KEYDOWN, REGISTER_SUBSCRIPTION, RESET_STORY_ARGS, SELECT_STORY, SET_CONFIG, SET_CURRENT_STORY, SET_FILTER, SET_GLOBALS, SET_INDEX, SET_STORIES, SHARED_STATE_CHANGED, SHARED_STATE_SET, STORIES_COLLAPSE_ALL, STORIES_EXPAND_ALL, STORY_ARGS_UPDATED, STORY_CHANGED, STORY_ERRORED, STORY_INDEX_INVALIDATED, STORY_MISSING, STORY_PREPARED, STORY_RENDER_PHASE_CHANGED, STORY_RENDERED, STORY_FINISHED, STORY_SPECIFIED, STORY_THREW_EXCEPTION, STORY_UNCHANGED, STORY_HOT_UPDATED, UPDATE_GLOBALS, UPDATE_QUERY_PARAMS, UPDATE_STORY_ARGS, REQUEST_WHATS_NEW_DATA, RESULT_WHATS_NEW_DATA, SET_WHATS_NEW_CACHE, TOGGLE_WHATS_NEW_NOTIFICATIONS, TELEMETRY_ERROR, SAVE_STORY_REQUEST, SAVE_STORY_RESPONSE, ARGTYPES_INFO_REQUEST, ARGTYPES_INFO_RESPONSE, GHOST_STORIES_REQUEST, GHOST_STORIES_RESPONSE, AI_SETUP_ANALYTICS_RESPONSE, AI_SETUP_ANALYTICS_REQUEST, OPEN_IN_EDITOR_REQUEST, OPEN_IN_EDITOR_RESPONSE, MANAGER_INERT_ATTRIBUTE_CHANGED, SHARE_ISOLATE_MODE, AI_PROMPT_NUDGE, SIDEBAR_FILTER_CHANGED} = events);
+	})))();
+}
+//#endregion
+//#region src/channels/postmessage/getEventSourceUrl.ts
+var pickFrameByRefId, getEventSourceUrl;
+function init_getEventSourceUrl() {
+	return (init_getEventSourceUrl = __esmMin((() => {
+		init_client_logger();
+		pickFrameByRefId = (candidates, refId) => {
+			if (candidates.length === 1) return candidates[0];
+			if (candidates.length === 0 || !refId) return;
+			return candidates.find((el) => (el.getAttribute("src") ?? "").includes(`refId=${encodeURIComponent(refId)}`));
+		};
+		getEventSourceUrl = (event, refId) => {
+			const candidates = Array.from(document.querySelectorAll("iframe[data-is-storybook]")).filter((element) => {
+				try {
+					return element.contentWindow?.location.origin === event.source.location.origin && element.contentWindow?.location.pathname === event.source.location.pathname;
+				} catch {}
+				try {
+					return element.contentWindow === event.source;
+				} catch {}
+				const src = element.getAttribute("src");
+				let origin;
+				try {
+					if (!src) return false;
+					({origin} = new URL(src, document.location.toString()));
+				} catch {
+					return false;
+				}
+				return origin === event.origin;
+			});
+			const src = pickFrameByRefId(candidates, refId)?.getAttribute("src");
+			if (src) {
+				const { protocol, host, pathname } = new URL(src, document.location.toString());
+				return `${protocol}//${host}${pathname}`;
+			}
+			if (candidates.length > 1) logger.error("found multiple candidates for event source");
+			return null;
+		};
+	})))();
+}
+//#endregion
+//#region src/channels/postmessage/index.ts
+var document$2, location, KEY, CHANNEL_OPTIONS$1, defaultEventOptions, getReferrerOrigin, isOnInitialBlankDocument, getOriginValidator, PostMessageTransport;
+function init_postmessage() {
+	return (init_postmessage = __esmMin((() => {
+		init_client_logger();
+		init_core_events();
+		init_dist();
+		init_tiny_invariant();
+		init_preview_errors();
+		init_local_hosts();
+		init_getEventSourceUrl();
+		({document: document$2, location} = globalThis);
+		KEY = "storybook-channel";
+		CHANNEL_OPTIONS$1 = globalThis.CHANNEL_OPTIONS || {};
+		defaultEventOptions = { maxDepth: 25 };
+		getReferrerOrigin = () => {
+			try {
+				const origin = document$2?.referrer && new URL(document$2.referrer).origin;
+				return origin && origin !== "null" ? origin : null;
+			} catch {
+				return null;
+			}
+		};
+		isOnInitialBlankDocument = (frame) => {
+			try {
+				return frame.location.href === "about:blank";
+			} catch {
+				return false;
+			}
+		};
+		getOriginValidator = () => {
+			const own = location?.origin;
+			if (globalThis.CONFIG_TYPE !== "DEVELOPMENT" || !own || own === "null") return null;
+			return (origin) => {
+				if (origin === own) return true;
+				try {
+					return matchesHostname(new URL(origin).hostname, LOOPBACK_HOSTNAMES);
+				} catch {
+					return false;
+				}
+			};
+		};
+		PostMessageTransport = class {
+			constructor(config) {
+				this.config = config;
+				this.connected = false;
+				this.rejectedOrigins = /* @__PURE__ */ new Set();
+				this.buffer = [];
+				this.originValidator = getOriginValidator();
+				this.insecureIframeMessaging = globalThis.INSECURE_IFRAME_MESSAGING === true;
+				this.pinsTargetOrigin = globalThis.CONFIG_TYPE === "DEVELOPMENT" && !this.insecureIframeMessaging;
+				if (typeof globalThis.addEventListener === "function") globalThis.addEventListener("message", this.handleEvent.bind(this), false);
+				if (config.page !== "manager" && config.page !== "preview") throw new InvalidChannelPageError({ page: config.page });
+			}
+			setHandler(handler) {
+				this.handler = (...args) => {
+					handler.apply(this, args);
+					if (!this.connected && this.getLocalFrame().length) {
+						this.flush();
+						this.connected = true;
+					}
+				};
+			}
+			/**
+			* Sends `event` to the associated window. If the window does not yet exist the event will be
+			* stored in a buffer and sent when the window exists.
+			*
+			* @param event
+			*/
+			send(event, options) {
+				const { target, allowRegExp, allowSymbol, allowDate, allowError, allowUndefined, maxDepth, space } = options || {};
+				const eventOptions = Object.fromEntries(Object.entries({
+					allowRegExp,
+					allowSymbol,
+					allowDate,
+					allowError,
+					allowUndefined,
+					maxDepth,
+					space
+				}).filter(([k, v]) => typeof v !== "undefined"));
+				const stringifyOptions = {
+					...defaultEventOptions,
+					...CHANNEL_OPTIONS$1,
+					...eventOptions
+				};
+				const frames = this.getFrames(target);
+				const query = new URLSearchParams(location?.search || "");
+				const data = stringify({
+					key: KEY,
+					event,
+					refId: query.get("refId")
+				}, stringifyOptions);
+				if (!frames.length) return new Promise((resolve, reject) => {
+					this.buffer.push({
+						event,
+						resolve,
+						reject
+					});
+				});
+				if (this.buffer.length) this.flush();
+				frames.forEach(({ contentWindow, targetOrigin }) => {
+					if (this.config.page === "manager" && isOnInitialBlankDocument(contentWindow)) return;
+					try {
+						contentWindow.postMessage(data, this.pinsTargetOrigin ? targetOrigin : "*");
+					} catch (e) {
+						logger.error("sending over postmessage fail");
+					}
+				});
+				return Promise.resolve(null);
+			}
+			flush() {
+				const { buffer } = this;
+				this.buffer = [];
+				buffer.forEach((item) => {
+					this.send(item.event).then(item.resolve).catch(item.reject);
+				});
+			}
+			getFrames(target) {
+				if (this.config.page === "manager") {
+					const list = Array.from(document$2.querySelectorAll("iframe[data-is-storybook][data-is-loaded]")).flatMap((e) => {
+						try {
+							if (!!e.contentWindow && e.dataset.isStorybook !== void 0 && e.id === target) return [{
+								contentWindow: e.contentWindow,
+								targetOrigin: this.getIframeTargetOrigin(e)
+							}];
+							return [];
+						} catch (er) {
+							return [];
+						}
+					});
+					return list?.length ? list : this.getCurrentFrames();
+				}
+				if (globalThis.parent && globalThis.parent !== globalThis.self) return [{
+					contentWindow: globalThis.parent,
+					targetOrigin: this.getManagerTargetOrigin()
+				}];
+				return [];
+			}
+			getCurrentFrames() {
+				if (this.config.page === "manager") return Array.from(document$2.querySelectorAll("[data-is-storybook=\"true\"]")).flatMap((e) => e.contentWindow ? [{
+					contentWindow: e.contentWindow,
+					targetOrigin: this.getIframeTargetOrigin(e)
+				}] : []);
+				if (globalThis.parent) return [{
+					contentWindow: globalThis.parent,
+					targetOrigin: this.getManagerTargetOrigin()
+				}];
+				return [];
+			}
+			getIframeTargetOrigin(element) {
+				const src = element.getAttribute("src");
+				if (src) try {
+					const { origin } = new URL(src, document$2.location.toString());
+					if (origin !== "null") return origin;
+				} catch {}
+				return location?.origin && location.origin !== "null" ? location.origin : "*";
+			}
+			getManagerTargetOrigin() {
+				const referrerOrigin = getReferrerOrigin();
+				if (this.originValidator) return referrerOrigin !== null && this.originValidator(referrerOrigin) ? referrerOrigin : location.origin;
+				return referrerOrigin ?? "*";
+			}
+			getLocalFrame() {
+				if (this.config.page === "manager") return Array.from(document$2.querySelectorAll("#storybook-preview-iframe")).flatMap((e) => e.contentWindow ? [e.contentWindow] : []);
+				if (globalThis.parent) return [globalThis.parent];
+				return [];
+			}
+			isAllowedSender(rawEvent) {
+				if (this.insecureIframeMessaging) return true;
+				if (this.config.page === "manager") return this.isAllowedToContactManager(rawEvent);
+				else if (this.config.page === "preview") return this.isAllowedToContactPreview(rawEvent);
+				return false;
+			}
+			isAllowedToContactPreview(rawEvent) {
+				if (!this.originValidator) return true;
+				if (this.originValidator(rawEvent.origin)) return true;
+				this.warnOnceAboutRejectedSender(rawEvent, `Ignored Forkbook channel message from unexpected origin "${rawEvent.origin}". While it runs in dev mode, this preview only accepts messages from local hosts and its own origin. To accept messages from any origin, set "security.insecureIframeMessaging" to true in the main config of the Forkbook serving this preview.`);
+				return false;
+			}
+			isAllowedToContactManager(rawEvent) {
+				const senderFrame = rawEvent.source ? Array.from(document$2.querySelectorAll("iframe")).find((frame) => frame.contentWindow === rawEvent.source) : void 0;
+				if (senderFrame?.hasAttribute("data-is-storybook")) {
+					if (!this.pinsTargetOrigin) return true;
+					const expectedOrigin = this.getIframeTargetOrigin(senderFrame);
+					if (expectedOrigin === "*" || expectedOrigin === rawEvent.origin) return true;
+					this.warnOnceAboutRejectedSender(rawEvent, `Ignored Forkbook channel message from a registered preview iframe that is on origin "${rawEvent.origin}" instead of "${expectedOrigin}". While it runs in dev mode, the manager only accepts channel messages from the origin each preview iframe was given, so a page the iframe navigated to cannot send them. To accept messages from any origin, set "security.insecureIframeMessaging" to true.`);
+					return false;
+				}
+				if (!senderFrame?.hasAttribute("data-is-storybook-thumbnail")) this.warnOnceAboutRejectedSender(rawEvent, `Ignored Forkbook channel message from a window that is not a registered preview iframe (origin "${rawEvent.origin}"). The manager only accepts channel messages from its own preview and composed Forkbook iframes, never from a page that embeds it. To accept messages from any window, set "security.insecureIframeMessaging" to true.`);
+				return false;
+			}
+			warnOnceAboutRejectedSender(rawEvent, message) {
+				if ((typeof rawEvent.data === "string" ? rawEvent.data.includes("storybook-channel") : rawEvent.data?.key === "storybook-channel") && !this.rejectedOrigins.has(rawEvent.origin)) {
+					this.rejectedOrigins.add(rawEvent.origin);
+					logger.warn(message);
+				}
+			}
+			handleEvent(rawEvent) {
+				try {
+					if (!this.isAllowedSender(rawEvent)) return;
+					const { data } = rawEvent;
+					const { key, event, refId } = typeof data === "string" && isJSON(data) ? parse(data, CHANNEL_OPTIONS$1) : data;
+					if (key === "storybook-channel") {
+						const pageString = this.config.page === "manager" ? `<span style="color: #37D5D3; background: black"> manager </span>` : `<span style="color: #1EA7FD; background: black"> preview </span>`;
+						const eventString = Object.values(core_events_exports).includes(event.type) ? `<span style="color: #FF4785">${event.type}</span>` : `<span style="color: #FFAE00">${event.type}</span>`;
+						if (refId) event.refId = refId;
+						event.source = this.config.page === "preview" ? rawEvent.origin : getEventSourceUrl(rawEvent, refId);
+						if (!event.source) {
+							pretty.error(`${pageString} received ${eventString} but was unable to determine the source of the event`);
+							return;
+						}
+						const message = `${pageString} received ${eventString} (${data.length})`;
+						pretty.debug(location.origin !== event.source ? message : `${message} <span style="color: gray">(on ${location.origin} from ${event.source})</span>`, ...event.args);
+						invariant(this.handler, "ChannelHandler should be set");
+						if (this.config.page === "manager" && this.buffer.length) this.flush();
+						this.handler(event);
+					}
+				} catch (error) {
+					logger.error(error);
+				}
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/channels/websocket/index.ts
+var HEARTBEAT_INTERVAL, SERVER_CHANNEL_PATH, CHANNEL_OPTIONS, WebsocketTransport;
+function init_websocket() {
+	return (init_websocket = __esmMin((() => {
+		init_core_events();
+		init_dist();
+		init_tiny_invariant();
+		HEARTBEAT_INTERVAL = 15e3;
+		SERVER_CHANNEL_PATH = "/storybook-server-channel";
+		CHANNEL_OPTIONS = globalThis.CHANNEL_OPTIONS || {};
+		WebsocketTransport = class {
+			constructor({ url, onError, page, createSocket }) {
+				this.buffer = [];
+				this.isReady = false;
+				this.isClosed = false;
+				this.socket = createSocket ? createSocket(url) : new WebSocket(url);
+				this.socket.onopen = () => {
+					this.isReady = true;
+					this.flush();
+				};
+				this.socket.onmessage = ({ data }) => {
+					const event = typeof data === "string" && isJSON(data) ? parse(data) : data;
+					invariant(this.handler, "WebsocketTransport handler should be set");
+					if (event.type === "ping") {
+						this.send({ type: "pong" });
+						return;
+					}
+					this.handler(event);
+				};
+				this.socket.onerror = (e) => {
+					if (onError) onError(e);
+				};
+				this.socket.onclose = (ev) => {
+					invariant(this.handler, "WebsocketTransport handler should be set");
+					this.handler({
+						type: CHANNEL_WS_DISCONNECT,
+						args: [{
+							reason: ev.reason,
+							code: ev.code
+						}],
+						from: page || "preview"
+					});
+					this.isClosed = true;
+				};
+			}
+			setHandler(handler) {
+				this.handler = handler;
+			}
+			send(event) {
+				if (!this.isClosed) {
+					if (!this.isReady) this.sendLater(event);
+					else this.sendNow(event);
+				}
+			}
+			sendLater(event) {
+				this.buffer.push(event);
+			}
+			sendNow(event) {
+				const data = stringify(event, {
+					maxDepth: 15,
+					...CHANNEL_OPTIONS
+				});
+				this.socket.send(data);
+			}
+			flush() {
+				const { buffer } = this;
+				this.buffer = [];
+				buffer.forEach((event) => this.send(event));
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/channels/channel-slot.ts
+function syncGlobalSlot(next) {
+	globalThis.__STORYBOOK_ADDONS_CHANNEL__ = next;
+}
+/**
+* Returns the installed addons channel, or `null` before one exists.
+*
+* The global slot wins over the module cache so duplicate copies of this module (e.g. dev-server
+* preset code and `.forkbook` service registration loading different bundles) still observe
+* `setChannel` from whichever copy installed the live websocket channel.
+*/
+function getChannel() {
+	const fromGlobal = globalThis.__STORYBOOK_ADDONS_CHANNEL__;
+	if (fromGlobal) channel = fromGlobal;
+	return channel ?? null;
+}
+/**
+* Returns the installed addons channel.
+*
+* Callers assume each runtime has installed a channel at its entry boundary (builder iframe setup,
+* manager boot, server `services` preset, or Node module bootstrap). Prefer this over nullable
+* `getChannel()` when the channel must exist.
+*/
+function requireChannel() {
+	const installed = getChannel();
+	if (!installed) throw new Error("Forkbook addons channel is not installed in this runtime. Install it via setChannel() or addons.setChannel() at the runtime entry point before registering services or emitting events.");
+	return installed;
+}
+/** Installs (or replaces) the shared addons channel. Pass `null` to clear. */
+function setChannel(next) {
+	channel = next ?? void 0;
+	syncGlobalSlot(channel);
+}
+/** Clears the shared channel slot. Alias for `setChannel(null)`. */
+function clearChannel() {
+	setChannel(null);
+}
+/** Installs a noop in-process channel — used by server presets and unit tests. */
+function installNoopChannel() {
+	setChannel(new Channel({}));
+}
+/**
+* Installs a noop channel when none is present yet.
+*
+* Prefer explicit `setChannel` / `installNoopChannel` at runtime entry points. This helper remains for
+* tests and tooling that need an in-process channel without a mock transport.
+*/
+function ensureChannel() {
+	if (!getChannel()) installNoopChannel();
+}
+var channel;
+function init_channel_slot() {
+	return (init_channel_slot = __esmMin((() => {
+		init_main();
+		if (typeof window === "undefined") ensureChannel();
+	})))();
+}
+//#endregion
+//#region src/channels/index.ts
+var channels_exports = /* @__PURE__ */ __exportAll({
+	Channel: () => Channel,
+	HEARTBEAT_INTERVAL: () => HEARTBEAT_INTERVAL,
+	PostMessageTransport: () => PostMessageTransport,
+	SERVER_CHANNEL_PATH: () => SERVER_CHANNEL_PATH,
+	WebsocketTransport: () => WebsocketTransport,
+	clearChannel: () => clearChannel,
+	createBrowserChannel: () => createBrowserChannel,
+	default: () => channels_default,
+	ensureChannel: () => ensureChannel,
+	getChannel: () => getChannel,
+	installNoopChannel: () => installNoopChannel,
+	requireChannel: () => requireChannel,
+	setChannel: () => setChannel
+});
+/**
+* Creates a new browser channel instance.
+*
+* @param {Options} options - The options object.
+* @param {Page} options.page - Page identifier.
+* @param {ChannelTransport[]} [options.extraTransports=[]] - An optional array of extra channel
+*   transports. Default is `[]`
+* @returns {Channel} - The new channel instance.
+*/
+function createBrowserChannel({ page, extraTransports = [] }) {
+	const transports = [new PostMessageTransport({ page }), ...extraTransports];
+	if (globalThis.CONFIG_TYPE === "DEVELOPMENT") {
+		const protocol = window.location.protocol === "http:" ? "ws" : "wss";
+		const { hostname, port } = window.location;
+		const { wsToken } = globalThis.CHANNEL_OPTIONS || {};
+		const channelUrl = `${protocol}://${hostname}:${port}${SERVER_CHANNEL_PATH}?token=${wsToken}&page=${page}`;
+		transports.push(new WebsocketTransport({
+			url: channelUrl,
+			onError: () => {},
+			page
+		}));
+	}
+	const channel = new Channel({ transports });
+	UniversalStore.__prepare(channel, page === "manager" ? UniversalStore.Environment.MANAGER : UniversalStore.Environment.PREVIEW);
+	return channel;
+}
+var channels_default;
+function init_channels() {
+	return (init_channels = __esmMin((() => {
+		init_universal_store();
+		init_main();
+		init_postmessage();
+		init_websocket();
+		init_channel_slot();
+		channels_default = Channel;
+	})))();
+}
+//#endregion
+//#region src/actions/constants.ts
+var PARAM_KEY$3, ADDON_ID$2, PANEL_ID, EVENT_ID, CLEAR_ID, CYCLIC_KEY;
+function init_constants() {
+	return (init_constants = __esmMin((() => {
+		PARAM_KEY$3 = "actions";
+		ADDON_ID$2 = "@aussieljk/forkbook/actions";
+		PANEL_ID = `${ADDON_ID$2}/panel`;
+		EVENT_ID = `${ADDON_ID$2}/action-event`;
+		CLEAR_ID = `${ADDON_ID$2}/action-clear`;
+		CYCLIC_KEY = "$___storybook.isCyclic";
+	})))();
+}
+//#endregion
+//#region src/channels/mock-channel.ts
+/** In-process channel with no transport — the default for unit tests and manager story mocks. */
+function mockChannel() {
+	return new Channel({ transport: {
+		setHandler: () => {},
+		send: () => {}
+	} });
+}
+function init_mock_channel() {
+	return (init_mock_channel = __esmMin((() => {
+		init_main();
+	})))();
+}
+//#endregion
+//#region src/csf/toStartCaseStr.ts
+function toStartCaseStr(str) {
+	return str.replace(/_/g, " ").replace(/-/g, " ").replace(/\./g, " ").replace(/([^\n])([A-Z])([a-z])/g, (str2, $1, $2, $3) => `${$1} ${$2}${$3}`).replace(/([a-z])([A-Z])/g, (str2, $1, $2) => `${$1} ${$2}`).replace(/([a-z])([0-9])/gi, (str2, $1, $2) => `${$1} ${$2}`).replace(/([0-9])([a-z])/gi, (str2, $1, $2) => `${$1} ${$2}`).replace(/(\s|^)(\w)/g, (str2, $1, $2) => `${$1}${$2.toUpperCase()}`).replace(/ +/g, " ").trim();
+}
+//#endregion
+//#region src/csf/export-story.ts
+function matches(storyKey, arrayOrRegex) {
+	if (Array.isArray(arrayOrRegex)) return arrayOrRegex.includes(storyKey);
+	return storyKey.match(arrayOrRegex);
+}
+/** Does a named export match CSF inclusion/exclusion options? */
+function isExportStory(key, { includeStories, excludeStories }) {
+	return key !== "__esModule" && (!includeStories || matches(key, includeStories)) && (!excludeStories || !matches(key, excludeStories));
+}
+var storyNameFromExport;
+function init_export_story() {
+	return (init_export_story = __esmMin((() => {
+		storyNameFromExport = (key) => toStartCaseStr(key);
+	})))();
+}
+//#endregion
+//#region src/csf/csf-utils.ts
+var sanitize, sanitizeSafe, toId, toTestId, combineTags;
+function init_csf_utils() {
+	return (init_csf_utils = __esmMin((() => {
+		sanitize = (string) => {
+			return string.toLowerCase().replace(/[ ’–—―′¿'`~!@#$%^&*()_|+\-=?;:'",.<>\{\}\[\]\\\/]/gi, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+		};
+		sanitizeSafe = (string, part) => {
+			const sanitized = sanitize(string);
+			if (sanitized === "") throw new Error(`Invalid ${part} '${string}', must include alphanumeric characters`);
+			return sanitized;
+		};
+		toId = (kind, name) => `${sanitizeSafe(kind, "kind")}${name ? `--${sanitizeSafe(name, "name")}` : ""}`;
+		toTestId = (parentId, testName) => `${parentId}:${sanitizeSafe(testName, "test")}`;
+		combineTags = (...tags) => {
+			const result = tags.reduce((acc, tag) => {
+				if (tag.startsWith("!")) acc.delete(tag.slice(1));
+				else acc.add(tag);
+				return acc;
+			}, /* @__PURE__ */ new Set());
+			return Array.from(result);
+		};
+	})))();
+}
+//#endregion
+//#region src/csf/includeConditionalArg.ts
+var import_tiny_isequal, count, testValue, includeConditionalArg;
+function init_includeConditionalArg() {
+	return (init_includeConditionalArg = __esmMin((() => {
+		import_tiny_isequal = require_tiny_isequal();
+		count = (vals) => vals.map((v) => typeof v !== "undefined").filter(Boolean).length;
+		testValue = (cond, value) => {
+			const { exists, eq, neq, truthy } = cond;
+			if (count([
+				exists,
+				eq,
+				neq,
+				truthy
+			]) > 1) throw new Error(`Invalid conditional test ${JSON.stringify({
+				exists,
+				eq,
+				neq
+			})}`);
+			if (typeof eq !== "undefined") return (0, import_tiny_isequal.isEqual)(value, eq);
+			if (typeof neq !== "undefined") return !(0, import_tiny_isequal.isEqual)(value, neq);
+			if (typeof exists !== "undefined") {
+				const valueExists = typeof value !== "undefined";
+				return exists ? valueExists : !valueExists;
+			}
+			return (typeof truthy === "undefined" ? true : truthy) ? !!value : !value;
+		};
+		includeConditionalArg = (argType, args, globals) => {
+			if (!argType.if) return true;
+			const { arg, global } = argType.if;
+			if (count([arg, global]) !== 1) throw new Error(`Invalid conditional value ${JSON.stringify({
+				arg,
+				global
+			})}`);
+			const value = arg ? args[arg] : globals[global];
+			return testValue(argType.if, value);
+		};
+	})))();
+}
+//#endregion
+//#region src/actions/addArgsHelpers.ts
+var isInInitialArgs, inferActionsFromArgTypesRegex, addActionsFromArgTypes;
+function init_addArgsHelpers() {
+	return (init_addArgsHelpers = __esmMin((() => {
+		init_action();
+		isInInitialArgs = (name, initialArgs) => typeof initialArgs[name] === "undefined" && !(name in initialArgs);
+		inferActionsFromArgTypesRegex = (context) => {
+			const { initialArgs, argTypes, id, parameters: { actions } } = context;
+			if (!actions || actions.disable || !actions.argTypesRegex || !argTypes) return {};
+			const argTypesRegex = new RegExp(actions.argTypesRegex);
+			return Object.entries(argTypes).filter(([name]) => !!argTypesRegex.test(name)).reduce((acc, [name, argType]) => {
+				if (isInInitialArgs(name, initialArgs)) acc[name] = action(name, {
+					implicit: true,
+					id
+				});
+				return acc;
+			}, {});
+		};
+		addActionsFromArgTypes = (context) => {
+			const { initialArgs, argTypes, parameters: { actions } } = context;
+			if (actions?.disable || !argTypes) return {};
+			return Object.entries(argTypes).filter(([name, argType]) => !!argType.action).reduce((acc, [name, argType]) => {
+				if (isInInitialArgs(name, initialArgs)) acc[name] = action(typeof argType.action === "string" ? argType.action : name);
+				return acc;
+			}, {});
+		};
+	})))();
+}
+//#endregion
+//#region src/actions/addArgs.ts
+var addArgs_exports = /* @__PURE__ */ __exportAll({ argsEnhancers: () => argsEnhancers });
+var argsEnhancers;
+function init_addArgs() {
+	return (init_addArgs = __esmMin((() => {
+		init_addArgsHelpers();
+		argsEnhancers = [addActionsFromArgTypes, inferActionsFromArgTypesRegex];
+	})))();
+}
+//#endregion
+//#region src/instrumenter/EVENTS.ts
+var EVENTS;
+function init_EVENTS() {
+	return (init_EVENTS = __esmMin((() => {
+		EVENTS = {
+			CALL: "@aussieljk/forkbook/instrumenter/call",
+			SYNC: "@aussieljk/forkbook/instrumenter/sync",
+			START: "@aussieljk/forkbook/instrumenter/start",
+			BACK: "@aussieljk/forkbook/instrumenter/back",
+			GOTO: "@aussieljk/forkbook/instrumenter/goto",
+			NEXT: "@aussieljk/forkbook/instrumenter/next",
+			END: "@aussieljk/forkbook/instrumenter/end"
+		};
+	})))();
+}
+//#endregion
+//#region src/instrumenter/preview-api.ts
+var addons;
+function init_preview_api() {
+	return (init_preview_api = __esmMin((() => {
+		addons = globalThis.__STORYBOOK_ADDONS_PREVIEW;
+	})))();
+}
+//#endregion
+//#region src/instrumenter/instrumenter.ts
+/**
+* Instruments an object or module by traversing its properties, patching any functions (methods) to
+* enable debugging. Patched functions will emit a `call` event when invoked. When intercept = true,
+* patched functions will return a Promise when the debugger stops before this function. As such,
+* "interceptable" functions will have to be `await`-ed.
+*/
+function instrument(obj, options = {}) {
+	try {
+		let forceInstrument = false;
+		let skipInstrument = false;
+		if (scope.window?.location?.search?.includes("instrument=true")) forceInstrument = true;
+		else if (scope.window?.location?.search?.includes("instrument=false")) skipInstrument = true;
+		if (scope.window?.parent === scope.window && !forceInstrument || skipInstrument) return obj;
+		if (scope.window && !scope.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__) scope.window.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__ = new Instrumenter();
+		return (scope.window?.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER__).instrument(obj, options);
+	} catch (e) {
+		once.warn(e);
+		return obj;
+	}
+}
+function getPropertyDescriptor(obj, propName) {
+	let target = obj;
+	while (target != null) {
+		const descriptor = Object.getOwnPropertyDescriptor(target, propName);
+		if (descriptor) return descriptor;
+		target = Object.getPrototypeOf(target);
+	}
+}
+function isClass(obj) {
+	if (typeof obj !== "function") return false;
+	const descriptor = Object.getOwnPropertyDescriptor(obj, "prototype");
+	if (!descriptor) return false;
+	return !descriptor.writable;
+}
+var alreadyCompletedException, isObject, isModule, isInstrumentable, construct, getInitialState, getRetainedState, Instrumenter;
+function init_instrumenter() {
+	return (init_instrumenter = __esmMin((() => {
+		init_client_logger();
+		init_core_events();
+		init_dist$1();
+		init_error();
+		init_EVENTS();
+		init_preview_api();
+		alreadyCompletedException = /* @__PURE__ */ new Error(`This function ran after the play function completed. Did you forget to \`await\` it?`);
+		isObject = (o) => Object.prototype.toString.call(o) === "[object Object]";
+		isModule = (o) => Object.prototype.toString.call(o) === "[object Module]";
+		isInstrumentable = (o) => {
+			if (!isObject(o) && !isModule(o)) return false;
+			if (o.constructor === void 0) return true;
+			const proto = o.constructor.prototype;
+			if (!isObject(proto)) return false;
+			return true;
+		};
+		construct = (obj) => {
+			try {
+				return new obj.constructor();
+			} catch {
+				return {};
+			}
+		};
+		getInitialState = () => ({
+			renderPhase: "preparing",
+			isDebugging: false,
+			isPlaying: false,
+			isLocked: false,
+			cursor: 0,
+			calls: [],
+			shadowCalls: [],
+			callRefsByResult: /* @__PURE__ */ new Map(),
+			chainedCallIds: /* @__PURE__ */ new Set(),
+			ancestors: [],
+			playUntil: void 0,
+			resolvers: {},
+			syncTimeout: void 0
+		});
+		getRetainedState = (state, isDebugging = false) => {
+			const calls = (isDebugging ? state.shadowCalls : state.calls).filter((call) => call.retain);
+			if (!calls.length) return;
+			const callRefsByResult = new Map(Array.from(state.callRefsByResult.entries()).filter(([, ref]) => ref.retain));
+			return {
+				cursor: calls.length,
+				calls,
+				callRefsByResult
+			};
+		};
+		Instrumenter = class {
+			constructor() {
+				this.detached = false;
+				this.initialized = false;
+				this.state = {};
+				this.loadParentWindowState = () => {
+					try {
+						this.state = scope.window?.parent?.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ || {};
+					} catch {
+						this.detached = true;
+					}
+				};
+				this.updateParentWindowState = () => {
+					try {
+						scope.window.parent.__STORYBOOK_ADDON_INTERACTIONS_INSTRUMENTER_STATE__ = this.state;
+					} catch {
+						this.detached = true;
+					}
+				};
+				this.loadParentWindowState();
+				const resetState = ({ storyId, renderPhase, isPlaying = true, isDebugging = false }) => {
+					const state = this.getState(storyId);
+					this.setState(storyId, {
+						...getInitialState(),
+						...getRetainedState(state, isDebugging),
+						renderPhase: renderPhase || state.renderPhase,
+						shadowCalls: isDebugging ? state.shadowCalls : [],
+						chainedCallIds: isDebugging ? state.chainedCallIds : /* @__PURE__ */ new Set(),
+						playUntil: isDebugging ? state.playUntil : void 0,
+						isPlaying,
+						isDebugging
+					});
+					this.sync(storyId);
+				};
+				const start = (channel) => ({ storyId, playUntil }) => {
+					if (!this.getState(storyId).isDebugging) this.setState(storyId, ({ calls }) => ({
+						calls: [],
+						shadowCalls: calls.map((call) => ({
+							...call,
+							status: "waiting"
+						})),
+						isDebugging: true
+					}));
+					const log = this.getLog(storyId);
+					this.setState(storyId, ({ shadowCalls }) => {
+						if (playUntil || !log.length) return { playUntil };
+						const firstRowIndex = shadowCalls.findIndex((call) => call.id === log[0].callId);
+						return { playUntil: shadowCalls.slice(0, firstRowIndex).filter((call) => call.interceptable && !call.ancestors?.length).slice(-1)[0]?.id };
+					});
+					channel.emit(FORCE_REMOUNT, {
+						storyId,
+						isDebugging: true
+					});
+				};
+				const back = (channel) => ({ storyId }) => {
+					const log = this.getLog(storyId).filter((call) => !call.ancestors?.length);
+					const last = log.reduceRight((res, item, index) => {
+						if (res >= 0 || item.status === "waiting") return res;
+						return index;
+					}, -1);
+					start(channel)({
+						storyId,
+						playUntil: log[last - 1]?.callId
+					});
+				};
+				const goto = (channel) => ({ storyId, callId }) => {
+					const { calls, shadowCalls, resolvers } = this.getState(storyId);
+					const call = calls.find(({ id }) => id === callId);
+					const shadowCall = shadowCalls.find(({ id }) => id === callId);
+					if (!call && shadowCall && Object.values(resolvers).length > 0) {
+						const nextId = this.getLog(storyId).find((c) => c.status === "waiting")?.callId;
+						if (shadowCall.id !== nextId) this.setState(storyId, { playUntil: shadowCall.id });
+						Object.values(resolvers).forEach((resolve) => resolve());
+					} else start(channel)({
+						storyId,
+						playUntil: callId
+					});
+				};
+				const next = (channel) => ({ storyId }) => {
+					const { resolvers } = this.getState(storyId);
+					if (Object.values(resolvers).length > 0) Object.values(resolvers).forEach((resolve) => resolve());
+					else {
+						const nextId = this.getLog(storyId).find((c) => c.status === "waiting")?.callId;
+						if (nextId) start(channel)({
+							storyId,
+							playUntil: nextId
+						});
+						else end({ storyId });
+					}
+				};
+				const end = ({ storyId }) => {
+					this.setState(storyId, {
+						playUntil: void 0,
+						isDebugging: false
+					});
+					Object.values(this.getState(storyId).resolvers).forEach((resolve) => resolve());
+				};
+				const renderPhaseChanged = ({ storyId, newPhase }) => {
+					const { isDebugging } = this.getState(storyId);
+					if (newPhase === "preparing" && isDebugging) return resetState({
+						storyId,
+						renderPhase: newPhase,
+						isDebugging
+					});
+					else if (newPhase === "playing") return resetState({
+						storyId,
+						renderPhase: newPhase,
+						isDebugging
+					});
+					if (newPhase === "played") this.setState(storyId, {
+						renderPhase: newPhase,
+						isLocked: false,
+						isPlaying: false,
+						isDebugging: false
+					});
+					else if (newPhase === "errored") this.setState(storyId, {
+						renderPhase: newPhase,
+						isLocked: false,
+						isPlaying: false
+					});
+					else if (newPhase === "aborted") this.setState(storyId, {
+						renderPhase: newPhase,
+						isLocked: true,
+						isPlaying: false
+					});
+					else this.setState(storyId, { renderPhase: newPhase });
+					this.sync(storyId);
+				};
+				if (addons) addons.ready().then(() => {
+					this.channel = addons.getChannel();
+					this.channel.on(FORCE_REMOUNT, resetState);
+					this.channel.on(STORY_RENDER_PHASE_CHANGED, renderPhaseChanged);
+					this.channel.on(SET_CURRENT_STORY, () => {
+						if (this.initialized) this.cleanup();
+						else this.initialized = true;
+					});
+					this.channel.on(EVENTS.START, start(this.channel));
+					this.channel.on(EVENTS.BACK, back(this.channel));
+					this.channel.on(EVENTS.GOTO, goto(this.channel));
+					this.channel.on(EVENTS.NEXT, next(this.channel));
+					this.channel.on(EVENTS.END, end);
+				});
+			}
+			getState(storyId) {
+				return this.state[storyId] || getInitialState();
+			}
+			setState(storyId, update) {
+				if (storyId) {
+					const state = this.getState(storyId);
+					const patch = typeof update === "function" ? update(state) : update;
+					this.state = {
+						...this.state,
+						[storyId]: {
+							...state,
+							...patch
+						}
+					};
+					this.updateParentWindowState();
+				}
+			}
+			cleanup() {
+				this.state = Object.entries(this.state).reduce((acc, [storyId, state]) => {
+					const retainedState = getRetainedState(state);
+					if (!retainedState) return acc;
+					acc[storyId] = Object.assign(getInitialState(), retainedState);
+					return acc;
+				}, {});
+				const payload = {
+					controlStates: {
+						detached: this.detached,
+						start: false,
+						back: false,
+						goto: false,
+						next: false,
+						end: false
+					},
+					logItems: []
+				};
+				this.channel?.emit(EVENTS.SYNC, payload);
+				this.updateParentWindowState();
+			}
+			getLog(storyId) {
+				const { calls, shadowCalls } = this.getState(storyId);
+				const merged = [...shadowCalls];
+				calls.forEach((call, index) => {
+					merged[index] = call;
+				});
+				const seen = /* @__PURE__ */ new Set();
+				return merged.reduceRight((acc, call) => {
+					call.args.forEach((arg) => {
+						if (arg?.__callId__) seen.add(arg.__callId__);
+					});
+					call.path.forEach((node) => {
+						if (node.__callId__) seen.add(node.__callId__);
+					});
+					if ((call.interceptable || call.exception) && !seen.has(call.id)) {
+						acc.unshift({
+							callId: call.id,
+							status: call.status,
+							ancestors: call.ancestors
+						});
+						seen.add(call.id);
+					}
+					return acc;
+				}, []);
+			}
+			instrument(obj, options, depth = 0) {
+				if (!isInstrumentable(obj)) return obj;
+				const { mutate = false, path = [] } = options;
+				const keys = options.getKeys ? options.getKeys(obj, depth) : Object.keys(obj);
+				depth += 1;
+				return keys.reduce((acc, key) => {
+					const descriptor = getPropertyDescriptor(obj, key);
+					if (typeof descriptor?.get === "function") {
+						if (descriptor.configurable) {
+							const getter = () => descriptor?.get?.bind(obj)?.();
+							Object.defineProperty(acc, key, { get: () => {
+								return this.instrument(getter(), {
+									...options,
+									path: path.concat(key)
+								}, depth);
+							} });
+						}
+						return acc;
+					}
+					const value = obj[key];
+					if (typeof value !== "function") {
+						acc[key] = this.instrument(value, {
+							...options,
+							path: path.concat(key)
+						}, depth);
+						return acc;
+					}
+					if ("__originalFn__" in value && typeof value.__originalFn__ === "function") {
+						acc[key] = value;
+						return acc;
+					}
+					acc[key] = (...args) => this.track(key, value, obj, args, options);
+					acc[key].__originalFn__ = value;
+					Object.defineProperty(acc[key], "name", {
+						value: key,
+						writable: false
+					});
+					if (Object.keys(value).length > 0) Object.assign(acc[key], this.instrument({ ...value }, {
+						...options,
+						path: path.concat(key)
+					}, depth));
+					return acc;
+				}, mutate ? obj : construct(obj));
+			}
+			track(method, fn, object, args, options) {
+				const storyId = args?.[0]?.__storyId__ || scope.__STORYBOOK_PREVIEW__?.selectionStore?.selection?.storyId;
+				const { cursor, ancestors } = this.getState(storyId);
+				this.setState(storyId, { cursor: cursor + 1 });
+				const id = `${ancestors.slice(-1)[0] || storyId} [${cursor}] ${method}`;
+				const { path = [], intercept = false, retain = false } = options;
+				const interceptable = typeof intercept === "function" ? intercept(method, path) : intercept;
+				const call = {
+					id,
+					cursor,
+					storyId,
+					ancestors,
+					path,
+					method,
+					args,
+					interceptable,
+					retain
+				};
+				const result = (interceptable && !ancestors.length ? this.intercept : this.invoke).call(this, fn, object, call, options);
+				return this.instrument(result, {
+					...options,
+					mutate: true,
+					path: [{ __callId__: call.id }]
+				});
+			}
+			intercept(fn, object, call, options) {
+				const { chainedCallIds, isDebugging, playUntil } = this.getState(call.storyId);
+				const isChainedUpon = chainedCallIds.has(call.id);
+				if (!isDebugging || isChainedUpon || playUntil) {
+					if (playUntil === call.id) this.setState(call.storyId, { playUntil: void 0 });
+					return this.invoke(fn, object, call, options);
+				}
+				return new Promise((resolve) => {
+					this.setState(call.storyId, ({ resolvers }) => ({
+						isLocked: false,
+						resolvers: {
+							...resolvers,
+							[call.id]: resolve
+						}
+					}));
+				}).then(() => {
+					this.setState(call.storyId, (state) => {
+						const { [call.id]: _, ...resolvers } = state.resolvers;
+						return {
+							isLocked: true,
+							resolvers
+						};
+					});
+					return this.invoke(fn, object, call, options);
+				});
+			}
+			invoke(fn, object, call, options) {
+				const { callRefsByResult, renderPhase } = this.getState(call.storyId);
+				const maximumDepth = 25;
+				const serializeValues = (value, depth, seen) => {
+					if (seen.includes(value)) return "[Circular]";
+					seen = [...seen, value];
+					if (depth > maximumDepth) return "...";
+					if (callRefsByResult.has(value)) return callRefsByResult.get(value);
+					if (value instanceof Array) return value.map((it) => serializeValues(it, ++depth, seen));
+					if (value instanceof Date) return { __date__: { value: value.toISOString() } };
+					if (value instanceof Error) {
+						const { name, message, stack } = value;
+						return { __error__: {
+							name,
+							message,
+							stack
+						} };
+					}
+					if (value instanceof RegExp) {
+						const { flags, source } = value;
+						return { __regexp__: {
+							flags,
+							source
+						} };
+					}
+					if (value instanceof scope.window?.HTMLElement) {
+						const { prefix, localName, id, classList, innerText } = value;
+						return { __element__: {
+							prefix,
+							localName,
+							id,
+							classNames: Array.from(classList),
+							innerText
+						} };
+					}
+					if (typeof value === "function") return { __function__: { name: "getMockName" in value ? value.getMockName() : value.name } };
+					if (typeof value === "symbol") return { __symbol__: { description: value.description } };
+					if (typeof value === "object" && value?.constructor?.name && value?.constructor?.name !== "Object") return { __class__: { name: value.constructor.name } };
+					if (Object.prototype.toString.call(value) === "[object Object]") return Object.fromEntries(Object.entries(value).map(([key, val]) => [key, serializeValues(val, ++depth, seen)]));
+					return value;
+				};
+				const info = {
+					...call,
+					args: call.args.map((arg) => serializeValues(arg, 0, []))
+				};
+				call.path.forEach((ref) => {
+					if (ref?.__callId__) this.setState(call.storyId, ({ chainedCallIds }) => ({ chainedCallIds: new Set(Array.from(chainedCallIds).concat(ref.__callId__)) }));
+				});
+				const handleException = (e) => {
+					if (e instanceof Error) {
+						const { name, message, stack, callId = call.id } = e;
+						const { showDiff = void 0, diff = void 0, actual = void 0, expected = void 0 } = e.name === "AssertionError" ? processError(e) : e;
+						const exception = {
+							name,
+							message,
+							stack,
+							callId,
+							showDiff,
+							diff,
+							actual,
+							expected
+						};
+						this.update({
+							...info,
+							status: "error",
+							exception
+						});
+						this.setState(call.storyId, (state) => ({ callRefsByResult: new Map([...Array.from(state.callRefsByResult.entries()), [e, {
+							__callId__: call.id,
+							retain: call.retain
+						}]]) }));
+						if (call.ancestors?.length) {
+							if (!Object.prototype.hasOwnProperty.call(e, "callId")) Object.defineProperty(e, "callId", { value: call.id });
+							throw e;
+						}
+					}
+					throw e;
+				};
+				try {
+					if (renderPhase === "played" && !call.retain) throw alreadyCompletedException;
+					const finalArgs = (options.getArgs ? options.getArgs(call, this.getState(call.storyId)) : call.args).map((arg) => {
+						if (typeof arg !== "function" || isClass(arg) || Object.keys(arg).length) return arg;
+						return (...args) => {
+							const { cursor, ancestors } = this.getState(call.storyId);
+							this.setState(call.storyId, {
+								cursor: 0,
+								ancestors: [...ancestors, call.id]
+							});
+							const restore = () => this.setState(call.storyId, {
+								cursor,
+								ancestors
+							});
+							let willRestore = false;
+							try {
+								const res = arg(...args);
+								if (res instanceof Promise) {
+									willRestore = true;
+									return res.finally(restore);
+								}
+								return res;
+							} finally {
+								if (!willRestore) restore();
+							}
+						};
+					});
+					const result = fn.apply(object, finalArgs);
+					if (result && [
+						"object",
+						"function",
+						"symbol"
+					].includes(typeof result)) this.setState(call.storyId, (state) => ({ callRefsByResult: new Map([...Array.from(state.callRefsByResult.entries()), [result, {
+						__callId__: call.id,
+						retain: call.retain
+					}]]) }));
+					this.update({
+						...info,
+						status: result instanceof Promise ? "active" : "done"
+					});
+					if (result instanceof Promise) return result.then((value) => {
+						this.update({
+							...info,
+							status: "done"
+						});
+						return value;
+					}, handleException);
+					return result;
+				} catch (e) {
+					return handleException(e);
+				}
+			}
+			update(call) {
+				this.channel?.emit(EVENTS.CALL, call);
+				this.setState(call.storyId, ({ calls }) => {
+					const callsById = calls.concat(call).reduce((a, c) => Object.assign(a, { [c.id]: c }), {});
+					return { calls: Object.values(callsById).sort((a, b) => a.id.localeCompare(b.id, void 0, { numeric: true })) };
+				});
+				this.sync(call.storyId);
+			}
+			sync(storyId) {
+				const synchronize = () => {
+					const { isLocked, isPlaying } = this.getState(storyId);
+					const logItems = this.getLog(storyId);
+					const pausedAt = logItems.filter(({ ancestors }) => !ancestors.length).find((item) => item.status === "waiting")?.callId;
+					const hasActive = logItems.some((item) => item.status === "active");
+					if (this.detached || isLocked || hasActive || logItems.length === 0) {
+						const payload = {
+							storyId,
+							controlStates: {
+								detached: this.detached,
+								start: false,
+								back: false,
+								goto: false,
+								next: false,
+								end: false
+							},
+							logItems
+						};
+						this.channel?.emit(EVENTS.SYNC, payload);
+						return;
+					}
+					const hasPrevious = logItems.some((item) => item.status === "done" || item.status === "error");
+					const payload = {
+						storyId,
+						controlStates: {
+							detached: this.detached,
+							start: hasPrevious,
+							back: hasPrevious,
+							goto: true,
+							next: isPlaying,
+							end: isPlaying
+						},
+						logItems,
+						pausedAt
+					};
+					this.channel?.emit(EVENTS.SYNC, payload);
+				};
+				this.setState(storyId, ({ syncTimeout }) => {
+					clearTimeout(syncTimeout);
+					return { syncTimeout: setTimeout(synchronize, 0) };
+				});
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/actions/loaders.ts
+var loaders_exports = /* @__PURE__ */ __exportAll({ loaders: () => loaders });
+var subscribed, logActionsWhenMockCalled, loaders;
+function init_loaders() {
+	return (init_loaders = __esmMin((() => {
+		init_test();
+		init_action();
+		subscribed = false;
+		logActionsWhenMockCalled = (context) => {
+			const { parameters } = context;
+			if (parameters?.actions?.disable) return;
+			if (!subscribed) {
+				onMockCall((mock, args) => {
+					const name = mock.getMockName();
+					if (name === "spy") return;
+					if (name === "vi.fn()") return;
+					if (!/^next\/.*::/.test(name) || [
+						"next/router::useRouter()",
+						"next/navigation::useRouter()",
+						"next/navigation::redirect",
+						"next/link::Link",
+						"next/cache::",
+						"next/headers::cookies().set",
+						"next/headers::cookies().delete",
+						"next/headers::headers().set",
+						"next/headers::headers().delete"
+					].some((prefix) => name.startsWith(prefix))) action(name)(args);
+				});
+				subscribed = true;
+			}
+		};
+		loaders = [logActionsWhenMockCalled];
+	})))();
+}
+//#endregion
+//#region src/actions/preview.ts
+var preview_default$5;
+function init_preview() {
+	return (init_preview = __esmMin((() => {
+		init_addArgs();
+		init_loaders();
+		preview_default$5 = () => definePreviewAddon({
+			...addArgs_exports,
+			...loaders_exports
+		});
+	})))();
+}
+//#endregion
+//#region src/backgrounds/constants.ts
+var PARAM_KEY$2;
+function init_constants$1() {
+	return (init_constants$1 = __esmMin((() => {
+		PARAM_KEY$2 = "backgrounds";
+	})))();
+}
+//#endregion
+//#region src/backgrounds/defaults.ts
+var DEFAULT_BACKGROUNDS;
+function init_defaults() {
+	return (init_defaults = __esmMin((() => {
+		DEFAULT_BACKGROUNDS = {
+			light: {
+				name: "light",
+				value: "#F8F8F8"
+			},
+			dark: {
+				name: "dark",
+				value: "#333"
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/backgrounds/utils.ts
+var document$1, isReduceMotionEnabled, clearStyles$1, clearStyle$1, addGridStyle, addBackgroundStyle;
+function init_utils() {
+	return (init_utils = __esmMin((() => {
+		({document: document$1} = globalThis);
+		isReduceMotionEnabled = () => {
+			if (!globalThis?.matchMedia) return false;
+			return !!globalThis.matchMedia("(prefers-reduced-motion: reduce)")?.matches;
+		};
+		clearStyles$1 = (selector) => {
+			(Array.isArray(selector) ? selector : [selector]).forEach(clearStyle$1);
+		};
+		clearStyle$1 = (selector) => {
+			if (!document$1) return;
+			const element = document$1.getElementById(selector);
+			if (element && element.parentElement) element.parentElement.removeChild(element);
+		};
+		addGridStyle = (selector, css) => {
+			if (!document$1) return;
+			const existingStyle = document$1.getElementById(selector);
+			if (existingStyle) {
+				if (existingStyle.innerHTML !== css) existingStyle.innerHTML = css;
+			} else {
+				const style = document$1.createElement("style");
+				style.setAttribute("id", selector);
+				style.innerHTML = css;
+				document$1.head.appendChild(style);
+			}
+		};
+		addBackgroundStyle = (selector, css, storyId) => {
+			if (!document$1) return;
+			const existingStyle = document$1.getElementById(selector);
+			if (existingStyle) {
+				if (existingStyle.innerHTML !== css) existingStyle.innerHTML = css;
+			} else {
+				const style = document$1.createElement("style");
+				style.setAttribute("id", selector);
+				style.innerHTML = css;
+				const gridStyleSelector = `addon-backgrounds-grid${storyId ? `-docs-${storyId}` : ""}`;
+				const existingGridStyle = document$1.getElementById(gridStyleSelector);
+				if (existingGridStyle) existingGridStyle.parentElement?.insertBefore(style, existingGridStyle);
+				else document$1.head.appendChild(style);
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/backgrounds/decorator.ts
+var defaultGrid, BG_SELECTOR_BASE, GRID_SELECTOR_BASE, transitionStyle, withBackgroundAndGrid;
+function init_decorator() {
+	return (init_decorator = __esmMin((() => {
+		init_preview_api$1();
+		init_constants$1();
+		init_defaults();
+		init_utils();
+		defaultGrid = {
+			cellSize: 100,
+			cellAmount: 10,
+			opacity: .8
+		};
+		BG_SELECTOR_BASE = `addon-backgrounds`;
+		GRID_SELECTOR_BASE = "addon-backgrounds-grid";
+		transitionStyle = isReduceMotionEnabled() ? "" : "transition: background-color 0.3s;";
+		withBackgroundAndGrid = (StoryFn, context) => {
+			const { globals = {}, parameters = {}, viewMode, id } = context;
+			const { options = DEFAULT_BACKGROUNDS, disable, grid = defaultGrid } = parameters["backgrounds"] || {};
+			const data = globals["backgrounds"] || {};
+			const backgroundName = typeof data === "string" ? data : data?.value;
+			const item = backgroundName ? options[backgroundName] : void 0;
+			const value = typeof item === "string" ? item : item?.value || "transparent";
+			const showGrid = typeof data === "string" ? false : data.grid || false;
+			const shownBackground = !!item && !disable;
+			const backgroundSelector = viewMode === "docs" ? `#anchor--${id} .docs-story, #anchor--primary--${id} .docs-story` : ".sb-show-main";
+			const gridSelector = viewMode === "docs" ? `#anchor--${id} .docs-story, #anchor--primary--${id} .docs-story` : ".sb-show-main";
+			const isLayoutPadded = parameters.layout === void 0 || parameters.layout === "padded";
+			const defaultOffset = viewMode === "docs" ? 20 : isLayoutPadded ? 16 : 0;
+			const { cellAmount, cellSize, opacity, offsetX = defaultOffset, offsetY = defaultOffset } = grid;
+			const backgroundSelectorId = viewMode === "docs" ? `${BG_SELECTOR_BASE}-docs-${id}` : `${BG_SELECTOR_BASE}-color`;
+			const backgroundTarget = viewMode === "docs" ? id : null;
+			useEffect(() => {
+				const backgroundStyles = `
+    ${backgroundSelector} {
+      background: ${value} !important;
+      ${transitionStyle}
+      }`;
+				if (!shownBackground) {
+					clearStyles$1(backgroundSelectorId);
+					return;
+				}
+				addBackgroundStyle(backgroundSelectorId, backgroundStyles, backgroundTarget);
+			}, [
+				backgroundSelector,
+				backgroundSelectorId,
+				backgroundTarget,
+				shownBackground,
+				value
+			]);
+			const gridSelectorId = viewMode === "docs" ? `${GRID_SELECTOR_BASE}-docs-${id}` : `${GRID_SELECTOR_BASE}`;
+			useEffect(() => {
+				if (!showGrid) {
+					clearStyles$1(gridSelectorId);
+					return;
+				}
+				const gridSize = [
+					`${cellSize * cellAmount}px ${cellSize * cellAmount}px`,
+					`${cellSize * cellAmount}px ${cellSize * cellAmount}px`,
+					`${cellSize}px ${cellSize}px`,
+					`${cellSize}px ${cellSize}px`
+				].join(", ");
+				const gridStyles = `
+        ${gridSelector} {
+          background-size: ${gridSize} !important;
+          background-position: ${offsetX}px ${offsetY}px, ${offsetX}px ${offsetY}px, ${offsetX}px ${offsetY}px, ${offsetX}px ${offsetY}px !important;
+          background-blend-mode: difference !important;
+          background-image: linear-gradient(rgba(130, 130, 130, ${opacity}) 1px, transparent 1px),
+           linear-gradient(90deg, rgba(130, 130, 130, ${opacity}) 1px, transparent 1px),
+           linear-gradient(rgba(130, 130, 130, ${opacity / 2}) 1px, transparent 1px),
+           linear-gradient(90deg, rgba(130, 130, 130, ${opacity / 2}) 1px, transparent 1px) !important;
+        }
+      `;
+				addGridStyle(gridSelectorId, gridStyles);
+			}, [
+				cellAmount,
+				cellSize,
+				gridSelector,
+				gridSelectorId,
+				showGrid,
+				offsetX,
+				offsetY,
+				opacity
+			]);
+			return StoryFn();
+		};
+	})))();
+}
+//#endregion
+//#region src/backgrounds/preview.ts
+var decorators$2, parameters, initialGlobals$2, preview_default$4;
+function init_preview$1() {
+	return (init_preview$1 = __esmMin((() => {
+		init_constants$1();
+		init_decorator();
+		decorators$2 = globalThis.FEATURES?.backgrounds ? [withBackgroundAndGrid] : [];
+		parameters = { [PARAM_KEY$2]: {
+			grid: {
+				cellSize: 20,
+				opacity: .5,
+				cellAmount: 5
+			},
+			disable: false
+		} };
+		initialGlobals$2 = { [PARAM_KEY$2]: {
+			value: void 0,
+			grid: false
+		} };
+		preview_default$4 = () => definePreviewAddon({
+			decorators: decorators$2,
+			parameters,
+			initialGlobals: initialGlobals$2
+		});
+	})))();
+}
+//#endregion
+//#region src/component-testing/preview.ts
+var step, preview_default$3;
+function init_preview$2() {
+	return (init_preview$2 = __esmMin((() => {
+		init_instrumenter();
+		({step} = instrument({ step: async (label, play, context) => play(context) }, { intercept: true }));
+		preview_default$3 = () => definePreviewAddon({
+			parameters: { throwPlayFunctionExceptions: false },
+			runStep: step
+		});
+	})))();
+}
+//#endregion
+//#region src/core-server/utils/ghost-stories/test-annotations.ts
+var isEmptyRender, afterEach, test_annotations_default;
+function init_test_annotations() {
+	return (init_test_annotations = __esmMin((() => {
+		isEmptyRender = (element) => {
+			const style = getComputedStyle(element);
+			const rect = element.getBoundingClientRect();
+			return !(rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && Number(style.opacity) > 0 && style.display !== "none");
+		};
+		afterEach = async ({ reporting, canvasElement, globals }) => {
+			try {
+				if (!globals.renderAnalysis?.enabled) return;
+				const emptyRender = isEmptyRender(canvasElement.firstElementChild ?? canvasElement);
+				if (emptyRender) reporting.addReport({
+					type: "render-analysis",
+					version: 1,
+					result: { emptyRender },
+					status: "warning"
+				});
+			} catch {}
+		};
+		test_annotations_default = () => definePreviewAddon({ afterEach });
+	})))();
+}
+//#endregion
+//#region src/highlight/constants.ts
+var ADDON_ID$1, HIGHLIGHT, REMOVE_HIGHLIGHT, RESET_HIGHLIGHT, SCROLL_INTO_VIEW, MAX_Z_INDEX;
+function init_constants$2() {
+	return (init_constants$2 = __esmMin((() => {
+		ADDON_ID$1 = "@aussieljk/forkbook/highlight";
+		HIGHLIGHT = `${ADDON_ID$1}/add`;
+		REMOVE_HIGHLIGHT = `${ADDON_ID$1}/remove`;
+		RESET_HIGHLIGHT = `${ADDON_ID$1}/reset`;
+		SCROLL_INTO_VIEW = `${ADDON_ID$1}/scroll-into-view`;
+		`${ADDON_ID$1}`;
+		MAX_Z_INDEX = 2147483647;
+	})))();
+}
+//#endregion
+//#region src/highlight/icons.ts
+var iconPaths;
+function init_icons() {
+	return (init_icons = __esmMin((() => {
+		iconPaths = {
+			chevronLeft: ["M9.10355 10.1464C9.29882 10.3417 9.29882 10.6583 9.10355 10.8536C8.90829 11.0488 8.59171 11.0488 8.39645 10.8536L4.89645 7.35355C4.70118 7.15829 4.70118 6.84171 4.89645 6.64645L8.39645 3.14645C8.59171 2.95118 8.90829 2.95118 9.10355 3.14645C9.29882 3.34171 9.29882 3.65829 9.10355 3.85355L5.95711 7L9.10355 10.1464Z"],
+			chevronRight: ["M4.89645 10.1464C4.70118 10.3417 4.70118 10.6583 4.89645 10.8536C5.09171 11.0488 5.40829 11.0488 5.60355 10.8536L9.10355 7.35355C9.29882 7.15829 9.29882 6.84171 9.10355 6.64645L5.60355 3.14645C5.40829 2.95118 5.09171 2.95118 4.89645 3.14645C4.70118 3.34171 4.70118 3.65829 4.89645 3.85355L8.04289 7L4.89645 10.1464Z"],
+			info: ["M7 5.5a.5.5 0 01.5.5v4a.5.5 0 01-1 0V6a.5.5 0 01.5-.5zM7 4.5A.75.75 0 107 3a.75.75 0 000 1.5z", "M7 14A7 7 0 107 0a7 7 0 000 14zm0-1A6 6 0 107 1a6 6 0 000 12z"],
+			shareAlt: ["M2 1.004a1 1 0 00-1 1v10a1 1 0 001 1h10a1 1 0 001-1v-4.5a.5.5 0 00-1 0v4.5H2v-10h4.5a.5.5 0 000-1H2z", "M7.354 7.357L12 2.711v1.793a.5.5 0 001 0v-3a.5.5 0 00-.5-.5h-3a.5.5 0 100 1h1.793L6.646 6.65a.5.5 0 10.708.707z"]
+		};
+	})))();
+}
+//#endregion
+//#region src/highlight/utils.ts
+var svgElements, createElement, createIcon, normalizeOptions, isFunction, state$1, listeners, teardowns, useStore, mapElements, mapBoxes, isOverMenu, isTargeted, keepInViewport, showPopover, hidePopover, getEventDetails;
+function init_utils$1() {
+	return (init_utils$1 = __esmMin((() => {
+		init_constants$2();
+		init_icons();
+		svgElements = "svg,path,rect,circle,line,polyline,polygon,ellipse,text".split(",");
+		createElement = (type, props = {}, children) => {
+			const element = svgElements.includes(type) ? document.createElementNS("http://www.w3.org/2000/svg", type) : document.createElement(type);
+			Object.entries(props).forEach(([key, val]) => {
+				if (/[A-Z]/.test(key)) {
+					if (key === "onClick") {
+						element.addEventListener("click", val);
+						element.addEventListener("keydown", (e) => {
+							if (e.key === "Enter" || e.key === " ") {
+								e.preventDefault();
+								val();
+							}
+						});
+					}
+					if (key === "onMouseEnter") element.addEventListener("mouseenter", val);
+					if (key === "onMouseLeave") element.addEventListener("mouseleave", val);
+				} else element.setAttribute(key, val);
+			});
+			children?.forEach((child) => {
+				if (child === null || child === void 0 || child === false) return;
+				try {
+					element.appendChild(child);
+				} catch (e) {
+					element.appendChild(document.createTextNode(String(child)));
+				}
+			});
+			return element;
+		};
+		createIcon = (name) => iconPaths[name] && createElement("svg", {
+			width: "14",
+			height: "14",
+			viewBox: "0 0 14 14",
+			xmlns: "http://www.w3.org/2000/svg"
+		}, iconPaths[name].map((d) => createElement("path", {
+			fill: "currentColor",
+			"fill-rule": "evenodd",
+			"clip-rule": "evenodd",
+			d
+		})));
+		normalizeOptions = (options) => {
+			const { menu, ...rest } = options;
+			return {
+				priority: 0,
+				styles: { outline: "2px dashed #029cfd" },
+				...rest,
+				menu: Array.isArray(menu) ? menu.every(Array.isArray) ? menu : [menu] : void 0
+			};
+		};
+		isFunction = (obj) => obj instanceof Function;
+		state$1 = /* @__PURE__ */ new Map();
+		listeners = /* @__PURE__ */ new Map();
+		teardowns = /* @__PURE__ */ new Map();
+		useStore = (initialValue) => {
+			const key = Symbol();
+			listeners.set(key, []);
+			state$1.set(key, initialValue);
+			const get = () => state$1.get(key);
+			const set = (update) => {
+				const current = state$1.get(key);
+				const next = isFunction(update) ? update(current) : update;
+				if (next !== current) {
+					state$1.set(key, next);
+					listeners.get(key)?.forEach((listener) => {
+						teardowns.get(listener)?.();
+						teardowns.set(listener, listener(next));
+					});
+				}
+			};
+			const subscribe = (listener) => {
+				listeners.get(key)?.push(listener);
+				return () => {
+					const list = listeners.get(key);
+					if (list) listeners.set(key, list.filter((l) => l !== listener));
+				};
+			};
+			const teardown = () => {
+				listeners.get(key)?.forEach((listener) => {
+					teardowns.get(listener)?.();
+					teardowns.delete(listener);
+				});
+				listeners.delete(key);
+				state$1.delete(key);
+			};
+			return {
+				get,
+				set,
+				subscribe,
+				teardown
+			};
+		};
+		mapElements = (highlights) => {
+			const root = document.getElementById("storybook-root");
+			const map = /* @__PURE__ */ new Map();
+			for (const highlight of highlights) {
+				const { priority = 0 } = highlight;
+				for (const selector of highlight.selectors) {
+					const elements = [...document.querySelectorAll(`:is(${selector}):not([id^="storybook-"], [id^="storybook-"] *, [class^="sb-"], [class^="sb-"] *)`), ...root?.querySelectorAll(selector) || []];
+					for (const element of elements) {
+						const existing = map.get(element);
+						if (!existing || existing.priority <= priority) map.set(element, {
+							...highlight,
+							priority,
+							selectors: Array.from(new Set((existing?.selectors || []).concat(selector)))
+						});
+					}
+				}
+			}
+			return map;
+		};
+		mapBoxes = (elements) => Array.from(elements.entries()).map(([element, { id, selectors, styles, hoverStyles, focusStyles, menu }]) => {
+			const { top, left, width, height } = element.getBoundingClientRect();
+			const { position } = getComputedStyle(element);
+			return {
+				element,
+				id,
+				selectors,
+				styles,
+				hoverStyles,
+				focusStyles,
+				menu,
+				top: position === "fixed" ? top : top + window.scrollY,
+				left: position === "fixed" ? left : left + window.scrollX,
+				width,
+				height
+			};
+		}).sort((a, b) => b.width * b.height - a.width * a.height);
+		isOverMenu = (menuElement, coordinates) => {
+			const menu = menuElement.getBoundingClientRect();
+			const { x, y } = coordinates;
+			return menu?.top && menu?.left && x >= menu.left && x <= menu.left + menu.width && y >= menu.top && y <= menu.top + menu.height;
+		};
+		isTargeted = (box, boxElement, coordinates) => {
+			if (!boxElement || !coordinates) return false;
+			let { left, top, width, height } = box;
+			if (height < 28) {
+				top = top - Math.round((28 - height) / 2);
+				height = 28;
+			}
+			if (width < 28) {
+				left = left - Math.round((28 - width) / 2);
+				width = 28;
+			}
+			if (boxElement.style.position === "fixed") {
+				left += window.scrollX;
+				top += window.scrollY;
+			}
+			const { x, y } = coordinates;
+			return x >= left && x <= left + width && y >= top && y <= top + height;
+		};
+		keepInViewport = (element, targetCoordinates, options = {}) => {
+			const { x, y } = targetCoordinates;
+			const { margin = 5, topOffset = 0, centered = false } = options;
+			const { scrollX, scrollY, innerHeight: windowHeight, innerWidth: windowWidth } = window;
+			const top = Math.min(element.style.position === "fixed" ? y - scrollY : y, windowHeight - element.clientHeight - margin - topOffset + scrollY);
+			const leftOffset = centered ? element.clientWidth / 2 : 0;
+			const left = element.style.position === "fixed" ? Math.max(Math.min(x - scrollX, windowWidth - leftOffset - margin), leftOffset + margin) : Math.max(Math.min(x, windowWidth - leftOffset - margin + scrollX), leftOffset + margin + scrollX);
+			Object.assign(element.style, {
+				...left !== x && { left: `${left}px` },
+				...top !== y && { top: `${top}px` }
+			});
+		};
+		showPopover = (element) => {
+			if (window.HTMLElement.prototype.hasOwnProperty("showPopover")) element.showPopover();
+		};
+		hidePopover = (element) => {
+			if (window.HTMLElement.prototype.hasOwnProperty("showPopover")) element.hidePopover();
+		};
+		getEventDetails = (target) => ({
+			top: target.top,
+			left: target.left,
+			width: target.width,
+			height: target.height,
+			selectors: target.selectors,
+			element: {
+				localName: target.element.localName,
+				tagName: target.element.tagName
+			}
+		});
+	})))();
+}
+//#endregion
+//#region src/highlight/useHighlights.ts
+var menuId, rootId, storybookRootId, useHighlights;
+function init_useHighlights() {
+	return (init_useHighlights = __esmMin((() => {
+		init_client_logger();
+		init_core_events();
+		init_constants$2();
+		init_utils$1();
+		menuId = "storybook-highlights-menu";
+		rootId = "storybook-highlights-root";
+		storybookRootId = "storybook-root";
+		useHighlights = (channel) => {
+			if (globalThis.__STORYBOOK_HIGHLIGHT_INITIALIZED) return;
+			globalThis.__STORYBOOK_HIGHLIGHT_INITIALIZED = true;
+			const { document } = globalThis;
+			const highlights = useStore([]);
+			const elements = useStore(/* @__PURE__ */ new Map());
+			const boxes = useStore([]);
+			const clickCoords = useStore();
+			const hoverCoords = useStore();
+			const targets = useStore([]);
+			const hovered = useStore([]);
+			const focused = useStore();
+			const selected = useStore();
+			let root = document.getElementById(rootId);
+			highlights.subscribe(() => {
+				if (!root) {
+					root = createElement("div", { id: rootId });
+					document.body.appendChild(root);
+				}
+			});
+			highlights.subscribe((value) => {
+				const storybookRoot = document.getElementById(storybookRootId) ?? document.body;
+				elements.set(mapElements(value));
+				const observer = new MutationObserver((records) => {
+					if (records.some((record) => !root?.contains(record.target))) elements.set(mapElements(value));
+				});
+				observer.observe(storybookRoot, {
+					subtree: true,
+					childList: true
+				});
+				return () => {
+					observer.disconnect();
+				};
+			});
+			elements.subscribe((value) => {
+				const updateBoxes = () => requestAnimationFrame(() => boxes.set(mapBoxes(value)));
+				const observer = new ResizeObserver(updateBoxes);
+				observer.observe(document.body);
+				Array.from(value.keys()).forEach((element) => observer.observe(element));
+				const scrollers = Array.from(document.body.querySelectorAll("*")).filter((el) => {
+					const { overflow, overflowX, overflowY } = window.getComputedStyle(el);
+					return ["auto", "scroll"].some((o) => [
+						overflow,
+						overflowX,
+						overflowY
+					].includes(o));
+				});
+				scrollers.forEach((element) => element.addEventListener("scroll", updateBoxes));
+				return () => {
+					observer.disconnect();
+					scrollers.forEach((element) => element.removeEventListener("scroll", updateBoxes));
+				};
+			});
+			elements.subscribe((value) => {
+				const sticky = Array.from(value.keys()).filter(({ style }) => style.position === "sticky");
+				const updateBoxes = () => requestAnimationFrame(() => {
+					boxes.set((current) => current.map((box) => {
+						if (sticky.includes(box.element)) {
+							const { top, left } = box.element.getBoundingClientRect();
+							return {
+								...box,
+								top: top + window.scrollY,
+								left: left + window.scrollX
+							};
+						}
+						return box;
+					}));
+				});
+				document.addEventListener("scroll", updateBoxes);
+				return () => document.removeEventListener("scroll", updateBoxes);
+			});
+			elements.subscribe((value) => {
+				targets.set((t) => t.filter(({ element }) => value.has(element)));
+			});
+			targets.subscribe((value) => {
+				if (value.length) {
+					selected.set((s) => value.some((t) => t.element === s?.element) ? s : void 0);
+					focused.set((s) => value.some((t) => t.element === s?.element) ? s : void 0);
+				} else {
+					selected.set(void 0);
+					focused.set(void 0);
+					clickCoords.set(void 0);
+				}
+			});
+			const styleElementByHighlight = /* @__PURE__ */ new Map(/* @__PURE__ */ new Map());
+			highlights.subscribe((value) => {
+				value.forEach(({ keyframes }) => {
+					if (keyframes) {
+						let style = styleElementByHighlight.get(keyframes);
+						if (!style) {
+							style = document.createElement("style");
+							style.setAttribute("data-highlight", "keyframes");
+							styleElementByHighlight.set(keyframes, style);
+							document.head.appendChild(style);
+						}
+						style.innerHTML = keyframes;
+					}
+				});
+				styleElementByHighlight.forEach((style, keyframes) => {
+					if (!value.some((v) => v.keyframes === keyframes)) {
+						style.remove();
+						styleElementByHighlight.delete(keyframes);
+					}
+				});
+			});
+			const boxElementByTargetElement = /* @__PURE__ */ new Map(/* @__PURE__ */ new Map());
+			boxes.subscribe((value) => {
+				value.forEach((box) => {
+					let boxElement = boxElementByTargetElement.get(box.element);
+					if (root && !boxElement) {
+						const props = {
+							popover: "manual",
+							"data-highlight-dimensions": `w${box.width.toFixed(0)}h${box.height.toFixed(0)}`,
+							"data-highlight-coordinates": `x${box.left.toFixed(0)}y${box.top.toFixed(0)}`
+						};
+						boxElement = root.appendChild(createElement("div", props, [createElement("div")]));
+						boxElementByTargetElement.set(box.element, boxElement);
+					}
+				});
+				boxElementByTargetElement.forEach((box, element) => {
+					if (!value.some(({ element: e }) => e === element)) {
+						box.remove();
+						boxElementByTargetElement.delete(element);
+					}
+				});
+			});
+			boxes.subscribe((value) => {
+				const targetable = value.filter((box) => box.menu);
+				if (!targetable.length) return;
+				const onClick = (event) => {
+					requestAnimationFrame(() => {
+						const menu = document.getElementById(menuId);
+						const coords = {
+							x: event.pageX,
+							y: event.pageY
+						};
+						if (menu && !isOverMenu(menu, coords)) {
+							const results = targetable.filter((box) => {
+								const boxElement = boxElementByTargetElement.get(box.element);
+								return isTargeted(box, boxElement, coords);
+							});
+							clickCoords.set(results.length ? coords : void 0);
+							targets.set(results);
+						}
+					});
+				};
+				document.addEventListener("click", onClick);
+				return () => document.removeEventListener("click", onClick);
+			});
+			const updateHovered = () => {
+				const menu = document.getElementById(menuId);
+				const coords = hoverCoords.get();
+				if (!coords || menu && isOverMenu(menu, coords)) return;
+				hovered.set((current) => {
+					const update = boxes.get().filter((box) => {
+						const boxElement = boxElementByTargetElement.get(box.element);
+						return isTargeted(box, boxElement, coords);
+					});
+					const existing = current.filter((box) => update.includes(box));
+					const additions = update.filter((box) => !current.includes(box));
+					const hasRemovals = current.length - existing.length;
+					return additions.length || hasRemovals ? [...existing, ...additions] : current;
+				});
+			};
+			hoverCoords.subscribe(updateHovered);
+			boxes.subscribe(updateHovered);
+			const updateBoxStyles = () => {
+				const selectedElement = selected.get();
+				const targetElements = selectedElement ? [selectedElement] : targets.get();
+				const focusedElement = targetElements.length === 1 ? targetElements[0] : focused.get();
+				const isMenuOpen = clickCoords.get() !== void 0;
+				boxes.get().forEach((box) => {
+					const boxElement = boxElementByTargetElement.get(box.element);
+					if (boxElement) {
+						const isFocused = focusedElement === box;
+						const isHovered = isMenuOpen ? focusedElement ? isFocused : targetElements.includes(box) : hovered.get()?.includes(box);
+						Object.assign(boxElement.style, {
+							animation: "none",
+							background: "transparent",
+							border: "none",
+							boxSizing: "border-box",
+							outline: "none",
+							outlineOffset: "0px",
+							...box.styles,
+							...isHovered ? box.hoverStyles : {},
+							...isFocused ? box.focusStyles : {},
+							position: getComputedStyle(box.element).position === "fixed" ? "fixed" : "absolute",
+							zIndex: MAX_Z_INDEX - 10,
+							top: `${box.top}px`,
+							left: `${box.left}px`,
+							width: `${box.width}px`,
+							height: `${box.height}px`,
+							margin: 0,
+							padding: 0,
+							cursor: box.menu && isHovered ? "pointer" : "default",
+							pointerEvents: box.menu ? "auto" : "none",
+							display: "flex",
+							alignItems: "center",
+							justifyContent: "center",
+							overflow: "visible"
+						});
+						Object.assign(boxElement.children[0].style, {
+							width: "100%",
+							height: "100%",
+							minHeight: `28px`,
+							minWidth: `28px`,
+							boxSizing: "content-box",
+							padding: boxElement.style.outlineWidth || "0px"
+						});
+						showPopover(boxElement);
+					}
+				});
+			};
+			boxes.subscribe(updateBoxStyles);
+			targets.subscribe(updateBoxStyles);
+			hovered.subscribe(updateBoxStyles);
+			focused.subscribe(updateBoxStyles);
+			selected.subscribe(updateBoxStyles);
+			const renderMenu = () => {
+				if (!root) return;
+				let menu = document.getElementById(menuId);
+				if (menu) menu.innerHTML = "";
+				else {
+					const props = {
+						id: menuId,
+						popover: "manual"
+					};
+					menu = root.appendChild(createElement("div", props));
+					root.appendChild(createElement("style", {}, [`
+            #${menuId} {
+              position: absolute;
+              z-index: ${MAX_Z_INDEX};
+              width: 300px;
+              padding: 0px;
+              margin: 15px 0 0 0;
+              transform: translateX(-50%);
+              font-family: "Nunito Sans", -apple-system, ".SFNSText-Regular", "San Francisco", BlinkMacSystemFont, "Segoe UI", "Helvetica Neue", Helvetica, Arial, sans-serif;
+              font-size: 12px;
+              background: white;
+              border: none;
+              border-radius: 6px;
+              box-shadow: 0 2px 5px 0 rgba(0, 0, 0, 0.05), 0 5px 15px 0 rgba(0, 0, 0, 0.1);
+              color: #2E3438;
+            }
+            #${menuId} ul {
+              list-style: none;
+              margin: 0;
+              padding: 0;
+            }
+            #${menuId} > ul {
+              max-height: 300px;
+              overflow-y: auto;
+              padding: 4px 0;
+            }
+            #${menuId} li {
+              padding: 0 4px;
+              margin: 0;
+            }
+            #${menuId} li > :not(ul) {
+              display: flex;
+              padding: 8px;
+              margin: 0;
+              align-items: center;
+              gap: 8px;
+              border-radius: 4px;
+            }
+            #${menuId} button {
+              width: 100%;
+              border: 0;
+              background: transparent;
+              color: inherit;
+              text-align: left;
+              font-family: inherit;
+              font-size: inherit;
+            }
+            #${menuId} button:focus-visible {
+              outline-color: #029CFD;
+            }
+            #${menuId} button:hover {
+              background: rgba(2, 156, 253, 0.07);
+              color: #029CFD;
+              cursor: pointer;
+            }
+            #${menuId} li code {
+              white-space: nowrap;
+              overflow: hidden;
+              text-overflow: ellipsis;
+              line-height: 16px;
+              font-size: 11px;
+            }
+            #${menuId} li svg {
+              flex-shrink: 0;
+              margin: 1px;
+              color: #73828C;
+            }
+            #${menuId} li > button:hover svg, #${menuId} li > button:focus-visible svg {
+              color: #029CFD;
+            }
+            #${menuId} .element-list li svg {
+              display: none;
+            }
+            #${menuId} li.selectable svg, #${menuId} li.selected svg {
+              display: block;
+            }
+            #${menuId} .menu-list {
+              border-top: 1px solid rgba(38, 85, 115, 0.15);
+            }
+            #${menuId} .menu-list > li:not(:last-child) {
+              padding-bottom: 4px;
+              margin-bottom: 4px;
+              border-bottom: 1px solid rgba(38, 85, 115, 0.15);
+            }
+            #${menuId} .menu-items, #${menuId} .menu-items li {
+              padding: 0;
+            }
+            #${menuId} .menu-item {
+              display: flex;
+            }
+            #${menuId} .menu-item-content {
+              display: flex;
+              flex-direction: column;
+              flex-grow: 1;
+            }
+          `]));
+				}
+				const selectedElement = selected.get();
+				const elementList = selectedElement ? [selectedElement] : targets.get();
+				if (elementList.length) {
+					menu.style.position = getComputedStyle(elementList[0].element).position === "fixed" ? "fixed" : "absolute";
+					menu.appendChild(createElement("ul", { class: "element-list" }, elementList.map((target) => {
+						const selectable = elementList.length > 1 && !!target.menu?.some((group) => group.some((item) => !item.selectors || item.selectors.some((s) => target.selectors.includes(s))));
+						const props = selectable ? {
+							class: "selectable",
+							onClick: () => selected.set(target),
+							onMouseEnter: () => focused.set(target),
+							onMouseLeave: () => focused.set(void 0)
+						} : selectedElement ? {
+							class: "selected",
+							onClick: () => selected.set(void 0)
+						} : {};
+						const asButton = selectable || selectedElement;
+						return createElement("li", props, [createElement(asButton ? "button" : "div", asButton ? { type: "button" } : {}, [
+							selectedElement ? createIcon("chevronLeft") : null,
+							createElement("code", {}, [target.element.outerHTML]),
+							selectable ? createIcon("chevronRight") : null
+						])]);
+					})));
+				}
+				if (selected.get() || targets.get().length === 1) {
+					const target = selected.get() || targets.get()[0];
+					const menuGroups = target.menu?.filter((group) => group.some((item) => !item.selectors || item.selectors.some((s) => target.selectors.includes(s))));
+					if (menuGroups?.length) menu.appendChild(createElement("ul", { class: "menu-list" }, menuGroups.map((menuItems) => createElement("li", {}, [createElement("ul", { class: "menu-items" }, menuItems.map(({ id, title, description, iconLeft, iconRight, clickable }) => {
+						const onClick = clickable && (() => channel.emit("@aussieljk/forkbook/highlight/menu-click", target.id, id, getEventDetails(target)));
+						return createElement("li", {}, [createElement(onClick ? "button" : "div", onClick ? {
+							class: "menu-item",
+							type: "button",
+							onClick
+						} : { class: "menu-item" }, [
+							iconLeft ? createIcon(iconLeft) : null,
+							createElement("div", { class: "menu-item-content" }, [createElement(description ? "strong" : "span", {}, [title]), description && createElement("span", {}, [description])]),
+							iconRight ? createIcon(iconRight) : null
+						])]);
+					}))]))));
+				}
+				const coords = clickCoords.get();
+				if (coords) {
+					Object.assign(menu.style, {
+						display: "block",
+						left: `${menu.style.position === "fixed" ? coords.x - window.scrollX : coords.x}px`,
+						top: `${menu.style.position === "fixed" ? coords.y - window.scrollY : coords.y}px`
+					});
+					showPopover(menu);
+					requestAnimationFrame(() => keepInViewport(menu, coords, {
+						topOffset: 15,
+						centered: true
+					}));
+				} else {
+					hidePopover(menu);
+					Object.assign(menu.style, { display: "none" });
+				}
+			};
+			targets.subscribe(renderMenu);
+			selected.subscribe(renderMenu);
+			const addHighlight = (highlight) => {
+				const info = highlight && normalizeOptions(highlight);
+				if (typeof info?.id !== "string" || !info.id) {
+					logger.warn("Ignoring highlight without an id", highlight);
+					return;
+				}
+				highlights.set((value) => {
+					const others = value.filter((h) => h.id !== info.id);
+					return info.selectors?.length ? [...others, info] : others;
+				});
+			};
+			const removeHighlight = (id) => {
+				if (id) highlights.set((value) => value.filter((h) => h.id !== id));
+			};
+			const resetState = () => {
+				highlights.set([]);
+				elements.set(/* @__PURE__ */ new Map());
+				boxes.set([]);
+				clickCoords.set(void 0);
+				hoverCoords.set(void 0);
+				targets.set([]);
+				hovered.set([]);
+				focused.set(void 0);
+				selected.set(void 0);
+			};
+			let removeTimeout;
+			const scrollIntoView = (target, options) => {
+				const id = "scrollIntoView-highlight";
+				clearTimeout(removeTimeout);
+				removeHighlight(id);
+				const element = document.querySelector(target);
+				if (!element) {
+					logger.warn(`Cannot scroll into view: ${target} not found`);
+					return;
+				}
+				element.scrollIntoView({
+					behavior: "smooth",
+					block: "center",
+					...options
+				});
+				const keyframeName = `kf-${Math.random().toString(36).substring(2, 15)}`;
+				highlights.set((value) => [...value, {
+					id,
+					priority: 1e3,
+					selectors: [target],
+					styles: {
+						outline: "2px solid #1EA7FD",
+						outlineOffset: "-1px",
+						animation: `${keyframeName} 3s linear forwards`
+					},
+					keyframes: `@keyframes ${keyframeName} {
+          0% { outline: 2px solid #1EA7FD; }
+          20% { outline: 2px solid #1EA7FD00; }
+          40% { outline: 2px solid #1EA7FD; }
+          60% { outline: 2px solid #1EA7FD00; }
+          80% { outline: 2px solid #1EA7FD; }
+          100% { outline: 2px solid #1EA7FD00; }
+        }`
+				}]);
+				removeTimeout = setTimeout(() => removeHighlight(id), 3500);
+			};
+			const onMouseMove = (event) => {
+				requestAnimationFrame(() => hoverCoords.set({
+					x: event.pageX,
+					y: event.pageY
+				}));
+			};
+			document.body.addEventListener("mousemove", onMouseMove);
+			channel.on(HIGHLIGHT, addHighlight);
+			channel.on(REMOVE_HIGHLIGHT, removeHighlight);
+			channel.on(RESET_HIGHLIGHT, resetState);
+			channel.on(SCROLL_INTO_VIEW, scrollIntoView);
+			channel.on(STORY_RENDER_PHASE_CHANGED, ({ newPhase }) => {
+				if (newPhase === "loading") resetState();
+			});
+		};
+	})))();
+}
+//#endregion
+//#region src/highlight/preview.ts
+var preview_default$2;
+function init_preview$3() {
+	return (init_preview$3 = __esmMin((() => {
+		init_preview_api$1();
+		init_useHighlights();
+		if (globalThis?.FEATURES?.highlight && addons$1?.ready) addons$1.ready().then(useHighlights);
+		preview_default$2 = () => definePreviewAddon({});
+	})))();
+}
+//#endregion
+//#region src/measure/constants.ts
+var PARAM_KEY$1;
+function init_constants$3() {
+	return (init_constants$3 = __esmMin((() => {
+		PARAM_KEY$1 = "measureEnabled";
+	})))();
+}
+//#endregion
+//#region src/measure/box-model/canvas.ts
+function getDocumentWidthAndHeight() {
+	const container = scope.document.documentElement;
+	const height = Math.max(container.scrollHeight, container.offsetHeight);
+	return {
+		width: Math.max(container.scrollWidth, container.offsetWidth),
+		height
+	};
+}
+function createCanvas() {
+	const canvas = scope.document.createElement("canvas");
+	canvas.id = "storybook-addon-measure";
+	const context = canvas.getContext("2d");
+	invariant(context != null);
+	const { width, height } = getDocumentWidthAndHeight();
+	setCanvasWidthAndHeight(canvas, context, {
+		width,
+		height
+	});
+	canvas.style.position = "absolute";
+	canvas.style.left = "0";
+	canvas.style.top = "0";
+	canvas.style.zIndex = "2147483647";
+	canvas.style.pointerEvents = "none";
+	scope.document.body.appendChild(canvas);
+	return {
+		canvas,
+		context,
+		width,
+		height
+	};
+}
+function setCanvasWidthAndHeight(canvas, context, { width, height }) {
+	canvas.style.width = `${width}px`;
+	canvas.style.height = `${height}px`;
+	const scale = scope.window.devicePixelRatio;
+	canvas.width = Math.floor(width * scale);
+	canvas.height = Math.floor(height * scale);
+	context.scale(scale, scale);
+}
+function init() {
+	if (!state.canvas) state = createCanvas();
+}
+function clear() {
+	if (state.context) state.context.clearRect(0, 0, state.width ?? 0, state.height ?? 0);
+}
+function draw(callback) {
+	clear();
+	callback(state.context);
+}
+function rescale() {
+	invariant(state.canvas, "Canvas should exist in the state.");
+	invariant(state.context, "Context should exist in the state.");
+	setCanvasWidthAndHeight(state.canvas, state.context, {
+		width: 0,
+		height: 0
+	});
+	const { width, height } = getDocumentWidthAndHeight();
+	setCanvasWidthAndHeight(state.canvas, state.context, {
+		width,
+		height
+	});
+	state.width = width;
+	state.height = height;
+}
+function destroy() {
+	if (state.canvas) {
+		clear();
+		state.canvas.parentNode?.removeChild(state.canvas);
+		state = {};
+	}
+}
+var state;
+function init_canvas() {
+	return (init_canvas = __esmMin((() => {
+		init_dist$1();
+		init_tiny_invariant();
+		state = {};
+	})))();
+}
+//#endregion
+//#region src/measure/box-model/labels.ts
+function roundedRect(context, { x, y, w, h, r }) {
+	x = x - w / 2;
+	y = y - h / 2;
+	if (w < 2 * r) r = w / 2;
+	if (h < 2 * r) r = h / 2;
+	context.beginPath();
+	context.moveTo(x + r, y);
+	context.arcTo(x + w, y, x + w, y + h, r);
+	context.arcTo(x + w, y + h, x, y + h, r);
+	context.arcTo(x, y + h, x, y, r);
+	context.arcTo(x, y, x + w, y, r);
+	context.closePath();
+}
+function positionCoordinate(position, { padding, border, width, height, top, left }) {
+	const contentWidth = width - border.left - border.right - padding.left - padding.right;
+	const contentHeight = height - padding.top - padding.bottom - border.top - border.bottom;
+	let x = left + border.left + padding.left;
+	let y = top + border.top + padding.top;
+	if (position === "top") x += contentWidth / 2;
+	else if (position === "right") {
+		x += contentWidth;
+		y += contentHeight / 2;
+	} else if (position === "bottom") {
+		x += contentWidth / 2;
+		y += contentHeight;
+	} else if (position === "left") y += contentHeight / 2;
+	else if (position === "center") {
+		x += contentWidth / 2;
+		y += contentHeight / 2;
+	}
+	return {
+		x,
+		y
+	};
+}
+/**
+* Offset the label based on how many layers appear before it For example: margin labels will shift
+* further outwards if there are padding labels
+*/
+function offset(type, position, { margin, border, padding }, labelPaddingSize, external) {
+	let shift = (dir) => 0;
+	let offsetX = 0;
+	let offsetY = 0;
+	const locationMultiplier = external ? 1 : .5;
+	const labelPaddingShift = external ? labelPaddingSize * 2 : 0;
+	if (type === "padding") shift = (dir) => padding[dir] * locationMultiplier + labelPaddingShift;
+	else if (type === "border") shift = (dir) => padding[dir] + border[dir] * locationMultiplier + labelPaddingShift;
+	else if (type === "margin") shift = (dir) => padding[dir] + border[dir] + margin[dir] * locationMultiplier + labelPaddingShift;
+	if (position === "top") offsetY = -shift("top");
+	else if (position === "right") offsetX = shift("right");
+	else if (position === "bottom") offsetY = shift("bottom");
+	else if (position === "left") offsetX = -shift("left");
+	return {
+		offsetX,
+		offsetY
+	};
+}
+function collide(a, b) {
+	return Math.abs(a.x - b.x) < Math.abs(a.w + b.w) / 2 && Math.abs(a.y - b.y) < Math.abs(a.h + b.h) / 2;
+}
+function overlapAdjustment(position, currentRect, prevRect) {
+	if (position === "top") currentRect.y = prevRect.y - prevRect.h - labelPadding;
+	else if (position === "right") currentRect.x = prevRect.x + prevRect.w / 2 + labelPadding + currentRect.w / 2;
+	else if (position === "bottom") currentRect.y = prevRect.y + prevRect.h + labelPadding;
+	else if (position === "left") currentRect.x = prevRect.x - prevRect.w / 2 - labelPadding - currentRect.w / 2;
+	return {
+		x: currentRect.x,
+		y: currentRect.y
+	};
+}
+function textWithRect(context, type, { x, y, w, h }, text) {
+	roundedRect(context, {
+		x,
+		y,
+		w,
+		h,
+		r: 3
+	});
+	context.fillStyle = `${colors$1[type]}dd`;
+	context.fill();
+	context.strokeStyle = colors$1[type];
+	context.stroke();
+	context.fillStyle = colors$1.text;
+	context.fillText(text, x, y);
+	roundedRect(context, {
+		x,
+		y,
+		w,
+		h,
+		r: 3
+	});
+	context.fillStyle = `${colors$1[type]}dd`;
+	context.fill();
+	context.strokeStyle = colors$1[type];
+	context.stroke();
+	context.fillStyle = colors$1.text;
+	context.fillText(text, x, y);
+	return {
+		x,
+		y,
+		w,
+		h
+	};
+}
+function configureText(context, text) {
+	context.font = "600 12px monospace";
+	context.textBaseline = "middle";
+	context.textAlign = "center";
+	const metrics = context.measureText(text);
+	const actualHeight = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+	return {
+		w: metrics.width + 12,
+		h: actualHeight + 12
+	};
+}
+function drawLabel(context, measurements, { type, position = "center", text }, prevRect, external = false) {
+	let { x, y } = positionCoordinate(position, measurements);
+	const { offsetX, offsetY } = offset(type, position, measurements, 7, external);
+	x += offsetX;
+	y += offsetY;
+	const { w, h } = configureText(context, text);
+	if (prevRect && collide({
+		x,
+		y,
+		w,
+		h
+	}, prevRect)) {
+		const adjusted = overlapAdjustment(position, {
+			x,
+			y,
+			w,
+			h
+		}, prevRect);
+		x = adjusted.x;
+		y = adjusted.y;
+	}
+	return textWithRect(context, type, {
+		x,
+		y,
+		w,
+		h
+	}, text);
+}
+function floatingOffset(alignment, { w, h }) {
+	const deltaW = w * .5 + labelPadding;
+	const deltaH = h * .5 + labelPadding;
+	return {
+		offsetX: (alignment.x === "left" ? -1 : 1) * deltaW,
+		offsetY: (alignment.y === "top" ? -1 : 1) * deltaH
+	};
+}
+function drawFloatingLabel(context, measurements, { type, text }) {
+	const { floatingAlignment, extremities } = measurements;
+	let x = extremities[floatingAlignment.x];
+	let y = extremities[floatingAlignment.y];
+	const { w, h } = configureText(context, text);
+	const { offsetX, offsetY } = floatingOffset(floatingAlignment, {
+		w,
+		h
+	});
+	x += offsetX;
+	y += offsetY;
+	return textWithRect(context, type, {
+		x,
+		y,
+		w,
+		h
+	}, text);
+}
+function drawStack(context, measurements, stack, external) {
+	const rects = [];
+	stack.forEach((l, idx) => {
+		const rect = external && l.position === "center" ? drawFloatingLabel(context, measurements, l) : drawLabel(context, measurements, l, rects[idx - 1], external);
+		rects[idx] = rect;
+	});
+}
+function labelStacks(context, measurements, labels, externalLabels) {
+	const stacks = labels.reduce((acc, l) => {
+		if (!Object.prototype.hasOwnProperty.call(acc, l.position)) acc[l.position] = [];
+		acc[l.position]?.push(l);
+		return acc;
+	}, {});
+	if (stacks.top) drawStack(context, measurements, stacks.top, externalLabels);
+	if (stacks.right) drawStack(context, measurements, stacks.right, externalLabels);
+	if (stacks.bottom) drawStack(context, measurements, stacks.bottom, externalLabels);
+	if (stacks.left) drawStack(context, measurements, stacks.left, externalLabels);
+	if (stacks.center) drawStack(context, measurements, stacks.center, externalLabels);
+}
+var colors$1, labelPadding;
+function init_labels() {
+	return (init_labels = __esmMin((() => {
+		colors$1 = {
+			margin: "#f6b26b",
+			border: "#ffe599",
+			padding: "#93c47d",
+			content: "#6fa8dc",
+			text: "#232020"
+		};
+		labelPadding = 6;
+	})))();
+}
+//#endregion
+//#region src/measure/box-model/visualizer.ts
+function pxToNumber(px) {
+	return parseInt(px.replace("px", ""), 10);
+}
+function round(value) {
+	return Number.isInteger(value) ? value : value.toFixed(2);
+}
+function filterZeroValues(labels) {
+	return labels.filter((l) => l.text !== 0 && l.text !== "0");
+}
+function floatingAlignment(extremities) {
+	const windowExtremities = {
+		top: scope.window.scrollY,
+		bottom: scope.window.scrollY + scope.window.innerHeight,
+		left: scope.window.scrollX,
+		right: scope.window.scrollX + scope.window.innerWidth
+	};
+	const distances = {
+		top: Math.abs(windowExtremities.top - extremities.top),
+		bottom: Math.abs(windowExtremities.bottom - extremities.bottom),
+		left: Math.abs(windowExtremities.left - extremities.left),
+		right: Math.abs(windowExtremities.right - extremities.right)
+	};
+	return {
+		x: distances.left > distances.right ? "left" : "right",
+		y: distances.top > distances.bottom ? "top" : "bottom"
+	};
+}
+function measureElement(element) {
+	const style = scope.getComputedStyle(element);
+	let { top, left, right, bottom, width, height } = element.getBoundingClientRect();
+	const { marginTop, marginBottom, marginLeft, marginRight, paddingTop, paddingBottom, paddingLeft, paddingRight, borderBottomWidth, borderTopWidth, borderLeftWidth, borderRightWidth } = style;
+	top = top + scope.window.scrollY;
+	left = left + scope.window.scrollX;
+	bottom = bottom + scope.window.scrollY;
+	right = right + scope.window.scrollX;
+	const margin = {
+		top: pxToNumber(marginTop),
+		bottom: pxToNumber(marginBottom),
+		left: pxToNumber(marginLeft),
+		right: pxToNumber(marginRight)
+	};
+	const padding = {
+		top: pxToNumber(paddingTop),
+		bottom: pxToNumber(paddingBottom),
+		left: pxToNumber(paddingLeft),
+		right: pxToNumber(paddingRight)
+	};
+	const border = {
+		top: pxToNumber(borderTopWidth),
+		bottom: pxToNumber(borderBottomWidth),
+		left: pxToNumber(borderLeftWidth),
+		right: pxToNumber(borderRightWidth)
+	};
+	const extremities = {
+		top: top - margin.top,
+		bottom: bottom + margin.bottom,
+		left: left - margin.left,
+		right: right + margin.right
+	};
+	return {
+		margin,
+		padding,
+		border,
+		top,
+		left,
+		bottom,
+		right,
+		width,
+		height,
+		extremities,
+		floatingAlignment: floatingAlignment(extremities)
+	};
+}
+function drawMargin(context, { margin, width, height, top, left, bottom, right }) {
+	const marginHeight = height + margin.bottom + margin.top;
+	context.fillStyle = colors.margin;
+	context.fillRect(left, top - margin.top, width, margin.top);
+	context.fillRect(right, top - margin.top, margin.right, marginHeight);
+	context.fillRect(left, bottom, width, margin.bottom);
+	context.fillRect(left - margin.left, top - margin.top, margin.left, marginHeight);
+	return filterZeroValues([
+		{
+			type: "margin",
+			text: round(margin.top),
+			position: "top"
+		},
+		{
+			type: "margin",
+			text: round(margin.right),
+			position: "right"
+		},
+		{
+			type: "margin",
+			text: round(margin.bottom),
+			position: "bottom"
+		},
+		{
+			type: "margin",
+			text: round(margin.left),
+			position: "left"
+		}
+	]);
+}
+function drawPadding(context, { padding, border, width, height, top, left, bottom, right }) {
+	const paddingWidth = width - border.left - border.right;
+	const paddingHeight = height - padding.top - padding.bottom - border.top - border.bottom;
+	context.fillStyle = colors.padding;
+	context.fillRect(left + border.left, top + border.top, paddingWidth, padding.top);
+	context.fillRect(right - padding.right - border.right, top + padding.top + border.top, padding.right, paddingHeight);
+	context.fillRect(left + border.left, bottom - padding.bottom - border.bottom, paddingWidth, padding.bottom);
+	context.fillRect(left + border.left, top + padding.top + border.top, padding.left, paddingHeight);
+	return filterZeroValues([
+		{
+			type: "padding",
+			text: padding.top,
+			position: "top"
+		},
+		{
+			type: "padding",
+			text: padding.right,
+			position: "right"
+		},
+		{
+			type: "padding",
+			text: padding.bottom,
+			position: "bottom"
+		},
+		{
+			type: "padding",
+			text: padding.left,
+			position: "left"
+		}
+	]);
+}
+function drawBorder(context, { border, width, height, top, left, bottom, right }) {
+	const borderHeight = height - border.top - border.bottom;
+	context.fillStyle = colors.border;
+	context.fillRect(left, top, width, border.top);
+	context.fillRect(left, bottom - border.bottom, width, border.bottom);
+	context.fillRect(left, top + border.top, border.left, borderHeight);
+	context.fillRect(right - border.right, top + border.top, border.right, borderHeight);
+	return filterZeroValues([
+		{
+			type: "border",
+			text: border.top,
+			position: "top"
+		},
+		{
+			type: "border",
+			text: border.right,
+			position: "right"
+		},
+		{
+			type: "border",
+			text: border.bottom,
+			position: "bottom"
+		},
+		{
+			type: "border",
+			text: border.left,
+			position: "left"
+		}
+	]);
+}
+function drawContent(context, { padding, border, width, height, top, left }) {
+	const contentWidth = width - border.left - border.right - padding.left - padding.right;
+	const contentHeight = height - padding.top - padding.bottom - border.top - border.bottom;
+	context.fillStyle = colors.content;
+	context.fillRect(left + border.left + padding.left, top + border.top + padding.top, contentWidth, contentHeight);
+	return [{
+		type: "content",
+		position: "center",
+		text: `${round(contentWidth)} x ${round(contentHeight)}`
+	}];
+}
+function drawBoxModel(element) {
+	return (context) => {
+		if (element && context) {
+			const measurements = measureElement(element);
+			const marginLabels = drawMargin(context, measurements);
+			const paddingLabels = drawPadding(context, measurements);
+			const borderLabels = drawBorder(context, measurements);
+			const contentLabels = drawContent(context, measurements);
+			const externalLabels = measurements.width <= 90 || measurements.height <= SMALL_NODE_SIZE;
+			labelStacks(context, measurements, [
+				...contentLabels,
+				...paddingLabels,
+				...borderLabels,
+				...marginLabels
+			], externalLabels);
+		}
+	};
+}
+function drawSelectedElement(element) {
+	draw(drawBoxModel(element));
+}
+var colors, SMALL_NODE_SIZE;
+function init_visualizer() {
+	return (init_visualizer = __esmMin((() => {
+		init_dist$1();
+		init_canvas();
+		init_labels();
+		colors = {
+			margin: "#f6b26ba8",
+			border: "#ffe599a8",
+			padding: "#93c47d8c",
+			content: "#6fa8dca8"
+		};
+		SMALL_NODE_SIZE = 30;
+	})))();
+}
+//#endregion
+//#region src/measure/util.ts
+var deepElementFromPoint;
+function init_util() {
+	return (init_util = __esmMin((() => {
+		init_dist$1();
+		deepElementFromPoint = (x, y) => {
+			const element = scope.document.elementFromPoint(x, y);
+			const crawlShadows = (node) => {
+				if (node && node.shadowRoot) {
+					const nestedElement = node.shadowRoot.elementFromPoint(x, y);
+					if (node.isEqualNode(nestedElement)) return node;
+					if (nestedElement.shadowRoot) return crawlShadows(nestedElement);
+					return nestedElement;
+				}
+				return node;
+			};
+			return crawlShadows(element) || element;
+		};
+	})))();
+}
+//#endregion
+//#region src/measure/withMeasure.ts
+function findAndDrawElement(x, y) {
+	nodeAtPointerRef = deepElementFromPoint(x, y);
+	drawSelectedElement(nodeAtPointerRef);
+}
+var nodeAtPointerRef, pointer, withMeasure;
+function init_withMeasure() {
+	return (init_withMeasure = __esmMin((() => {
+		init_preview_api$1();
+		init_canvas();
+		init_visualizer();
+		init_util();
+		pointer = {
+			x: 0,
+			y: 0
+		};
+		withMeasure = (StoryFn, context) => {
+			const { measureEnabled } = context.globals || {};
+			const measureActive = measureEnabled && !context.parameters?.measure?.disable;
+			useEffect(() => {
+				if (typeof globalThis.document === "undefined") return;
+				const onPointerMove = (event) => {
+					window.requestAnimationFrame(() => {
+						event.stopPropagation();
+						pointer.x = event.clientX;
+						pointer.y = event.clientY;
+					});
+				};
+				globalThis.document.addEventListener("pointermove", onPointerMove);
+				return () => {
+					globalThis.document.removeEventListener("pointermove", onPointerMove);
+				};
+			}, []);
+			useEffect(() => {
+				const onPointerOver = (event) => {
+					window.requestAnimationFrame(() => {
+						event.stopPropagation();
+						findAndDrawElement(event.clientX, event.clientY);
+					});
+				};
+				const onResize = () => {
+					window.requestAnimationFrame(() => {
+						rescale();
+					});
+				};
+				if (context.viewMode === "story" && measureActive) {
+					globalThis.document.addEventListener("pointerover", onPointerOver);
+					init();
+					globalThis.window.addEventListener("resize", onResize);
+					findAndDrawElement(pointer.x, pointer.y);
+				}
+				return () => {
+					globalThis.window.removeEventListener("resize", onResize);
+					destroy();
+				};
+			}, [measureActive, context.viewMode]);
+			return StoryFn();
+		};
+	})))();
+}
+//#endregion
+//#region src/measure/preview.ts
+var decorators$1, initialGlobals$1, preview_default$1;
+function init_preview$4() {
+	return (init_preview$4 = __esmMin((() => {
+		init_constants$3();
+		init_withMeasure();
+		decorators$1 = globalThis.FEATURES?.measure ? [withMeasure] : [];
+		initialGlobals$1 = { [PARAM_KEY$1]: false };
+		preview_default$1 = () => definePreviewAddon({
+			decorators: decorators$1,
+			initialGlobals: initialGlobals$1
+		});
+	})))();
+}
+//#endregion
+//#region src/outline/constants.ts
+var PARAM_KEY;
+function init_constants$4() {
+	return (init_constants$4 = __esmMin((() => {
+		PARAM_KEY = "outline";
+	})))();
+}
+//#endregion
+//#region src/outline/helpers.ts
+var clearStyles, clearStyle, addOutlineStyles;
+function init_helpers() {
+	return (init_helpers = __esmMin((() => {
+		init_dist$1();
+		clearStyles = (selector) => {
+			(Array.isArray(selector) ? selector : [selector]).forEach(clearStyle);
+		};
+		clearStyle = (input) => {
+			const selector = typeof input === "string" ? input : input.join("");
+			const element = scope.document.getElementById(selector);
+			if (element && element.parentElement) element.parentElement.removeChild(element);
+		};
+		addOutlineStyles = (selector, css) => {
+			const existingStyle = scope.document.getElementById(selector);
+			if (existingStyle) {
+				if (existingStyle.innerHTML !== css) existingStyle.innerHTML = css;
+			} else {
+				const style = scope.document.createElement("style");
+				style.setAttribute("id", selector);
+				style.innerHTML = css;
+				scope.document.head.appendChild(style);
+			}
+		};
+	})))();
+}
+//#endregion
+//#region src/outline/outlineCSS.ts
+function outlineCSS(selector) {
+	return dedent`
+    ${selector} body {
+      outline: 1px solid #2980b9 !important;
+    }
+
+    ${selector} article {
+      outline: 1px solid #3498db !important;
+    }
+
+    ${selector} nav {
+      outline: 1px solid #0088c3 !important;
+    }
+
+    ${selector} aside {
+      outline: 1px solid #33a0ce !important;
+    }
+
+    ${selector} section {
+      outline: 1px solid #66b8da !important;
+    }
+
+    ${selector} header {
+      outline: 1px solid #99cfe7 !important;
+    }
+
+    ${selector} footer {
+      outline: 1px solid #cce7f3 !important;
+    }
+
+    ${selector} h1 {
+      outline: 1px solid #162544 !important;
+    }
+
+    ${selector} h2 {
+      outline: 1px solid #314e6e !important;
+    }
+
+    ${selector} h3 {
+      outline: 1px solid #3e5e85 !important;
+    }
+
+    ${selector} h4 {
+      outline: 1px solid #449baf !important;
+    }
+
+    ${selector} h5 {
+      outline: 1px solid #c7d1cb !important;
+    }
+
+    ${selector} h6 {
+      outline: 1px solid #4371d0 !important;
+    }
+
+    ${selector} main {
+      outline: 1px solid #2f4f90 !important;
+    }
+
+    ${selector} address {
+      outline: 1px solid #1a2c51 !important;
+    }
+
+    ${selector} div {
+      outline: 1px solid #036cdb !important;
+    }
+
+    ${selector} p {
+      outline: 1px solid #ac050b !important;
+    }
+
+    ${selector} hr {
+      outline: 1px solid #ff063f !important;
+    }
+
+    ${selector} pre {
+      outline: 1px solid #850440 !important;
+    }
+
+    ${selector} blockquote {
+      outline: 1px solid #f1b8e7 !important;
+    }
+
+    ${selector} ol {
+      outline: 1px solid #ff050c !important;
+    }
+
+    ${selector} ul {
+      outline: 1px solid #d90416 !important;
+    }
+
+    ${selector} li {
+      outline: 1px solid #d90416 !important;
+    }
+
+    ${selector} dl {
+      outline: 1px solid #fd3427 !important;
+    }
+
+    ${selector} dt {
+      outline: 1px solid #ff0043 !important;
+    }
+
+    ${selector} dd {
+      outline: 1px solid #e80174 !important;
+    }
+
+    ${selector} figure {
+      outline: 1px solid #ff00bb !important;
+    }
+
+    ${selector} figcaption {
+      outline: 1px solid #bf0032 !important;
+    }
+
+    ${selector} table {
+      outline: 1px solid #00cc99 !important;
+    }
+
+    ${selector} caption {
+      outline: 1px solid #37ffc4 !important;
+    }
+
+    ${selector} thead {
+      outline: 1px solid #98daca !important;
+    }
+
+    ${selector} tbody {
+      outline: 1px solid #64a7a0 !important;
+    }
+
+    ${selector} tfoot {
+      outline: 1px solid #22746b !important;
+    }
+
+    ${selector} tr {
+      outline: 1px solid #86c0b2 !important;
+    }
+
+    ${selector} th {
+      outline: 1px solid #a1e7d6 !important;
+    }
+
+    ${selector} td {
+      outline: 1px solid #3f5a54 !important;
+    }
+
+    ${selector} col {
+      outline: 1px solid #6c9a8f !important;
+    }
+
+    ${selector} colgroup {
+      outline: 1px solid #6c9a9d !important;
+    }
+
+    ${selector} button {
+      outline: 1px solid #da8301 !important;
+    }
+
+    ${selector} datalist {
+      outline: 1px solid #c06000 !important;
+    }
+
+    ${selector} fieldset {
+      outline: 1px solid #d95100 !important;
+    }
+
+    ${selector} form {
+      outline: 1px solid #d23600 !important;
+    }
+
+    ${selector} input {
+      outline: 1px solid #fca600 !important;
+    }
+
+    ${selector} keygen {
+      outline: 1px solid #b31e00 !important;
+    }
+
+    ${selector} label {
+      outline: 1px solid #ee8900 !important;
+    }
+
+    ${selector} legend {
+      outline: 1px solid #de6d00 !important;
+    }
+
+    ${selector} meter {
+      outline: 1px solid #e8630c !important;
+    }
+
+    ${selector} optgroup {
+      outline: 1px solid #b33600 !important;
+    }
+
+    ${selector} option {
+      outline: 1px solid #ff8a00 !important;
+    }
+
+    ${selector} output {
+      outline: 1px solid #ff9619 !important;
+    }
+
+    ${selector} progress {
+      outline: 1px solid #e57c00 !important;
+    }
+
+    ${selector} select {
+      outline: 1px solid #e26e0f !important;
+    }
+
+    ${selector} textarea {
+      outline: 1px solid #cc5400 !important;
+    }
+
+    ${selector} details {
+      outline: 1px solid #33848f !important;
+    }
+
+    ${selector} summary {
+      outline: 1px solid #60a1a6 !important;
+    }
+
+    ${selector} command {
+      outline: 1px solid #438da1 !important;
+    }
+
+    ${selector} menu {
+      outline: 1px solid #449da6 !important;
+    }
+
+    ${selector} del {
+      outline: 1px solid #bf0000 !important;
+    }
+
+    ${selector} ins {
+      outline: 1px solid #400000 !important;
+    }
+
+    ${selector} img {
+      outline: 1px solid #22746b !important;
+    }
+
+    ${selector} iframe {
+      outline: 1px solid #64a7a0 !important;
+    }
+
+    ${selector} embed {
+      outline: 1px solid #98daca !important;
+    }
+
+    ${selector} object {
+      outline: 1px solid #00cc99 !important;
+    }
+
+    ${selector} param {
+      outline: 1px solid #37ffc4 !important;
+    }
+
+    ${selector} video {
+      outline: 1px solid #6ee866 !important;
+    }
+
+    ${selector} audio {
+      outline: 1px solid #027353 !important;
+    }
+
+    ${selector} source {
+      outline: 1px solid #012426 !important;
+    }
+
+    ${selector} canvas {
+      outline: 1px solid #a2f570 !important;
+    }
+
+    ${selector} track {
+      outline: 1px solid #59a600 !important;
+    }
+
+    ${selector} map {
+      outline: 1px solid #7be500 !important;
+    }
+
+    ${selector} area {
+      outline: 1px solid #305900 !important;
+    }
+
+    ${selector} a {
+      outline: 1px solid #ff62ab !important;
+    }
+
+    ${selector} em {
+      outline: 1px solid #800b41 !important;
+    }
+
+    ${selector} strong {
+      outline: 1px solid #ff1583 !important;
+    }
+
+    ${selector} i {
+      outline: 1px solid #803156 !important;
+    }
+
+    ${selector} b {
+      outline: 1px solid #cc1169 !important;
+    }
+
+    ${selector} u {
+      outline: 1px solid #ff0430 !important;
+    }
+
+    ${selector} s {
+      outline: 1px solid #f805e3 !important;
+    }
+
+    ${selector} small {
+      outline: 1px solid #d107b2 !important;
+    }
+
+    ${selector} abbr {
+      outline: 1px solid #4a0263 !important;
+    }
+
+    ${selector} q {
+      outline: 1px solid #240018 !important;
+    }
+
+    ${selector} cite {
+      outline: 1px solid #64003c !important;
+    }
+
+    ${selector} dfn {
+      outline: 1px solid #b4005a !important;
+    }
+
+    ${selector} sub {
+      outline: 1px solid #dba0c8 !important;
+    }
+
+    ${selector} sup {
+      outline: 1px solid #cc0256 !important;
+    }
+
+    ${selector} time {
+      outline: 1px solid #d6606d !important;
+    }
+
+    ${selector} code {
+      outline: 1px solid #e04251 !important;
+    }
+
+    ${selector} kbd {
+      outline: 1px solid #5e001f !important;
+    }
+
+    ${selector} samp {
+      outline: 1px solid #9c0033 !important;
+    }
+
+    ${selector} var {
+      outline: 1px solid #d90047 !important;
+    }
+
+    ${selector} mark {
+      outline: 1px solid #ff0053 !important;
+    }
+
+    ${selector} bdi {
+      outline: 1px solid #bf3668 !important;
+    }
+
+    ${selector} bdo {
+      outline: 1px solid #6f1400 !important;
+    }
+
+    ${selector} ruby {
+      outline: 1px solid #ff7b93 !important;
+    }
+
+    ${selector} rt {
+      outline: 1px solid #ff2f54 !important;
+    }
+
+    ${selector} rp {
+      outline: 1px solid #803e49 !important;
+    }
+
+    ${selector} span {
+      outline: 1px solid #cc2643 !important;
+    }
+
+    ${selector} br {
+      outline: 1px solid #db687d !important;
+    }
+
+    ${selector} wbr {
+      outline: 1px solid #db175b !important;
+    }`;
+}
+function init_outlineCSS() {
+	return (init_outlineCSS = __esmMin((() => {
+		init_esm();
+	})))();
+}
+//#endregion
+//#region src/outline/withOutline.ts
+var withOutline;
+function init_withOutline() {
+	return (init_withOutline = __esmMin((() => {
+		init_preview_api$1();
+		init_constants$4();
+		init_helpers();
+		init_outlineCSS();
+		withOutline = (StoryFn, context) => {
+			const globals = context.globals || {};
+			const isActive = !context.parameters?.["outline"]?.disable && [true, "true"].includes(globals["outline"]);
+			const isInDocs = context.viewMode === "docs";
+			const outlineStyles = useMemo(() => {
+				return outlineCSS(isInDocs ? `[data-story-block="true"]` : ".sb-show-main");
+			}, [context]);
+			useEffect(() => {
+				const selectorId = isInDocs ? `addon-outline-docs-${context.id}` : `addon-outline`;
+				if (!isActive) clearStyles(selectorId);
+				else addOutlineStyles(selectorId, outlineStyles);
+				return () => {
+					clearStyles(selectorId);
+				};
+			}, [
+				isActive,
+				outlineStyles,
+				context
+			]);
+			return StoryFn();
+		};
+	})))();
+}
+//#endregion
+//#region src/outline/preview.ts
+var decorators, initialGlobals, preview_default;
+function init_preview$5() {
+	return (init_preview$5 = __esmMin((() => {
+		init_constants$4();
+		init_withOutline();
+		decorators = globalThis.FEATURES?.outline ? [withOutline] : [];
+		initialGlobals = { [PARAM_KEY]: false };
+		preview_default = () => definePreviewAddon({
+			decorators,
+			initialGlobals
+		});
+	})))();
+}
+//#endregion
+//#region src/docs-tools/shared.ts
+var ADDON_ID, SNIPPET_RENDERED;
+function init_shared() {
+	return (init_shared = __esmMin((() => {
+		ADDON_ID = "@aussieljk/forkbook/docs";
+		SNIPPET_RENDERED = `${ADDON_ID}/snippet-rendered`;
+	})))();
+}
+//#endregion
+//#region src/docs-tools/storyDocsCodePanel.ts
+/**
+* Whether the preview story-docs hook should skip emitting a snippet to the manager Code panel.
+*
+* The args/source shape logic mirrors {@link skipJsxRender} in the React `jsxDecorator`, so static
+* service snippets replace dynamic JSX rendering under the same conditions. It additionally skips
+* portable stories (vitest, playwright/jest portable): those have no manager Code panel and no OSA
+* server peer, so the `extractStoryDocs` remote command has no handler and would reject after the
+* ack timeout — there is nothing to emit to.
+*/
+function shouldSkipStoryDocsEmit(parameters) {
+	const sourceParams = parameters?.docs?.source;
+	const isArgsStory = parameters?.__isArgsStory;
+	if (parameters?.__isPortableStory) return true;
+	if (sourceParams?.type === "dynamic") return false;
+	return !isArgsStory || sourceParams?.code !== void 0 || sourceParams?.type === "code";
+}
+function init_storyDocsCodePanel() {
+	return (init_storyDocsCodePanel = __esmMin((() => {
+		init_shared();
+	})))();
+}
+//#endregion
+//#region src/csf/core-annotations.ts
+/** Flag a project-annotations object as already containing the core annotations. */
+function markAsComposedWithCoreAnnotations(annotations) {
+	Object.defineProperty(annotations, CORE_ANNOTATIONS_COMPOSED, {
+		value: true,
+		enumerable: false,
+		configurable: true,
+		writable: true
+	});
+	return annotations;
+}
+/** Whether a project-annotations object already contains the core annotations. */
+function hasCoreAnnotations(annotations) {
+	return annotations != null && typeof annotations === "object" && annotations[CORE_ANNOTATIONS_COMPOSED] === true;
+}
+function getCoreAnnotations() {
+	return [
+		(preview_default$1.default ?? preview_default$1)(),
+		(preview_default$4.default ?? preview_default$4)(),
+		(preview_default$2.default ?? preview_default$2)(),
+		(preview_default.default ?? preview_default)(),
+		(preview_default$8.default ?? preview_default$8)(),
+		(preview_default$5.default ?? preview_default$5)(),
+		(preview_default$3.default ?? preview_default$3)(),
+		(preview_default$9.default ?? preview_default$9)(),
+		(test_annotations_default.default ?? test_annotations_default)(),
+		(preview_default$6.default ?? preview_default$6)(),
+		(preview_default$7.default ?? preview_default$7)()
+	];
+}
+var CORE_ANNOTATIONS_COMPOSED;
+function init_core_annotations() {
+	return (init_core_annotations = __esmMin((() => {
+		init_preview();
+		init_preview$1();
+		init_preview$2();
+		init_test_annotations();
+		init_preview$3();
+		init_preview$4();
+		init_preview$5();
+		init_preview$6();
+		init_preview$7();
+		init_preview$9();
+		init_preview$8();
+		CORE_ANNOTATIONS_COMPOSED = Symbol.for("storybook.internal.composedWithCoreAnnotations");
+	})))();
+}
+//#endregion
+//#region src/csf/csf-factories.ts
+function definePreviewAddon(preview) {
+	return preview;
+}
+function isMeta(input) {
+	return input != null && typeof input === "object" && "_tag" in input && input?._tag === "Meta";
+}
+function isStory(input) {
+	return input != null && typeof input === "object" && "_tag" in input && input?._tag === "Story";
+}
+function getStoryChildren(story) {
+	if ("__children" in story) return story.__children;
+	return [];
+}
+function init_csf_factories() {
+	return (init_csf_factories = __esmMin((() => {})))();
+}
+//#endregion
+//#region src/actions/runtime/configureActions.ts
+var config, configureActions;
+function init_configureActions() {
+	return (init_configureActions = __esmMin((() => {
+		config = {
+			depth: 10,
+			clearOnStoryChange: true,
+			limit: 50
+		};
+		configureActions = (options = {}) => {
+			Object.assign(config, options);
+		};
+	})))();
+}
+//#endregion
+//#region src/actions/runtime/action.ts
+function action(name, options = {}) {
+	const actionOptions = {
+		...config,
+		...options
+	};
+	const handler = function actionHandler(...args) {
+		if (options.implicit) {
+			const storyRenderer = ("__STORYBOOK_PREVIEW__" in scope ? scope.__STORYBOOK_PREVIEW__ : void 0)?.storyRenders.find((render) => render.phase === "playing" || render.phase === "rendering");
+			if (storyRenderer) {
+				const deprecated = !globalThis?.FEATURES?.disallowImplicitActionsInRenderV8;
+				const error = new ImplicitActionsDuringRendering({
+					phase: storyRenderer.phase,
+					name,
+					deprecated
+				});
+				if (deprecated) console.warn(error);
+				else throw error;
+			}
+		}
+		const channel = addons$1.getChannel();
+		const id = Date.now().toString(36) + Math.random().toString(36).substring(2);
+		const minDepth = 5;
+		const serializedArgs = args.map(serializeArg);
+		const actionDisplayToEmit = {
+			id,
+			count: 0,
+			data: {
+				name,
+				args: args.length > 1 ? serializedArgs : serializedArgs[0]
+			},
+			options: {
+				...actionOptions,
+				maxDepth: minDepth + (actionOptions.depth || 3)
+			}
+		};
+		channel.emit(EVENT_ID, actionDisplayToEmit);
+	};
+	handler.isAction = true;
+	handler.implicit = options.implicit;
+	return handler;
+}
+var findProto, isReactSyntheticEvent, serializeArg;
+function init_action() {
+	return (init_action = __esmMin((() => {
+		init_preview_errors();
+		init_dist$1();
+		init_preview_api$1();
+		init_constants();
+		init_configureActions();
+		findProto = (obj, callback) => {
+			const proto = Object.getPrototypeOf(obj);
+			if (!proto || callback(proto)) return proto;
+			return findProto(proto, callback);
+		};
+		isReactSyntheticEvent = (e) => Boolean(typeof e === "object" && e && findProto(e, (proto) => /^Synthetic(?:Base)?Event$/.test(proto.constructor.name)) && typeof e.persist === "function");
+		serializeArg = (a) => {
+			if (isReactSyntheticEvent(a)) {
+				const e = Object.create(a.constructor.prototype, Object.getOwnPropertyDescriptors(a));
+				e.persist();
+				const viewDescriptor = Object.getOwnPropertyDescriptor(e, "view");
+				const view = viewDescriptor?.value;
+				if (typeof view === "object" && view?.constructor.name === "Window") Object.defineProperty(e, "view", {
+					...viewDescriptor,
+					value: Object.create(view.constructor.prototype)
+				});
+				return e;
+			}
+			return a;
+		};
+	})))();
+}
+//#endregion
+//#region src/actions/runtime/actions.ts
+var actions;
+function init_actions() {
+	return (init_actions = __esmMin((() => {
+		init_action();
+		init_configureActions();
+		actions = (...args) => {
+			let options = config;
+			let names = args;
+			if (names.length === 1 && Array.isArray(names[0])) [names] = names;
+			if (names.length !== 1 && typeof names[names.length - 1] !== "string") options = {
+				...config,
+				...names.pop()
+			};
+			let namesObject = names[0];
+			if (names.length !== 1 || typeof namesObject === "string") {
+				namesObject = {};
+				names.forEach((name) => {
+					namesObject[name] = name;
+				});
+			}
+			const actionsObject = {};
+			Object.keys(namesObject).forEach((name) => {
+				actionsObject[name] = action(namesObject[name], options);
+			});
+			return actionsObject;
+		};
+	})))();
+}
+//#endregion
+//#region src/actions/index.ts
+var actions_exports = /* @__PURE__ */ __exportAll({
+	ADDON_ID: () => ADDON_ID$2,
+	CLEAR_ID: () => CLEAR_ID,
+	CYCLIC_KEY: () => CYCLIC_KEY,
+	EVENT_ID: () => EVENT_ID,
+	PANEL_ID: () => PANEL_ID,
+	PARAM_KEY: () => PARAM_KEY$3,
+	action: () => action,
+	actions: () => actions,
+	config: () => config,
+	configureActions: () => configureActions
+});
+function init_actions$1() {
+	return (init_actions$1 = __esmMin((() => {
+		init_constants();
+		init_action();
+		init_actions();
+		init_configureActions();
+	})))();
+}
+//#endregion
+export { RESET_STORY_ARGS as $, channels_exports as A, init_manager_errors as At, CONFIG_ERROR as B, toId as C, deprecate as Ct, storyNameFromExport as D, OpenServiceStaticSnapshotInvalidError as Dt, isExportStory as E, once as Et, init_channel_slot as F, FORCE_RE_RENDER as G, DOCS_PREPARED as H, installNoopChannel as I, NAVIGATE_URL as J, GLOBALS_UPDATED as K, setChannel as L, clearChannel as M, ensureChannel as N, init_mock_channel as O, OpenServiceStaticSnapshotLoadError as Ot, getChannel as P, PREVIEW_KEYDOWN as Q, ARGTYPES_INFO_REQUEST as R, sanitize as S, client_logger_exports as St, init_export_story as T, logger as Tt, DOCS_RENDERED as U, CURRENT_STORY_WAS_SET as V, FORCE_REMOUNT as W, PRELOAD_ENTRIES as X, PLAY_FUNCTION_THREW_EXCEPTION as Y, PREVIEW_INITIALIZED as Z, instrument as _, UPDATE_GLOBALS as _t, init_csf_factories as a, STORY_FINISHED as at, combineTags as b, core_events_exports as bt, getCoreAnnotations as c, STORY_MISSING as ct, markAsComposedWithCoreAnnotations as d, STORY_RENDER_PHASE_CHANGED as dt, SET_CURRENT_STORY as et, init_storyDocsCodePanel as f, STORY_SPECIFIED as ft, init_instrumenter as g, UNHANDLED_ERRORS_WHILE_PLAYING as gt, init_shared as h, TELEMETRY_ERROR as ht, getStoryChildren as i, STORY_ERRORED as it, init_channels as j, mockChannel as k, UniversalStoreFollowerTimeoutError as kt, hasCoreAnnotations as l, STORY_PREPARED as lt, SNIPPET_RENDERED as m, STORY_UNCHANGED as mt, init_actions$1 as n, STORY_ARGS_UPDATED as nt, isMeta as o, STORY_HOT_UPDATED as ot, shouldSkipStoryDocsEmit as p, STORY_THREW_EXCEPTION as pt, MANAGER_INERT_ATTRIBUTE_CHANGED as q, definePreviewAddon as r, STORY_CHANGED as rt, isStory as s, STORY_INDEX_INVALIDATED as st, actions_exports as t, SET_GLOBALS as tt, init_core_annotations as u, STORY_RENDERED as ut, includeConditionalArg as v, UPDATE_QUERY_PARAMS as vt, toTestId as w, init_client_logger as wt, init_csf_utils as x, init_core_events as xt, init_includeConditionalArg as y, UPDATE_STORY_ARGS as yt, ARGTYPES_INFO_RESPONSE as z };