@powerhousedao/powerhouse-vetra-packages 6.1.0-dev.2 → 6.1.0-dev.21

package/dist/browser/dist-C1nRM9t2.js

@@ -0,0 +1,3768 @@
+import { E as __commonJSMin, k as __toESM, t as capitalCase } from "./dist-CXoKspdx.js";
+import { A as replayDocument, J as validateStateSchemaName, K as validateInitialState, S as createZip, Y as generateId, _ as baseSaveToFileHandle, a as handleTargetNameCollisions, c as moveNode, d as logger, g as baseLoadFromInput, i as generateNodesCopy, l as updateNode, n as copyNode, o as isFileNode, q as validateModules, r as driveDocumentModelModule, s as isFolderNode, t as addFolder$1, u as documentModelDocumentModelModule, v as buildSignedAction, y as createPresignedHeader, z as setName } from "./document-drive-oqv68jDU.js";
+import { c as driveCollectionId, n as gql, o as SyncStatus, s as ModuleNotFoundError, t as reactorDriveDocumentModelModule } from "./dist-DLFI75Zd.js";
+import { Children, cloneElement, forwardRef, isValidElement, use, useEffect, useMemo, useState, useSyncExternalStore } from "react";
+import "react/jsx-runtime";
+//#region ../reactor-browser/dist/make-ph-event-functions-DwiD1zH9.js
+const isServer$1 = typeof window === "undefined";
+function makePHEventFunctions(key) {
+	const setEventName = `ph:set${capitalCase(key)}`;
+	const updateEventName = `ph:${key}Updated`;
+	function setValue(value) {
+		if (isServer$1) return;
+		const event = new CustomEvent(setEventName, { detail: { [key]: value } });
+		window.dispatchEvent(event);
+	}
+	function dispatchUpdatedEvent() {
+		if (isServer$1) return;
+		const event = new CustomEvent(updateEventName);
+		window.dispatchEvent(event);
+	}
+	function handleSetValueEvent(event) {
+		if (isServer$1) return;
+		const value = event.detail[key];
+		if (!window.ph) window.ph = {};
+		window.ph[key] = value;
+		dispatchUpdatedEvent();
+	}
+	function addEventHandler() {
+		if (isServer$1) return;
+		window.addEventListener(setEventName, handleSetValueEvent);
+	}
+	function subscribeToValue(onStoreChange) {
+		if (isServer$1) return () => {};
+		window.addEventListener(updateEventName, onStoreChange);
+		return () => {
+			window.removeEventListener(updateEventName, onStoreChange);
+		};
+	}
+	function getSnapshot() {
+		if (isServer$1) return;
+		return window.ph?.[key];
+	}
+	function getServerSnapshot() {}
+	function useValue() {
+		return useSyncExternalStore(subscribeToValue, getSnapshot, getServerSnapshot);
+	}
+	return {
+		useValue,
+		setValue,
+		addEventHandler
+	};
+}
+//#endregion
+//#region ../reactor-browser/dist/document-by-id-BrIy0iHX.js
+async function queueActions(document, actionOrActions) {
+	if (!document) throw new Error("No document provided");
+	if (!actionOrActions) throw new Error("No actions provided");
+	const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
+	if (actions.length === 0) throw new Error("No actions provided");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	return await reactorClient.execute(document.header.id, "main", actions);
+}
+async function queueOperations(documentId, operationOrOperations) {
+	if (!documentId) throw new Error("No documentId provided");
+	if (!operationOrOperations) throw new Error("No operations provided");
+	const operations = Array.isArray(operationOrOperations) ? operationOrOperations : [operationOrOperations];
+	if (operations.length === 0) throw new Error("No operations provided");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const actions = operations.map((op) => op.action);
+	return await reactorClient.execute(documentId, "main", actions);
+}
+async function uploadOperations(documentId, allOperations, pushOperations, options) {
+	const operationsLimit = options?.operationsLimit || 50;
+	const onProgress = options?.onProgress;
+	logger.verbose(`uploadDocumentOperations(documentId:${documentId}, ops: ${Object.keys(allOperations).join(",")}, limit:${operationsLimit})`);
+	const allOperationsArray = Object.values(allOperations).filter((ops) => ops !== void 0);
+	const totalOperations = allOperationsArray.reduce((total, operations) => total + operations.length, 0);
+	let uploadedOperations = 0;
+	for (const operations of allOperationsArray) for (let i = 0; i < operations.length; i += operationsLimit) {
+		logger.verbose(`uploadDocumentOperations:for(i:${i}, ops:${operations.length}, limit:${operationsLimit}): START`);
+		const chunk = operations.slice(i, i + operationsLimit);
+		const operation = chunk.at(-1);
+		if (!operation) break;
+		const scope = operation.action.scope;
+		await pushOperations(documentId, chunk);
+		uploadedOperations += chunk.length;
+		if (onProgress) onProgress({
+			stage: "uploading",
+			progress: Math.round(uploadedOperations / totalOperations * 100),
+			totalOperations,
+			uploadedOperations
+		});
+		logger.verbose(`uploadDocumentOperations:for:waitForUpdate(${documentId}:${scope} rev ${operation.index}): NEXT`);
+	}
+	logger.verbose(`uploadDocumentOperations:for:waitForUpdate(${documentId}): END`);
+}
+async function signAction(action, document) {
+	const reactor = window.ph?.reactorClient;
+	if (!reactor) return action;
+	const reducer = (await reactor.getDocumentModelModule(document.header.documentType)).reducer;
+	const renown = window.ph?.renown;
+	if (!renown?.user) return action;
+	if (!action.context?.signer) return action;
+	const actionSigner = action.context.signer;
+	return await buildSignedAction(action, reducer, document, actionSigner, renown.crypto.sign);
+}
+function addActionContext(action) {
+	const renown = window.ph?.renown;
+	if (!renown?.user) return action;
+	return {
+		context: { signer: {
+			app: {
+				name: "Connect",
+				key: renown.did
+			},
+			user: {
+				address: renown.user.address,
+				networkId: renown.user.networkId,
+				chainId: renown.user.chainId
+			},
+			signatures: []
+		} },
+		...action
+	};
+}
+async function makeSignedActionWithContext(action, document) {
+	if (!action) {
+		logger.error("No action found");
+		return;
+	}
+	if (!document) {
+		logger.error("No document found");
+		return;
+	}
+	return addActionContext(await signAction(action, document));
+}
+async function makeSignedActionsWithContext(actionOrActions, document) {
+	if (!actionOrActions) {
+		logger.error("No actions found");
+		return;
+	}
+	const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
+	return (await Promise.all(actions.map((action) => makeSignedActionWithContext(action, document)))).filter((a) => a !== void 0);
+}
+async function getDocument(documentId) {
+	try {
+		return await window.ph?.reactorClient?.get(documentId);
+	} catch (error) {
+		logger.debug(`Failed to get document with id ${documentId}:`, error);
+		return;
+	}
+}
+function getActionErrors(result, actions) {
+	return actions.reduce((errors, a) => {
+		const scopeOperations = result.operations[a.scope];
+		if (!scopeOperations) return errors;
+		const op = scopeOperations.findLast((op) => op.action.id === a.id);
+		if (op?.error) errors.push(new Error(op.error));
+		return errors;
+	}, new Array());
+}
+async function dispatchActions(actionOrActions, documentOrDocumentId, onErrors, onSuccess) {
+	const document = typeof documentOrDocumentId === "string" ? await getDocument(documentOrDocumentId) : documentOrDocumentId;
+	if (!document) {
+		logger.error(`Document with id ${JSON.stringify(documentOrDocumentId)} not found`);
+		return;
+	}
+	const signedActionsWithContext = await makeSignedActionsWithContext(actionOrActions, document);
+	if (!signedActionsWithContext) {
+		logger.error("No signed actions with context found");
+		return;
+	}
+	const result = await queueActions(document, signedActionsWithContext);
+	if (onErrors && result) {
+		const errors = getActionErrors(result, signedActionsWithContext);
+		if (errors.length) onErrors(errors);
+	}
+	if (onSuccess && result) onSuccess(result);
+	return result;
+}
+const documentEventFunctions = makePHEventFunctions("documentCache");
+/** Returns all documents in the reactor. */
+const useDocumentCache = documentEventFunctions.useValue;
+documentEventFunctions.setValue;
+documentEventFunctions.addEventHandler;
+/**
+* Retrieves a document from the reactor and subscribes to changes using React Suspense.
+* This hook will suspend rendering while the document is loading.
+* @param id - The document ID to retrieve, or null/undefined to skip retrieval
+* @returns The document if found, or undefined if id is null/undefined
+*/
+function useDocument(id) {
+	const documentCache = useDocumentCache();
+	const document = useSyncExternalStore((cb) => id && documentCache ? documentCache.subscribe(id, cb) : () => {}, () => id ? documentCache?.get(id) : void 0);
+	return document ? use(document) : void 0;
+}
+function useDispatch(document) {
+	/**
+	* Dispatches actions to the document.
+	* @param actionOrActions - The action or actions to dispatch.
+	* @param onErrors - Callback invoked with any errors that occurred during action execution.
+	*/
+	function dispatch(actionOrActions, onErrors, onSuccess) {
+		dispatchActions(actionOrActions, document, onErrors, onSuccess).catch(logger.error);
+	}
+	return [document, dispatch];
+}
+/** Returns a document by id. */
+function useDocumentById(id) {
+	const document = useDocument(id);
+	const [, dispatch] = useDispatch(document);
+	return [document, dispatch];
+}
+//#endregion
+//#region ../reactor-browser/dist/client-D7hUM13i.js
+const PhDocumentFieldsFragmentDoc = gql`
+  fragment PHDocumentFields on PHDocument {
+    id
+    slug
+    name
+    documentType
+    state
+    revisionsList {
+      scope
+      revision
+    }
+    createdAtUtcIso
+    lastModifiedAtUtcIso
+  }
+`;
+gql`
+  query GetDocumentModels($namespace: String, $paging: PagingInput) {
+    documentModels(namespace: $namespace, paging: $paging) {
+      items {
+        id
+        name
+        namespace
+        version
+        specification
+      }
+      totalCount
+      hasNextPage
+      hasPreviousPage
+      cursor
+    }
+  }
+`;
+const GetDocumentDocument = gql`
+  query GetDocument($identifier: String!, $view: ViewFilterInput) {
+    document(identifier: $identifier, view: $view) {
+      document {
+        ...PHDocumentFields
+      }
+      childIds
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+const GetDocumentWithOperationsDocument = gql`
+  query GetDocumentWithOperations(
+    $identifier: String!
+    $view: ViewFilterInput
+    $operationsFilter: DocumentOperationsFilterInput
+    $operationsPaging: PagingInput
+  ) {
+    document(identifier: $identifier, view: $view) {
+      document {
+        ...PHDocumentFields
+        operations(filter: $operationsFilter, paging: $operationsPaging) {
+          items {
+            index
+            timestampUtcMs
+            hash
+            skip
+            error
+            id
+            action {
+              id
+              type
+              timestampUtcMs
+              input
+              scope
+              attachments {
+                data
+                mimeType
+                hash
+                extension
+                fileName
+              }
+              context {
+                signer {
+                  user {
+                    address
+                    networkId
+                    chainId
+                  }
+                  app {
+                    name
+                    key
+                  }
+                  signatures
+                }
+              }
+            }
+          }
+          totalCount
+          hasNextPage
+          hasPreviousPage
+          cursor
+        }
+      }
+      childIds
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  query GetDocumentOutgoingRelationships(
+    $sourceIdentifier: String!
+    $relationshipType: String!
+    $view: ViewFilterInput
+    $paging: PagingInput
+  ) {
+    documentOutgoingRelationships(
+      sourceIdentifier: $sourceIdentifier
+      relationshipType: $relationshipType
+      view: $view
+      paging: $paging
+    ) {
+      items {
+        ...PHDocumentFields
+      }
+      totalCount
+      hasNextPage
+      hasPreviousPage
+      cursor
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  query GetDocumentIncomingRelationships(
+    $targetIdentifier: String!
+    $relationshipType: String!
+    $view: ViewFilterInput
+    $paging: PagingInput
+  ) {
+    documentIncomingRelationships(
+      targetIdentifier: $targetIdentifier
+      relationshipType: $relationshipType
+      view: $view
+      paging: $paging
+    ) {
+      items {
+        ...PHDocumentFields
+      }
+      totalCount
+      hasNextPage
+      hasPreviousPage
+      cursor
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  query FindDocuments(
+    $search: SearchFilterInput
+    $view: ViewFilterInput
+    $paging: PagingInput
+  ) {
+    findDocuments(search: $search, view: $view, paging: $paging) {
+      items {
+        ...PHDocumentFields
+      }
+      totalCount
+      hasNextPage
+      hasPreviousPage
+      cursor
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+const GetDocumentOperationsDocument = gql`
+  query GetDocumentOperations(
+    $filter: OperationsFilterInput!
+    $paging: PagingInput
+  ) {
+    documentOperations(filter: $filter, paging: $paging) {
+      items {
+        index
+        timestampUtcMs
+        hash
+        skip
+        error
+        id
+        action {
+          id
+          type
+          timestampUtcMs
+          input
+          scope
+          attachments {
+            data
+            mimeType
+            hash
+            extension
+            fileName
+          }
+          context {
+            signer {
+              user {
+                address
+                networkId
+                chainId
+              }
+              app {
+                name
+                key
+              }
+              signatures
+            }
+          }
+        }
+      }
+      totalCount
+      hasNextPage
+      hasPreviousPage
+      cursor
+    }
+  }
+`;
+gql`
+  query GetJobStatus($jobId: String!) {
+    jobStatus(jobId: $jobId) {
+      id
+      status
+      result
+      error
+      createdAt
+      completedAt
+    }
+  }
+`;
+gql`
+  mutation CreateDocument($document: JSONObject!, $parentIdentifier: String) {
+    createDocument(document: $document, parentIdentifier: $parentIdentifier) {
+      ...PHDocumentFields
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation CreateEmptyDocument(
+    $documentType: String!
+    $parentIdentifier: String
+  ) {
+    createEmptyDocument(
+      documentType: $documentType
+      parentIdentifier: $parentIdentifier
+    ) {
+      ...PHDocumentFields
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation MutateDocument(
+    $documentIdentifier: String!
+    $actions: [JSONObject!]!
+    $view: ViewFilterInput
+  ) {
+    mutateDocument(
+      documentIdentifier: $documentIdentifier
+      actions: $actions
+      view: $view
+    ) {
+      ...PHDocumentFields
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation MutateDocumentAsync(
+    $documentIdentifier: String!
+    $actions: [JSONObject!]!
+    $view: ViewFilterInput
+  ) {
+    mutateDocumentAsync(
+      documentIdentifier: $documentIdentifier
+      actions: $actions
+      view: $view
+    )
+  }
+`;
+gql`
+  mutation RenameDocument(
+    $documentIdentifier: String!
+    $name: String!
+    $branch: String
+  ) {
+    renameDocument(
+      documentIdentifier: $documentIdentifier
+      name: $name
+      branch: $branch
+    ) {
+      ...PHDocumentFields
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation SetPreferredEditor(
+    $documentIdentifier: String!
+    $preferredEditor: String
+    $branch: String
+  ) {
+    setPreferredEditor(
+      documentIdentifier: $documentIdentifier
+      preferredEditor: $preferredEditor
+      branch: $branch
+    ) {
+      ...PHDocumentFields
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation AddRelationship(
+    $sourceIdentifier: String!
+    $targetIdentifier: String!
+    $relationshipType: String!
+    $branch: String
+  ) {
+    addRelationship(
+      sourceIdentifier: $sourceIdentifier
+      targetIdentifier: $targetIdentifier
+      relationshipType: $relationshipType
+      branch: $branch
+    ) {
+      ...PHDocumentFields
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation RemoveRelationship(
+    $sourceIdentifier: String!
+    $targetIdentifier: String!
+    $relationshipType: String!
+    $branch: String
+  ) {
+    removeRelationship(
+      sourceIdentifier: $sourceIdentifier
+      targetIdentifier: $targetIdentifier
+      relationshipType: $relationshipType
+      branch: $branch
+    ) {
+      ...PHDocumentFields
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation MoveRelationship(
+    $sourceParentIdentifier: String!
+    $targetParentIdentifier: String!
+    $targetIdentifier: String!
+    $relationshipType: String!
+    $branch: String
+  ) {
+    moveRelationship(
+      sourceParentIdentifier: $sourceParentIdentifier
+      targetParentIdentifier: $targetParentIdentifier
+      targetIdentifier: $targetIdentifier
+      relationshipType: $relationshipType
+      branch: $branch
+    ) {
+      source {
+        ...PHDocumentFields
+      }
+      target {
+        ...PHDocumentFields
+      }
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  mutation DeleteDocument($identifier: String!, $propagate: PropagationMode) {
+    deleteDocument(identifier: $identifier, propagate: $propagate)
+  }
+`;
+gql`
+  mutation DeleteDocuments(
+    $identifiers: [String!]!
+    $propagate: PropagationMode
+  ) {
+    deleteDocuments(identifiers: $identifiers, propagate: $propagate)
+  }
+`;
+gql`
+  subscription DocumentChanges(
+    $search: SearchFilterInput
+    $view: ViewFilterInput
+  ) {
+    documentChanges(search: $search, view: $view) {
+      type
+      documents {
+        ...PHDocumentFields
+      }
+      context {
+        parentId
+        childId
+      }
+    }
+  }
+  ${PhDocumentFieldsFragmentDoc}
+`;
+gql`
+  subscription JobChanges($jobId: String!) {
+    jobChanges(jobId: $jobId) {
+      jobId
+      status
+      result
+      error
+    }
+  }
+`;
+gql`
+  query PollSyncEnvelopes(
+    $channelId: String!
+    $outboxAck: Int!
+    $outboxLatest: Int!
+  ) {
+    pollSyncEnvelopes(
+      channelId: $channelId
+      outboxAck: $outboxAck
+      outboxLatest: $outboxLatest
+    ) {
+      envelopes {
+        type
+        channelMeta {
+          id
+        }
+        operations {
+          operation {
+            index
+            timestampUtcMs
+            hash
+            skip
+            error
+            id
+            action {
+              id
+              type
+              timestampUtcMs
+              input
+              scope
+              attachments {
+                data
+                mimeType
+                hash
+                extension
+                fileName
+              }
+              context {
+                signer {
+                  user {
+                    address
+                    networkId
+                    chainId
+                  }
+                  app {
+                    name
+                    key
+                  }
+                  signatures
+                }
+              }
+            }
+          }
+          context {
+            documentId
+            documentType
+            scope
+            branch
+          }
+        }
+        cursor {
+          remoteName
+          cursorOrdinal
+          lastSyncedAtUtcMs
+        }
+        key
+        dependsOn
+      }
+      ackOrdinal
+      deadLetters {
+        documentId
+        error
+      }
+      hasMore
+    }
+  }
+`;
+gql`
+  mutation TouchChannel($input: TouchChannelInput!) {
+    touchChannel(input: $input) {
+      success
+      ackOrdinal
+    }
+  }
+`;
+gql`
+  mutation PushSyncEnvelopes($envelopes: [SyncEnvelopeInput!]!) {
+    pushSyncEnvelopes(envelopes: $envelopes)
+  }
+`;
+/** Get the source string from a GraphQL document (string or DocumentNode). */
+function getDocumentSource(doc) {
+	return typeof doc === "string" ? doc : doc.loc?.source.body ?? "";
+}
+/**
+* Extract the inner selection set of a named field from a GraphQL document source.
+* Returns the `{ ... }` block including braces.
+*/
+function extractSelectionSet(doc, fieldName, fallback) {
+	const source = getDocumentSource(doc);
+	return new RegExp(`${fieldName}\\([^)]*\\)\\s*(\\{[\\s\\S]*\\})\\s*\\}`).exec(source)?.[1] ?? fallback;
+}
+/**
+* Extract the query body and any fragment definitions from a GraphQL document.
+* Returns { body, fragments } where body is the content inside the query `{ ... }`
+* and fragments are any trailing fragment definitions.
+*/
+function extractQueryParts(doc, fallbackBody) {
+	const source = getDocumentSource(doc);
+	const queryMatch = /^[^{]*\{([\s\S]*?)\}\s*(fragment[\s\S]*)?$/.exec(source);
+	return {
+		body: queryMatch?.[1]?.trim() ?? fallbackBody,
+		fragments: queryMatch?.[2]?.trim() ?? ""
+	};
+}
+extractSelectionSet(GetDocumentOperationsDocument, "documentOperations", "{ items { index } }");
+extractQueryParts(GetDocumentDocument, "document(identifier: $identifier) { document { id name documentType state revisionsList { scope revision } createdAtUtcIso lastModifiedAtUtcIso } childIds }");
+//#endregion
+//#region ../reactor-browser/dist/renown-Dzmo1gJD.js
+const { useValue: useLoading, setValue: setLoading, addEventHandler: addLoadingEventHandler } = makePHEventFunctions("loading");
+const renownEventFunctions = makePHEventFunctions("renown");
+renownEventFunctions.addEventHandler;
+/** Returns the renown instance */
+const useRenown = renownEventFunctions.useValue;
+renownEventFunctions.setValue;
+/** Returns the current user from the renown instance, subscribing to user events */
+function useUser() {
+	const renown = useRenown();
+	const [user, setUser] = useState(renown?.user);
+	useEffect(() => {
+		setUser(renown?.user);
+		if (!renown) return;
+		return renown.on("user", setUser);
+	}, [renown]);
+	return user;
+}
+function mergeProps(parentProps, childProps) {
+	const merged = { ...parentProps };
+	for (const key of Object.keys(childProps)) {
+		const parentValue = parentProps[key];
+		const childValue = childProps[key];
+		if (key === "style") merged[key] = {
+			...parentValue,
+			...childValue
+		};
+		else if (key === "className") merged[key] = [parentValue, childValue].filter(Boolean).join(" ");
+		else if (typeof parentValue === "function" && typeof childValue === "function") merged[key] = (...args) => {
+			childValue(...args);
+			parentValue(...args);
+		};
+		else if (childValue !== void 0) merged[key] = childValue;
+	}
+	return merged;
+}
+const Slot = forwardRef(({ children, ...props }, ref) => {
+	const child = Children.only(children);
+	if (!isValidElement(child)) return null;
+	const childElement = child;
+	const mergedProps = mergeProps(props, childElement.props);
+	if (ref) mergedProps.ref = ref;
+	return cloneElement(childElement, mergedProps);
+});
+Slot.displayName = "Slot";
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/lazyDataLastImpl-DtF3cihj.js
+function e$8(e, t, n) {
+	let r = (n) => e(n, ...t);
+	return n === void 0 ? r : Object.assign(r, {
+		lazy: n,
+		lazyArgs: t
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/purry.js
+function t$5(t, n, r) {
+	let i = t.length - n.length;
+	if (i === 0) return t(...n);
+	if (i === 1) return e$8(t, n, r);
+	throw Error(`Wrong number of arguments`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/allPass.js
+function t$4(...t) {
+	return t$5(n$4, t);
+}
+const n$4 = (e, t) => t.every((t) => t(e));
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/conditional-CTEJD5TX.js
+function e$7(e, t, n) {
+	return e(n[0]) ? (e) => t(e, ...n) : t(...n);
+}
+function t$3(...t) {
+	return e$7(r, n$3, t);
+}
+function n$3(e, ...t) {
+	for (let n of t) {
+		if (typeof n == `function`) return n(e);
+		let [t, r] = n;
+		if (t(e)) return r(e);
+	}
+	throw Error(`conditional: data failed for all cases`);
+}
+function r(e) {
+	if (!Array.isArray(e)) return !1;
+	let [t, n, ...r] = e;
+	return typeof t == `function` && t.length <= 1 && typeof n == `function` && n.length <= 1 && r.length === 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/constant.js
+function e$6(e) {
+	return () => e;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/hasAtLeast.js
+function t$2(...t) {
+	return t$5(n$2, t);
+}
+const n$2 = (e, t) => e.length >= t;
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/funnel.js
+const e$5 = Symbol(`funnel/voidReducer`), t$1 = () => e$5;
+function n$1(n, { triggerAt: r = `end`, minQuietPeriodMs: i, maxBurstDurationMs: a, minGapMs: o, reducer: s = t$1 }) {
+	let c, l, u, d, f = () => {
+		let t = u;
+		t !== void 0 && (u = void 0, t === e$5 ? n() : n(t), o !== void 0 && (l = setTimeout(p, o)));
+	}, p = () => {
+		clearTimeout(l), l = void 0, c === void 0 && f();
+	}, m = () => {
+		clearTimeout(c), c = void 0, d = void 0, l === void 0 && f();
+	};
+	return {
+		call: (...e) => {
+			let t = c === void 0 && l === void 0;
+			if ((r !== `start` || t) && (u = s(u, ...e)), !(c === void 0 && !t)) {
+				if (i !== void 0 || a !== void 0 || o === void 0) {
+					clearTimeout(c);
+					let e = Date.now();
+					d ??= e;
+					let t = a === void 0 ? i ?? 0 : Math.min(i ?? a, Math.max(0, a - (e - d)));
+					c = setTimeout(m, t);
+				}
+				r !== `end` && t && f();
+			}
+		},
+		cancel: () => {
+			clearTimeout(c), c = void 0, d = void 0, clearTimeout(l), l = void 0, u = void 0;
+		},
+		flush: () => {
+			m(), p();
+		},
+		get isIdle() {
+			return c === void 0 && l === void 0;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/isDefined.js
+function e$4(e) {
+	return e !== void 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/isNot.js
+function e$3(e) {
+	return (t) => !e(t);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/isStrictEqual.js
+function t(...t) {
+	return t$5(n, t);
+}
+const n = (e, t) => e === t || Object.is(e, t);
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/isString.js
+function e$2(e) {
+	return typeof e == `string`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/isTruthy.js
+function e$1(e) {
+	return !!e;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/remeda@2.33.7/node_modules/remeda/dist/once.js
+function e(e) {
+	let t = !1, n;
+	return () => (t ||= (n = e(), !0), n);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/slug@11.0.1/node_modules/slug/slug.js
+let base64;
+if (typeof window !== "undefined") if (window.btoa) base64 = function(input) {
+	return btoa(unescape(encodeURIComponent(input)));
+};
+else base64 = function(input) {
+	const str = unescape(encodeURIComponent(input + ""));
+	let output = "";
+	for (let block, charCode, idx = 0, map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; str.charAt(idx | 0) || (map = "=", idx % 1); output += map.charAt(63 & block >> 8 - idx % 1 * 8)) {
+		charCode = str.charCodeAt(idx += 3 / 4);
+		/* c8 ignore next 3 */
+		if (charCode > 255) throw new Error("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");
+		block = block << 8 | charCode;
+	}
+	return output;
+};
+else base64 = function(input) {
+	return Buffer.from(input).toString("base64");
+};
+function slug(string, opts) {
+	let result = slugify(string, opts);
+	if ((opts && opts.fallback !== void 0 ? opts.fallback : slug.defaults.fallback) === true && result === "") result = slugify(base64(string), opts);
+	return result;
+}
+const locales = {
+	bg: {
+		Й: "Y",
+		й: "y",
+		X: "H",
+		x: "h",
+		Ц: "Ts",
+		ц: "ts",
+		Щ: "Sht",
+		щ: "sht",
+		Ъ: "A",
+		ъ: "a",
+		Ь: "Y",
+		ь: "y"
+	},
+	de: {
+		Ä: "AE",
+		ä: "ae",
+		Ö: "OE",
+		ö: "oe",
+		Ü: "UE",
+		ü: "ue"
+	},
+	sr: {
+		đ: "dj",
+		Đ: "DJ"
+	},
+	uk: {
+		И: "Y",
+		и: "y",
+		Й: "Y",
+		й: "y",
+		Ц: "Ts",
+		ц: "ts",
+		Х: "Kh",
+		х: "kh",
+		Щ: "Shch",
+		щ: "shch",
+		Г: "H",
+		г: "h"
+	}
+};
+let defaultLocale = {};
+function slugify(string, opts) {
+	if (typeof string !== "string") throw new Error("slug() requires a string argument, received " + typeof string);
+	if (!string.isWellFormed()) throw new Error("slug() received a malformed string with lone surrogates");
+	if (typeof opts === "string") opts = { replacement: opts };
+	opts = opts ? Object.assign({}, opts) : {};
+	opts.mode = opts.mode || slug.defaults.mode;
+	const defaults = slug.defaults.modes[opts.mode];
+	const keys = [
+		"replacement",
+		"multicharmap",
+		"charmap",
+		"remove",
+		"lower",
+		"trim"
+	];
+	for (let key, i = 0, l = keys.length; i < l; i++) {
+		key = keys[i];
+		opts[key] = key in opts ? opts[key] : defaults[key];
+	}
+	const localeMap = locales[opts.locale] || defaultLocale;
+	let lengths = [];
+	for (const key in opts.multicharmap) {
+		if (!Object.prototype.hasOwnProperty.call(opts.multicharmap, key)) continue;
+		const len = key.length;
+		if (lengths.indexOf(len) === -1) lengths.push(len);
+	}
+	lengths = lengths.sort(function(a, b) {
+		return b - a;
+	});
+	const disallowedChars = opts.mode === "rfc3986" ? /[^\w\s\-.~]/ : /[^A-Za-z0-9\s]/;
+	let result = "";
+	for (let char, i = 0, l = string.length; i < l; i++) {
+		char = string[i];
+		let matchedMultichar = false;
+		for (let j = 0; j < lengths.length; j++) {
+			const len = lengths[j];
+			const str = string.substr(i, len);
+			if (opts.multicharmap[str]) {
+				i += len - 1;
+				char = opts.multicharmap[str];
+				matchedMultichar = true;
+				break;
+			}
+		}
+		if (!matchedMultichar) if (localeMap[char]) char = localeMap[char];
+		else if (opts.charmap[char]) char = opts.charmap[char].replace(opts.replacement, " ");
+		else if (char.includes(opts.replacement)) char = char.replace(opts.replacement, " ");
+		else char = char.replace(disallowedChars, "");
+		result += char;
+	}
+	if (opts.remove) result = result.replace(opts.remove, "");
+	if (opts.trim) result = result.trim();
+	result = result.replace(/\s+/g, opts.replacement);
+	if (opts.lower) result = result.toLowerCase();
+	return result;
+}
+const initialMulticharmap = {
+	फ़: "Fi",
+	ग़: "Ghi",
+	ख़: "Khi",
+	क़: "Qi",
+	ड़: "ugDha",
+	ढ़: "ugDhha",
+	य़: "Yi",
+	ज़: "Za",
+	בִי: "i",
+	בֵ: "e",
+	בֵי: "e",
+	בֶ: "e",
+	בַ: "a",
+	בָ: "a",
+	בֹ: "o",
+	וֹ: "o",
+	בֻ: "u",
+	וּ: "u",
+	בּ: "b",
+	כּ: "k",
+	ךּ: "k",
+	פּ: "p",
+	שׁ: "sh",
+	שׂ: "s",
+	בְ: "e",
+	חֱ: "e",
+	חֲ: "a",
+	חֳ: "o",
+	בִ: "i"
+};
+const initialCharmap = {
+	À: "A",
+	Á: "A",
+	Â: "A",
+	Ã: "A",
+	Ä: "A",
+	Å: "A",
+	Æ: "AE",
+	Ç: "C",
+	È: "E",
+	É: "E",
+	Ê: "E",
+	Ë: "E",
+	Ì: "I",
+	Í: "I",
+	Î: "I",
+	Ï: "I",
+	Ð: "D",
+	Ñ: "N",
+	Ò: "O",
+	Ó: "O",
+	Ô: "O",
+	Õ: "O",
+	Ö: "O",
+	Ő: "O",
+	Ø: "O",
+	Ō: "O",
+	Ù: "U",
+	Ú: "U",
+	Û: "U",
+	Ü: "U",
+	Ű: "U",
+	Ý: "Y",
+	Þ: "TH",
+	ß: "ss",
+	à: "a",
+	á: "a",
+	â: "a",
+	ã: "a",
+	ä: "a",
+	å: "a",
+	æ: "ae",
+	ç: "c",
+	è: "e",
+	é: "e",
+	ê: "e",
+	ë: "e",
+	ì: "i",
+	í: "i",
+	î: "i",
+	ï: "i",
+	ð: "d",
+	ñ: "n",
+	ò: "o",
+	ó: "o",
+	ô: "o",
+	õ: "o",
+	ö: "o",
+	ő: "o",
+	ø: "o",
+	ō: "o",
+	Œ: "OE",
+	œ: "oe",
+	ù: "u",
+	ú: "u",
+	û: "u",
+	ü: "u",
+	ű: "u",
+	ý: "y",
+	þ: "th",
+	ÿ: "y",
+	ẞ: "SS",
+	α: "a",
+	β: "b",
+	γ: "g",
+	δ: "d",
+	ε: "e",
+	ζ: "z",
+	η: "h",
+	θ: "th",
+	ι: "i",
+	κ: "k",
+	λ: "l",
+	μ: "m",
+	ν: "n",
+	ξ: "3",
+	ο: "o",
+	π: "p",
+	ρ: "r",
+	σ: "s",
+	τ: "t",
+	υ: "y",
+	φ: "f",
+	χ: "x",
+	ψ: "ps",
+	ω: "w",
+	ά: "a",
+	έ: "e",
+	ί: "i",
+	ό: "o",
+	ύ: "y",
+	ή: "h",
+	ώ: "w",
+	ς: "s",
+	ϊ: "i",
+	ΰ: "y",
+	ϋ: "y",
+	ΐ: "i",
+	Α: "A",
+	Β: "B",
+	Γ: "G",
+	Δ: "D",
+	Ε: "E",
+	Ζ: "Z",
+	Η: "H",
+	Θ: "Th",
+	Ι: "I",
+	Κ: "K",
+	Λ: "L",
+	Μ: "M",
+	Ν: "N",
+	Ξ: "3",
+	Ο: "O",
+	Π: "P",
+	Ρ: "R",
+	Σ: "S",
+	Τ: "T",
+	Υ: "Y",
+	Φ: "F",
+	Χ: "X",
+	Ψ: "PS",
+	Ω: "W",
+	Ά: "A",
+	Έ: "E",
+	Ί: "I",
+	Ό: "O",
+	Ύ: "Y",
+	Ή: "H",
+	Ώ: "W",
+	Ϊ: "I",
+	Ϋ: "Y",
+	ş: "s",
+	Ş: "S",
+	ı: "i",
+	İ: "I",
+	ğ: "g",
+	Ğ: "G",
+	а: "a",
+	б: "b",
+	в: "v",
+	г: "g",
+	д: "d",
+	е: "e",
+	ё: "yo",
+	ж: "zh",
+	з: "z",
+	и: "i",
+	й: "j",
+	к: "k",
+	л: "l",
+	м: "m",
+	н: "n",
+	о: "o",
+	п: "p",
+	р: "r",
+	с: "s",
+	т: "t",
+	у: "u",
+	ф: "f",
+	х: "h",
+	ц: "c",
+	ч: "ch",
+	ш: "sh",
+	щ: "sh",
+	ъ: "u",
+	ы: "y",
+	ь: "",
+	э: "e",
+	ю: "yu",
+	я: "ya",
+	А: "A",
+	Б: "B",
+	В: "V",
+	Г: "G",
+	Д: "D",
+	Е: "E",
+	Ё: "Yo",
+	Ж: "Zh",
+	З: "Z",
+	И: "I",
+	Й: "J",
+	К: "K",
+	Л: "L",
+	М: "M",
+	Н: "N",
+	О: "O",
+	П: "P",
+	Р: "R",
+	С: "S",
+	Т: "T",
+	У: "U",
+	Ф: "F",
+	Х: "H",
+	Ц: "C",
+	Ч: "Ch",
+	Ш: "Sh",
+	Щ: "Sh",
+	Ъ: "U",
+	Ы: "Y",
+	Ь: "",
+	Э: "E",
+	Ю: "Yu",
+	Я: "Ya",
+	Є: "Ye",
+	І: "I",
+	Ї: "Yi",
+	Ґ: "G",
+	є: "ye",
+	і: "i",
+	ї: "yi",
+	ґ: "g",
+	č: "c",
+	ď: "d",
+	ě: "e",
+	ň: "n",
+	ř: "r",
+	š: "s",
+	ť: "t",
+	ů: "u",
+	ž: "z",
+	Č: "C",
+	Ď: "D",
+	Ě: "E",
+	Ň: "N",
+	Ř: "R",
+	Š: "S",
+	Ť: "T",
+	Ů: "U",
+	Ž: "Z",
+	ľ: "l",
+	ĺ: "l",
+	ŕ: "r",
+	Ľ: "L",
+	Ĺ: "L",
+	Ŕ: "R",
+	ą: "a",
+	ć: "c",
+	ę: "e",
+	ł: "l",
+	ń: "n",
+	ś: "s",
+	ź: "z",
+	ż: "z",
+	Ą: "A",
+	Ć: "C",
+	Ę: "E",
+	Ł: "L",
+	Ń: "N",
+	Ś: "S",
+	Ź: "Z",
+	Ż: "Z",
+	ā: "a",
+	ē: "e",
+	ģ: "g",
+	ī: "i",
+	ķ: "k",
+	ļ: "l",
+	ņ: "n",
+	ū: "u",
+	Ā: "A",
+	Ē: "E",
+	Ģ: "G",
+	Ī: "I",
+	Ķ: "K",
+	Ļ: "L",
+	Ņ: "N",
+	Ū: "U",
+	أ: "a",
+	إ: "i",
+	ب: "b",
+	ت: "t",
+	ث: "th",
+	ج: "g",
+	ح: "h",
+	خ: "kh",
+	د: "d",
+	ذ: "th",
+	ر: "r",
+	ز: "z",
+	س: "s",
+	ش: "sh",
+	ص: "s",
+	ض: "d",
+	ط: "t",
+	ظ: "th",
+	ع: "aa",
+	غ: "gh",
+	ف: "f",
+	ق: "k",
+	ك: "k",
+	ل: "l",
+	م: "m",
+	ن: "n",
+	ه: "h",
+	و: "o",
+	ي: "y",
+	ء: "aa",
+	ة: "a",
+	آ: "a",
+	ا: "a",
+	پ: "p",
+	ژ: "zh",
+	گ: "g",
+	چ: "ch",
+	ک: "k",
+	ی: "i",
+	ė: "e",
+	į: "i",
+	ų: "u",
+	Ė: "E",
+	Į: "I",
+	Ų: "U",
+	ț: "t",
+	Ț: "T",
+	ţ: "t",
+	Ţ: "T",
+	ș: "s",
+	Ș: "S",
+	ă: "a",
+	Ă: "A",
+	Ạ: "A",
+	Ả: "A",
+	Ầ: "A",
+	Ấ: "A",
+	Ậ: "A",
+	Ẩ: "A",
+	Ẫ: "A",
+	Ằ: "A",
+	Ắ: "A",
+	Ặ: "A",
+	Ẳ: "A",
+	Ẵ: "A",
+	Ẹ: "E",
+	Ẻ: "E",
+	Ẽ: "E",
+	Ề: "E",
+	Ế: "E",
+	Ệ: "E",
+	Ể: "E",
+	Ễ: "E",
+	Ị: "I",
+	Ỉ: "I",
+	Ĩ: "I",
+	Ọ: "O",
+	Ỏ: "O",
+	Ồ: "O",
+	Ố: "O",
+	Ộ: "O",
+	Ổ: "O",
+	Ỗ: "O",
+	Ơ: "O",
+	Ờ: "O",
+	Ớ: "O",
+	Ợ: "O",
+	Ở: "O",
+	Ỡ: "O",
+	Ụ: "U",
+	Ủ: "U",
+	Ũ: "U",
+	Ư: "U",
+	Ừ: "U",
+	Ứ: "U",
+	Ự: "U",
+	Ử: "U",
+	Ữ: "U",
+	Ỳ: "Y",
+	Ỵ: "Y",
+	Ỷ: "Y",
+	Ỹ: "Y",
+	Đ: "D",
+	ạ: "a",
+	ả: "a",
+	ầ: "a",
+	ấ: "a",
+	ậ: "a",
+	ẩ: "a",
+	ẫ: "a",
+	ằ: "a",
+	ắ: "a",
+	ặ: "a",
+	ẳ: "a",
+	ẵ: "a",
+	ẹ: "e",
+	ẻ: "e",
+	ẽ: "e",
+	ề: "e",
+	ế: "e",
+	ệ: "e",
+	ể: "e",
+	ễ: "e",
+	ị: "i",
+	ỉ: "i",
+	ĩ: "i",
+	ọ: "o",
+	ỏ: "o",
+	ồ: "o",
+	ố: "o",
+	ộ: "o",
+	ổ: "o",
+	ỗ: "o",
+	ơ: "o",
+	ờ: "o",
+	ớ: "o",
+	ợ: "o",
+	ở: "o",
+	ỡ: "o",
+	ụ: "u",
+	ủ: "u",
+	ũ: "u",
+	ư: "u",
+	ừ: "u",
+	ứ: "u",
+	ự: "u",
+	ử: "u",
+	ữ: "u",
+	ỳ: "y",
+	ỵ: "y",
+	ỷ: "y",
+	ỹ: "y",
+	đ: "d",
+	Ә: "AE",
+	ә: "ae",
+	Ғ: "GH",
+	ғ: "gh",
+	Қ: "KH",
+	қ: "kh",
+	Ң: "NG",
+	ң: "ng",
+	Ү: "UE",
+	ү: "ue",
+	Ұ: "U",
+	ұ: "u",
+	Һ: "H",
+	һ: "h",
+	Ө: "OE",
+	ө: "oe",
+	ђ: "dj",
+	ј: "j",
+	љ: "lj",
+	њ: "nj",
+	ћ: "c",
+	џ: "dz",
+	Ђ: "Dj",
+	Ј: "j",
+	Љ: "Lj",
+	Њ: "Nj",
+	Ћ: "C",
+	Џ: "Dz",
+	nj: "nj",
+	lj: "lj",
+	Nj: "NJ",
+	Lj: "LJ",
+	अ: "a",
+	आ: "aa",
+	ए: "e",
+	ई: "ii",
+	ऍ: "ei",
+	ऎ: "ae",
+	ऐ: "ai",
+	इ: "i",
+	ओ: "o",
+	ऑ: "oi",
+	ऒ: "oii",
+	ऊ: "uu",
+	औ: "ou",
+	उ: "u",
+	ब: "B",
+	भ: "Bha",
+	च: "Ca",
+	छ: "Chha",
+	ड: "Da",
+	ढ: "Dha",
+	फ: "Fa",
+	ग: "Ga",
+	घ: "Gha",
+	ग़: "Ghi",
+	ह: "Ha",
+	ज: "Ja",
+	झ: "Jha",
+	क: "Ka",
+	ख: "Kha",
+	ख़: "Khi",
+	ल: "L",
+	ळ: "Li",
+	ऌ: "Li",
+	ऴ: "Lii",
+	ॡ: "Lii",
+	म: "Ma",
+	न: "Na",
+	ङ: "Na",
+	ञ: "Nia",
+	ण: "Nae",
+	ऩ: "Ni",
+	ॐ: "oms",
+	प: "Pa",
+	क़: "Qi",
+	र: "Ra",
+	ऋ: "Ri",
+	ॠ: "Ri",
+	ऱ: "Ri",
+	स: "Sa",
+	श: "Sha",
+	ष: "Shha",
+	ट: "Ta",
+	त: "Ta",
+	ठ: "Tha",
+	द: "Tha",
+	थ: "Tha",
+	ध: "Thha",
+	ड़: "ugDha",
+	ढ़: "ugDhha",
+	व: "Va",
+	य: "Ya",
+	य़: "Yi",
+	ज़: "Za",
+	ə: "e",
+	Ə: "E",
+	ა: "a",
+	ბ: "b",
+	გ: "g",
+	დ: "d",
+	ე: "e",
+	ვ: "v",
+	ზ: "z",
+	თ: "t",
+	ი: "i",
+	კ: "k",
+	ლ: "l",
+	მ: "m",
+	ნ: "n",
+	ო: "o",
+	პ: "p",
+	ჟ: "zh",
+	რ: "r",
+	ს: "s",
+	ტ: "t",
+	უ: "u",
+	ფ: "p",
+	ქ: "k",
+	ღ: "gh",
+	ყ: "q",
+	შ: "sh",
+	ჩ: "ch",
+	ც: "ts",
+	ძ: "dz",
+	წ: "ts",
+	ჭ: "ch",
+	ხ: "kh",
+	ჯ: "j",
+	ჰ: "h",
+	ב: "v",
+	גּ: "g",
+	ג: "g",
+	ד: "d",
+	דּ: "d",
+	ה: "h",
+	ו: "v",
+	ז: "z",
+	ח: "h",
+	ט: "t",
+	י: "y",
+	כ: "kh",
+	ך: "kh",
+	ל: "l",
+	מ: "m",
+	ם: "m",
+	נ: "n",
+	ן: "n",
+	ס: "s",
+	פ: "f",
+	ף: "f",
+	ץ: "ts",
+	צ: "ts",
+	ק: "k",
+	ר: "r",
+	תּ: "t",
+	ת: "t"
+};
+slug.charmap = Object.assign({}, initialCharmap);
+slug.multicharmap = Object.assign({}, initialMulticharmap);
+slug.defaults = {
+	charmap: slug.charmap,
+	mode: "pretty",
+	modes: {
+		rfc3986: {
+			replacement: "-",
+			remove: null,
+			lower: true,
+			charmap: slug.charmap,
+			multicharmap: slug.multicharmap,
+			trim: true
+		},
+		pretty: {
+			replacement: "-",
+			remove: null,
+			lower: true,
+			charmap: slug.charmap,
+			multicharmap: slug.multicharmap,
+			trim: true
+		}
+	},
+	multicharmap: slug.multicharmap,
+	fallback: true
+};
+slug.reset = function() {
+	slug.defaults.modes.rfc3986.charmap = slug.defaults.modes.pretty.charmap = slug.charmap = slug.defaults.charmap = Object.assign({}, initialCharmap);
+	slug.defaults.modes.rfc3986.multicharmap = slug.defaults.modes.pretty.multicharmap = slug.multicharmap = slug.defaults.multicharmap = Object.assign({}, initialMulticharmap);
+	defaultLocale = "";
+};
+slug.extend = function(customMap) {
+	const keys = Object.keys(customMap);
+	const multi = {};
+	const single = {};
+	for (let i = 0; i < keys.length; i++) if (keys[i].length > 1) multi[keys[i]] = customMap[keys[i]];
+	else single[keys[i]] = customMap[keys[i]];
+	Object.assign(slug.charmap, single);
+	Object.assign(slug.multicharmap, multi);
+};
+slug.setLocale = function(locale) {
+	defaultLocale = locales[locale] || {};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/descriptors.js
+const normalizeDescriptors = (error) => {
+	CORE_ERROR_PROPS.forEach((propName) => {
+		normalizeDescriptor(error, propName);
+	});
+};
+const CORE_ERROR_PROPS = [
+	"name",
+	"message",
+	"stack",
+	"cause",
+	"errors"
+];
+const normalizeDescriptor = (error, propName) => {
+	const descriptor = getDescriptor(error, propName);
+	if (descriptor === void 0) return;
+	if (isReadonlyGetter(descriptor)) {
+		setErrorProperty(error, propName, error[propName]);
+		return;
+	}
+	if (isInvalidDescriptor(descriptor)) setErrorDescriptor(error, propName, descriptor);
+};
+const getDescriptor = (value, propName) => {
+	const descriptor = Object.getOwnPropertyDescriptor(value, propName);
+	if (descriptor !== void 0) return descriptor;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null ? void 0 : getDescriptor(prototype, propName);
+};
+const isReadonlyGetter = ({ get, set }) => get !== void 0 && set === void 0;
+const isInvalidDescriptor = ({ enumerable, writable }) => enumerable || !writable;
+const setErrorProperty = (error, propName, value) => {
+	setErrorDescriptor(error, propName, { value });
+};
+const setErrorDescriptor = (error, propName, descriptor) => {
+	Object.defineProperty(error, propName, {
+		...descriptor,
+		..."get" in descriptor || "set" in descriptor ? {} : { writable: true },
+		enumerable: false,
+		configurable: true
+	});
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/aggregate.js
+const normalizeAggregate = (error, recurse) => {
+	if (Array.isArray(error.errors)) setErrorProperty(error, "errors", error.errors.filter(isDefined).map(recurse).filter(Boolean));
+	else if (isAggregateError(error)) setErrorProperty(error, "errors", []);
+	else if (error.errors !== void 0) deleteAggregateErrors(error);
+};
+const isDefined = (error) => error !== void 0;
+const isAggregateError = (error) => "AggregateError" in globalThis && (error.name === "AggregateError" || error instanceof AggregateError);
+const deleteAggregateErrors = (error) => {
+	delete error.errors;
+	if (error.errors !== void 0) setErrorProperty(error, "errors", []);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/cause.js
+const normalizeCause = (error, recurse) => {
+	if (!("cause" in error)) return;
+	const cause = error.cause === void 0 ? error.cause : recurse(error.cause);
+	if (cause === void 0) delete error.cause;
+	else setErrorProperty(error, "cause", cause);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/is-error-instance@3.0.1/node_modules/is-error-instance/build/src/main.js
+const isErrorInstance = (value) => isInstanceOfError(value) || hasErrorTag(value);
+const isInstanceOfError = (value) => {
+	try {
+		return value instanceof Error;
+	} catch {
+		return false;
+	}
+};
+const hasErrorTag = (value) => {
+	try {
+		return ERROR_TAGS.has(Object.prototype.toString.call(value));
+	} catch {
+		return false;
+	}
+};
+const ERROR_TAGS = new Set([
+	"[object Error]",
+	"[object DOMException]",
+	"[object DOMError]",
+	"[object Exception]"
+]);
+//#endregion
+//#region ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/modifiable.js
+const isNonModifiableError = (error) => !Object.isExtensible(error) || CORE_ERROR_PROPS.some((propName) => isNonConfigurableProp(error, propName) || isThrowingProp(error, propName));
+const isNonConfigurableProp = (error, propName) => {
+	const descriptor = Object.getOwnPropertyDescriptor(error, propName);
+	return descriptor !== void 0 && !descriptor.configurable;
+};
+const isThrowingProp = (error, propName) => {
+	try {
+		error[propName];
+		return false;
+	} catch {
+		return true;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/stack.js
+const setStack = (error) => {
+	setErrorProperty(error, "stack", getStack(error.message, error.name));
+};
+const getStack = (message = "", name = "Error") => {
+	const { stack } = new (getErrorClass(name))(message);
+	return typeof stack === "string" && stack !== "" ? stack : `${name}: ${message}`;
+};
+const getErrorClass = (name) => {
+	const descriptor = {
+		value: name,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	};
+	const StackError = Object.defineProperty(class extends Error {}, "name", descriptor);
+	Object.defineProperty(StackError.prototype, "name", descriptor);
+	return StackError;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/copy.js
+const copyObject = (object) => {
+	const objectCopy = {};
+	for (const propName of getPropsToCopy(object)) try {
+		const value = object[propName];
+		const { enumerable, configurable, writable = true } = getDescriptor(object, propName);
+		Object.defineProperty(objectCopy, propName, {
+			value,
+			enumerable,
+			configurable,
+			writable
+		});
+	} catch {}
+	return objectCopy;
+};
+const getPropsToCopy = (object) => {
+	const propNames = getOwnKeys(object);
+	for (const propName of CORE_ERROR_PROPS) if (isInheritedProp(object, propName)) propNames.push(propName);
+	return propNames;
+};
+const getOwnKeys = (object) => {
+	try {
+		return Reflect.ownKeys(object);
+	} catch {
+		return [];
+	}
+};
+const isInheritedProp = (object, propName) => {
+	try {
+		return propName in object && !Object.hasOwn(object, propName);
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/object.js
+const objectifyError = (object) => {
+	const { name, message, stack, cause, errors, ...objectA } = copyObject(object);
+	const messageA = getMessage(message, objectA);
+	const error = newError(name, messageA);
+	if (message === messageA) assignObjectProps(error, objectA);
+	Object.entries({
+		name,
+		stack,
+		cause,
+		errors
+	}).forEach(([propName, propValue]) => {
+		setNewErrorProperty(error, propName, propValue);
+	});
+	if (stack === void 0) setStack(error);
+	return error;
+};
+const getMessage = (message, object) => typeof message === "string" && message !== "" ? message : truncateMessage(safeJsonStringify(object));
+const safeJsonStringify = (object) => {
+	try {
+		return JSON.stringify(object);
+	} catch {
+		return safeStringify(object);
+	}
+};
+const safeStringify = (object) => {
+	try {
+		return String(object);
+	} catch {
+		return "Invalid error";
+	}
+};
+const truncateMessage = (message) => message.length < MESSAGE_MAX_SIZE ? message : `${message.slice(0, MESSAGE_MAX_SIZE)}...`;
+const MESSAGE_MAX_SIZE = 1e3;
+const newError = (name, message) => {
+	if (name === "AggregateError" && "AggregateError" in globalThis) return new AggregateError([], message);
+	if (name in NATIVE_ERRORS) return new NATIVE_ERRORS[name](message);
+	return new Error(message);
+};
+const NATIVE_ERRORS = {
+	Error,
+	ReferenceError,
+	TypeError,
+	SyntaxError,
+	RangeError,
+	URIError,
+	EvalError
+};
+const assignObjectProps = (error, object) => {
+	for (const propName in object) if (!(propName in error)) error[propName] = object[propName];
+};
+const setNewErrorProperty = (error, propName, propValue) => {
+	if (propValue !== void 0) setErrorProperty(error, propName, propValue);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/string.js
+const stringifyError = (value) => {
+	try {
+		const error = new Error(String(value));
+		setStack(error);
+		return error;
+	} catch (error_) {
+		return error_;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/create/main.js
+const { toString: objectToString } = Object.prototype;
+const createError = (value) => {
+	if (isErrorPlainObj(value)) return objectifyError(value);
+	if (!isErrorInstance(value)) return stringifyError(value);
+	if (isInvalidError(value)) return objectifyError(value);
+	return value;
+};
+const isErrorPlainObj = (value) => {
+	try {
+		return isPlainObject(value);
+	} catch {
+		return false;
+	}
+};
+const isInvalidError = (value) => isProxy(value) || isNonModifiableError(value) || hasInvalidConstructor(value);
+const isProxy = (value) => {
+	try {
+		return objectToString.call(value) === "[object Object]";
+	} catch {
+		return true;
+	}
+};
+const hasInvalidConstructor = (error) => typeof error.constructor !== "function" || typeof error.constructor.name !== "string" || error.constructor.name === "" || error.constructor.prototype !== Object.getPrototypeOf(error);
+//#endregion
+//#region ../../node_modules/.pnpm/normalize-exception@4.0.1/node_modules/normalize-exception/build/src/main.js
+const normalizeException = (error, { shallow = false } = {}) => recurseException(error, [], shallow);
+const recurseException = (error, parents, shallow) => {
+	if (parents.includes(error)) return;
+	const recurse = shallow ? identity : (innerError) => recurseException(innerError, [...parents, error], shallow);
+	const errorA = createError(error);
+	normalizeProps(errorA, recurse);
+	return errorA;
+};
+const identity = (error) => error;
+const normalizeProps = (error, recurse) => {
+	normalizeName(error);
+	normalizeMessage(error);
+	normalizeStack(error);
+	normalizeCause(error, recurse);
+	normalizeAggregate(error, recurse);
+	normalizeDescriptors(error);
+};
+const normalizeName = (error) => {
+	if (isDefinedString(error.name)) return;
+	const prototypeName = Object.getPrototypeOf(error).name;
+	setErrorProperty(error, "name", isDefinedString(prototypeName) ? prototypeName : error.constructor.name);
+};
+const normalizeMessage = (error) => {
+	if (!isDefinedString(error.message)) setErrorProperty(error, "message", "");
+};
+const normalizeStack = (error) => {
+	if (!isDefinedString(error.stack)) setStack(error);
+};
+const isDefinedString = (value) => typeof value === "string" && value !== "";
+//#endregion
+//#region ../reactor-browser/dist/index.js
+var import_lz_string = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var LZString = (function() {
+		var f = String.fromCharCode;
+		var keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+		var keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
+		var baseReverseDic = {};
+		function getBaseValue(alphabet, character) {
+			if (!baseReverseDic[alphabet]) {
+				baseReverseDic[alphabet] = {};
+				for (var i = 0; i < alphabet.length; i++) baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+			}
+			return baseReverseDic[alphabet][character];
+		}
+		var LZString = {
+			compressToBase64: function(input) {
+				if (input == null) return "";
+				var res = LZString._compress(input, 6, function(a) {
+					return keyStrBase64.charAt(a);
+				});
+				switch (res.length % 4) {
+					default:
+					case 0: return res;
+					case 1: return res + "===";
+					case 2: return res + "==";
+					case 3: return res + "=";
+				}
+			},
+			decompressFromBase64: function(input) {
+				if (input == null) return "";
+				if (input == "") return null;
+				return LZString._decompress(input.length, 32, function(index) {
+					return getBaseValue(keyStrBase64, input.charAt(index));
+				});
+			},
+			compressToUTF16: function(input) {
+				if (input == null) return "";
+				return LZString._compress(input, 15, function(a) {
+					return f(a + 32);
+				}) + " ";
+			},
+			decompressFromUTF16: function(compressed) {
+				if (compressed == null) return "";
+				if (compressed == "") return null;
+				return LZString._decompress(compressed.length, 16384, function(index) {
+					return compressed.charCodeAt(index) - 32;
+				});
+			},
+			compressToUint8Array: function(uncompressed) {
+				var compressed = LZString.compress(uncompressed);
+				var buf = new Uint8Array(compressed.length * 2);
+				for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
+					var current_value = compressed.charCodeAt(i);
+					buf[i * 2] = current_value >>> 8;
+					buf[i * 2 + 1] = current_value % 256;
+				}
+				return buf;
+			},
+			decompressFromUint8Array: function(compressed) {
+				if (compressed === null || compressed === void 0) return LZString.decompress(compressed);
+				else {
+					var buf = new Array(compressed.length / 2);
+					for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1];
+					var result = [];
+					buf.forEach(function(c) {
+						result.push(f(c));
+					});
+					return LZString.decompress(result.join(""));
+				}
+			},
+			compressToEncodedURIComponent: function(input) {
+				if (input == null) return "";
+				return LZString._compress(input, 6, function(a) {
+					return keyStrUriSafe.charAt(a);
+				});
+			},
+			decompressFromEncodedURIComponent: function(input) {
+				if (input == null) return "";
+				if (input == "") return null;
+				input = input.replace(/ /g, "+");
+				return LZString._decompress(input.length, 32, function(index) {
+					return getBaseValue(keyStrUriSafe, input.charAt(index));
+				});
+			},
+			compress: function(uncompressed) {
+				return LZString._compress(uncompressed, 16, function(a) {
+					return f(a);
+				});
+			},
+			_compress: function(uncompressed, bitsPerChar, getCharFromInt) {
+				if (uncompressed == null) return "";
+				var i, value, context_dictionary = {}, context_dictionaryToCreate = {}, context_c = "", context_wc = "", context_w = "", context_enlargeIn = 2, context_dictSize = 3, context_numBits = 2, context_data = [], context_data_val = 0, context_data_position = 0, ii;
+				for (ii = 0; ii < uncompressed.length; ii += 1) {
+					context_c = uncompressed.charAt(ii);
+					if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+						context_dictionary[context_c] = context_dictSize++;
+						context_dictionaryToCreate[context_c] = true;
+					}
+					context_wc = context_w + context_c;
+					if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) context_w = context_wc;
+					else {
+						if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+							if (context_w.charCodeAt(0) < 256) {
+								for (i = 0; i < context_numBits; i++) {
+									context_data_val = context_data_val << 1;
+									if (context_data_position == bitsPerChar - 1) {
+										context_data_position = 0;
+										context_data.push(getCharFromInt(context_data_val));
+										context_data_val = 0;
+									} else context_data_position++;
+								}
+								value = context_w.charCodeAt(0);
+								for (i = 0; i < 8; i++) {
+									context_data_val = context_data_val << 1 | value & 1;
+									if (context_data_position == bitsPerChar - 1) {
+										context_data_position = 0;
+										context_data.push(getCharFromInt(context_data_val));
+										context_data_val = 0;
+									} else context_data_position++;
+									value = value >> 1;
+								}
+							} else {
+								value = 1;
+								for (i = 0; i < context_numBits; i++) {
+									context_data_val = context_data_val << 1 | value;
+									if (context_data_position == bitsPerChar - 1) {
+										context_data_position = 0;
+										context_data.push(getCharFromInt(context_data_val));
+										context_data_val = 0;
+									} else context_data_position++;
+									value = 0;
+								}
+								value = context_w.charCodeAt(0);
+								for (i = 0; i < 16; i++) {
+									context_data_val = context_data_val << 1 | value & 1;
+									if (context_data_position == bitsPerChar - 1) {
+										context_data_position = 0;
+										context_data.push(getCharFromInt(context_data_val));
+										context_data_val = 0;
+									} else context_data_position++;
+									value = value >> 1;
+								}
+							}
+							context_enlargeIn--;
+							if (context_enlargeIn == 0) {
+								context_enlargeIn = Math.pow(2, context_numBits);
+								context_numBits++;
+							}
+							delete context_dictionaryToCreate[context_w];
+						} else {
+							value = context_dictionary[context_w];
+							for (i = 0; i < context_numBits; i++) {
+								context_data_val = context_data_val << 1 | value & 1;
+								if (context_data_position == bitsPerChar - 1) {
+									context_data_position = 0;
+									context_data.push(getCharFromInt(context_data_val));
+									context_data_val = 0;
+								} else context_data_position++;
+								value = value >> 1;
+							}
+						}
+						context_enlargeIn--;
+						if (context_enlargeIn == 0) {
+							context_enlargeIn = Math.pow(2, context_numBits);
+							context_numBits++;
+						}
+						context_dictionary[context_wc] = context_dictSize++;
+						context_w = String(context_c);
+					}
+				}
+				if (context_w !== "") {
+					if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+						if (context_w.charCodeAt(0) < 256) {
+							for (i = 0; i < context_numBits; i++) {
+								context_data_val = context_data_val << 1;
+								if (context_data_position == bitsPerChar - 1) {
+									context_data_position = 0;
+									context_data.push(getCharFromInt(context_data_val));
+									context_data_val = 0;
+								} else context_data_position++;
+							}
+							value = context_w.charCodeAt(0);
+							for (i = 0; i < 8; i++) {
+								context_data_val = context_data_val << 1 | value & 1;
+								if (context_data_position == bitsPerChar - 1) {
+									context_data_position = 0;
+									context_data.push(getCharFromInt(context_data_val));
+									context_data_val = 0;
+								} else context_data_position++;
+								value = value >> 1;
+							}
+						} else {
+							value = 1;
+							for (i = 0; i < context_numBits; i++) {
+								context_data_val = context_data_val << 1 | value;
+								if (context_data_position == bitsPerChar - 1) {
+									context_data_position = 0;
+									context_data.push(getCharFromInt(context_data_val));
+									context_data_val = 0;
+								} else context_data_position++;
+								value = 0;
+							}
+							value = context_w.charCodeAt(0);
+							for (i = 0; i < 16; i++) {
+								context_data_val = context_data_val << 1 | value & 1;
+								if (context_data_position == bitsPerChar - 1) {
+									context_data_position = 0;
+									context_data.push(getCharFromInt(context_data_val));
+									context_data_val = 0;
+								} else context_data_position++;
+								value = value >> 1;
+							}
+						}
+						context_enlargeIn--;
+						if (context_enlargeIn == 0) {
+							context_enlargeIn = Math.pow(2, context_numBits);
+							context_numBits++;
+						}
+						delete context_dictionaryToCreate[context_w];
+					} else {
+						value = context_dictionary[context_w];
+						for (i = 0; i < context_numBits; i++) {
+							context_data_val = context_data_val << 1 | value & 1;
+							if (context_data_position == bitsPerChar - 1) {
+								context_data_position = 0;
+								context_data.push(getCharFromInt(context_data_val));
+								context_data_val = 0;
+							} else context_data_position++;
+							value = value >> 1;
+						}
+					}
+					context_enlargeIn--;
+					if (context_enlargeIn == 0) {
+						context_enlargeIn = Math.pow(2, context_numBits);
+						context_numBits++;
+					}
+				}
+				value = 2;
+				for (i = 0; i < context_numBits; i++) {
+					context_data_val = context_data_val << 1 | value & 1;
+					if (context_data_position == bitsPerChar - 1) {
+						context_data_position = 0;
+						context_data.push(getCharFromInt(context_data_val));
+						context_data_val = 0;
+					} else context_data_position++;
+					value = value >> 1;
+				}
+				while (true) {
+					context_data_val = context_data_val << 1;
+					if (context_data_position == bitsPerChar - 1) {
+						context_data.push(getCharFromInt(context_data_val));
+						break;
+					} else context_data_position++;
+				}
+				return context_data.join("");
+			},
+			decompress: function(compressed) {
+				if (compressed == null) return "";
+				if (compressed == "") return null;
+				return LZString._decompress(compressed.length, 32768, function(index) {
+					return compressed.charCodeAt(index);
+				});
+			},
+			_decompress: function(length, resetValue, getNextValue) {
+				var dictionary = [], enlargeIn = 4, dictSize = 4, numBits = 3, entry = "", result = [], i, w, bits, resb, maxpower, power, c, data = {
+					val: getNextValue(0),
+					position: resetValue,
+					index: 1
+				};
+				for (i = 0; i < 3; i += 1) dictionary[i] = i;
+				bits = 0;
+				maxpower = Math.pow(2, 2);
+				power = 1;
+				while (power != maxpower) {
+					resb = data.val & data.position;
+					data.position >>= 1;
+					if (data.position == 0) {
+						data.position = resetValue;
+						data.val = getNextValue(data.index++);
+					}
+					bits |= (resb > 0 ? 1 : 0) * power;
+					power <<= 1;
+				}
+				switch (bits) {
+					case 0:
+						bits = 0;
+						maxpower = Math.pow(2, 8);
+						power = 1;
+						while (power != maxpower) {
+							resb = data.val & data.position;
+							data.position >>= 1;
+							if (data.position == 0) {
+								data.position = resetValue;
+								data.val = getNextValue(data.index++);
+							}
+							bits |= (resb > 0 ? 1 : 0) * power;
+							power <<= 1;
+						}
+						c = f(bits);
+						break;
+					case 1:
+						bits = 0;
+						maxpower = Math.pow(2, 16);
+						power = 1;
+						while (power != maxpower) {
+							resb = data.val & data.position;
+							data.position >>= 1;
+							if (data.position == 0) {
+								data.position = resetValue;
+								data.val = getNextValue(data.index++);
+							}
+							bits |= (resb > 0 ? 1 : 0) * power;
+							power <<= 1;
+						}
+						c = f(bits);
+						break;
+					case 2: return "";
+				}
+				dictionary[3] = c;
+				w = c;
+				result.push(c);
+				while (true) {
+					if (data.index > length) return "";
+					bits = 0;
+					maxpower = Math.pow(2, numBits);
+					power = 1;
+					while (power != maxpower) {
+						resb = data.val & data.position;
+						data.position >>= 1;
+						if (data.position == 0) {
+							data.position = resetValue;
+							data.val = getNextValue(data.index++);
+						}
+						bits |= (resb > 0 ? 1 : 0) * power;
+						power <<= 1;
+					}
+					switch (c = bits) {
+						case 0:
+							bits = 0;
+							maxpower = Math.pow(2, 8);
+							power = 1;
+							while (power != maxpower) {
+								resb = data.val & data.position;
+								data.position >>= 1;
+								if (data.position == 0) {
+									data.position = resetValue;
+									data.val = getNextValue(data.index++);
+								}
+								bits |= (resb > 0 ? 1 : 0) * power;
+								power <<= 1;
+							}
+							dictionary[dictSize++] = f(bits);
+							c = dictSize - 1;
+							enlargeIn--;
+							break;
+						case 1:
+							bits = 0;
+							maxpower = Math.pow(2, 16);
+							power = 1;
+							while (power != maxpower) {
+								resb = data.val & data.position;
+								data.position >>= 1;
+								if (data.position == 0) {
+									data.position = resetValue;
+									data.val = getNextValue(data.index++);
+								}
+								bits |= (resb > 0 ? 1 : 0) * power;
+								power <<= 1;
+							}
+							dictionary[dictSize++] = f(bits);
+							c = dictSize - 1;
+							enlargeIn--;
+							break;
+						case 2: return result.join("");
+					}
+					if (enlargeIn == 0) {
+						enlargeIn = Math.pow(2, numBits);
+						numBits++;
+					}
+					if (dictionary[c]) entry = dictionary[c];
+					else if (c === dictSize) entry = w + w.charAt(0);
+					else return null;
+					result.push(entry);
+					dictionary[dictSize++] = w + entry.charAt(0);
+					enlargeIn--;
+					w = entry;
+					if (enlargeIn == 0) {
+						enlargeIn = Math.pow(2, numBits);
+						numBits++;
+					}
+				}
+			}
+		};
+		return LZString;
+	})();
+	if (typeof define === "function" && define.amd) define(function() {
+		return LZString;
+	});
+	else if (typeof module !== "undefined" && module != null) module.exports = LZString;
+	else if (typeof angular !== "undefined" && angular != null) angular.module("LZString", []).factory("LZString", function() {
+		return LZString;
+	});
+})))(), 1);
+var DocumentModelNotFoundError = class extends Error {
+	documentType;
+	name = "DocumentModelNotFoundError";
+	constructor(documentType) {
+		super(`Document model module for type ${documentType} not found`);
+		this.documentType = documentType;
+	}
+	static isError(error) {
+		return Error.isError(error) && error.name === "DocumentModelNotFoundError";
+	}
+};
+var DocumentTypeMismatchError = class extends Error {
+	constructor(documentId, expectedType, actualType) {
+		super(`Document ${documentId} is not of type ${expectedType}. Actual type: ${actualType}`);
+	}
+};
+var NoSelectedDocumentError = class extends Error {
+	constructor() {
+		super("There is no selected document. Did you mean to call 'useSelectedDocumentSafe' instead?");
+	}
+};
+function getUserPermissions() {
+	const user = window.ph?.renown?.user;
+	const allowList = window.ph?.allowList;
+	if (!allowList) return {
+		isAllowedToCreateDocuments: true,
+		isAllowedToEditDocuments: true
+	};
+	return {
+		isAllowedToCreateDocuments: allowList.includes(user?.address ?? ""),
+		isAllowedToEditDocuments: allowList.includes(user?.address ?? "")
+	};
+}
+const BASE_STATE_KEYS = new Set(["auth"]);
+const NON_DOMAIN_SCOPES = new Set(["auth", "document"]);
+async function downloadFile(document, fileName) {
+	try {
+		const data = await createZip(document);
+		const blob = new Blob([new Uint8Array(data)], { type: "application/zip" });
+		const link = window.document.createElement("a");
+		link.style.display = "none";
+		link.href = URL.createObjectURL(blob);
+		link.download = fileName;
+		window.document.body.appendChild(link);
+		link.click();
+		window.document.body.removeChild(link);
+	} catch (e) {
+		logger.error(e instanceof Error ? e.message : String(e));
+	}
+}
+async function getDocumentExtension(document) {
+	const documentType = document.header.documentType;
+	let rawExtension;
+	if (documentType === "powerhouse/document-model") rawExtension = document.state.global?.extension;
+	else {
+		const reactorClient = window.ph?.reactorClient;
+		if (reactorClient) {
+			const { results: documentModelModules } = await reactorClient.getDocumentModelModules();
+			rawExtension = documentModelModules.find((m) => m.documentModel.global.id === documentType)?.utils.fileExtension;
+		}
+	}
+	return (rawExtension ?? "").replace(/^\.+|\.+$/g, "");
+}
+/**
+* Fetches all operations for a document using cursor-based pagination.
+* The reactor client handles multi-scope cursors transparently via
+* composite cursors, so all scopes are fetched in a single paginated stream.
+*/
+async function fetchDocumentOperations(reactorClient, document, pageSize = 100) {
+	const scopes = Object.keys(document.state).filter((k) => !BASE_STATE_KEYS.has(k));
+	const operations = {};
+	for (const scope of scopes) operations[scope] = [];
+	let cursor = "";
+	do {
+		const page = await reactorClient.getOperations(document.header.id, { scopes }, void 0, {
+			cursor,
+			limit: pageSize
+		});
+		for (const op of page.results) {
+			const scope = op.action.scope ?? "global";
+			if (operations[scope]) operations[scope].push(op);
+		}
+		cursor = page.nextCursor ?? "";
+	} while (cursor);
+	return operations;
+}
+function extractInitialState(documentScopeOps) {
+	const upgradeOp = documentScopeOps.find((op) => op.action.type === "UPGRADE_DOCUMENT");
+	if (!upgradeOp) throw new Error("No UPGRADE_DOCUMENT operation found — document is invalid");
+	const input = upgradeOp.action.input;
+	const initialState = input.initialState ?? input.state;
+	if (!initialState) throw new Error("UPGRADE_DOCUMENT operation has no initialState — document is invalid");
+	return initialState;
+}
+function filterDomainOperations(operations) {
+	return Object.fromEntries(Object.entries(operations).filter(([scope]) => !NON_DOMAIN_SCOPES.has(scope)));
+}
+async function exportFile(document, suggestedName) {
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const operations = await fetchDocumentOperations(reactorClient, document);
+	const initialState = extractInitialState(operations["document"] ?? []);
+	const documentWithOps = {
+		...document,
+		operations,
+		initialState
+	};
+	const extension = await getDocumentExtension(documentWithOps);
+	const baseName = suggestedName || documentWithOps.header.name || "Untitled";
+	const name = extension ? `${baseName}.${extension}.phd` : `${baseName}.phd`;
+	if (!window.showSaveFilePicker) return await downloadFile(documentWithOps, name);
+	try {
+		const fileHandle = await window.showSaveFilePicker({ suggestedName: name });
+		await baseSaveToFileHandle(documentWithOps, fileHandle);
+		return fileHandle;
+	} catch (e) {
+		if (!(e instanceof DOMException && e.name === "AbortError")) throw e;
+	}
+}
+async function loadFile(path) {
+	const baseDocument = await baseLoadFromInput(path, (state) => state, { checkHashes: true });
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const { results: documentModelModules } = await reactorClient.getDocumentModelModules();
+	const documentModelModule = documentModelModules.find((module) => module.documentModel.global.id === baseDocument.header.documentType);
+	if (!documentModelModule) throw new DocumentModelNotFoundError(baseDocument.header.documentType);
+	return documentModelModule.utils.loadFromInput(path);
+}
+async function addDocument(driveId, name, documentType, parentFolder, document, id, preferredEditor) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const documentModelModule = await reactorClient.getDocumentModelModule(documentType);
+	const newDocument = document ?? documentModelModule.utils.createDocument();
+	newDocument.header.name = name;
+	if (preferredEditor) newDocument.header.meta = {
+		...newDocument.header.meta,
+		preferredEditor
+	};
+	let newDoc;
+	try {
+		newDoc = await reactorClient.drives.addFile(driveId, newDocument, parentFolder);
+	} catch (e) {
+		logger.error("Error adding document: @error", e);
+		throw new Error("There was an error adding document", { cause: e });
+	}
+	return {
+		id: newDoc.header.id,
+		name: newDoc.header.name,
+		documentType,
+		parentFolder: parentFolder ?? null,
+		kind: "file"
+	};
+}
+async function addFile(file, driveId, name, parentFolder) {
+	logger.verbose(`addFile(drive: ${driveId}, name: ${name}, folder: ${parentFolder})`);
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create files");
+	const document = await loadFile(file);
+	let duplicateId = false;
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	try {
+		await reactorClient.get(document.header.id);
+		duplicateId = true;
+	} catch {}
+	const documentId = duplicateId ? generateId() : document.header.id;
+	const header = createPresignedHeader(documentId, document.header.documentType);
+	header.lastModifiedAtUtcIso = document.header.createdAtUtcIso;
+	header.meta = document.header.meta;
+	header.name = name || document.header.name;
+	const initialDocument = {
+		...document,
+		header,
+		state: document.initialState,
+		operations: Object.keys(document.operations).reduce((acc, key) => {
+			acc[key] = [];
+			return acc;
+		}, {})
+	};
+	await addDocument(driveId, name || document.header.name, document.header.documentType, parentFolder, initialDocument, documentId, document.header.meta?.preferredEditor);
+	await uploadOperations(documentId, filterDomainOperations(document.operations), queueOperations);
+}
+async function addFolder(driveId, name, parentFolder) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to create folders");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	await reactorClient.get(driveId);
+	const folderId = generateId();
+	const node = (await reactorClient.execute(driveId, "main", [addFolder$1({
+		id: folderId,
+		name,
+		parentFolder
+	})])).state.global.nodes.find((node) => node.id === folderId);
+	if (!node || !isFolderNode(node)) throw new Error("There was an error adding folder");
+	return node;
+}
+async function renameNode(driveId, nodeId, name) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to rename documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	if ((await reactorClient.execute(nodeId, "main", [setName({ name })])).header.name !== name) throw new Error("There was an error renaming the node");
+	const node = (await reactorClient.execute(driveId, "main", [updateNode({
+		id: nodeId,
+		name
+	})])).state.global.nodes.find((n) => n.id === nodeId);
+	if (!node) throw new Error("There was an error renaming node in the drive");
+	return node;
+}
+async function renameDriveNode(driveId, nodeId, name) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to rename documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	if ((await reactorClient.execute(nodeId, "main", [setName({ name })])).header.name !== name) throw new Error("There was an error renaming the node");
+	await reactorClient.execute(driveId, "main", [updateNode({
+		id: nodeId,
+		name
+	})]);
+	return (await reactorClient.get(driveId)).state.global.nodes.find((n) => n.id === nodeId);
+}
+async function moveNodeById(args) {
+	const { driveId, srcId, targetId } = args;
+	if (!driveId || !srcId) return;
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to move documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	const targetParentFolder = t$3(targetId, [e$3(e$4), e$6(void 0)], [t(driveId), e$6(void 0)], e$6(targetId));
+	if (t(targetParentFolder, srcId)) return;
+	return await reactorClient.execute(driveId, "main", [moveNode({
+		srcFolder: srcId,
+		targetParentFolder
+	})]);
+}
+async function moveNode$1(driveId, src, target) {
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to move documents");
+	const reactorClient = window.ph?.reactorClient;
+	if (!reactorClient) throw new Error("ReactorClient not initialized");
+	return await reactorClient.execute(driveId, "main", [moveNode({
+		srcFolder: src.id,
+		targetParentFolder: target?.id
+	})]);
+}
+async function _duplicateDocument(reactor, document, newId = generateId()) {
+	const documentModule = await reactor.getDocumentModelModule(document.header.documentType);
+	return replayDocument(document.initialState, document.operations, documentModule.reducer, createPresignedHeader(newId, document.header.documentType));
+}
+async function copyNode$1(driveId, src, target) {
+	const reactor = window.ph?.reactorClient;
+	if (!reactor) return;
+	const { isAllowedToCreateDocuments } = getUserPermissions();
+	if (!isAllowedToCreateDocuments) throw new Error("User is not allowed to copy documents");
+	const drive = await reactor.get(driveId);
+	const copyNodesInput = generateNodesCopy({
+		srcId: src.id,
+		targetParentFolder: target?.id,
+		targetName: src.name
+	}, () => generateId(), drive.state.global.nodes);
+	const resolvedNamesMap = /* @__PURE__ */ new Map();
+	for (const copyNodeInput of copyNodesInput) {
+		const node = drive.state.global.nodes.find((n) => n.id === copyNodeInput.srcId);
+		if (node) {
+			const resolvedName = handleTargetNameCollisions({
+				nodes: drive.state.global.nodes,
+				srcName: copyNodeInput.targetName || node.name,
+				srcKind: isFileNode(node) ? "file" : "folder",
+				targetParentFolder: copyNodeInput.targetParentFolder || null
+			});
+			resolvedNamesMap.set(copyNodeInput.targetId, resolvedName);
+		}
+	}
+	const fileNodesToCopy = copyNodesInput.filter((copyNodeInput) => {
+		const node = drive.state.global.nodes.find((node) => node.id === copyNodeInput.srcId);
+		return node !== void 0 && isFileNode(node);
+	});
+	for (const fileNodeToCopy of fileNodesToCopy) try {
+		const duplicatedDocument = await _duplicateDocument(reactor, await reactor.get(fileNodeToCopy.srcId), fileNodeToCopy.targetId);
+		const resolvedName = resolvedNamesMap.get(fileNodeToCopy.targetId);
+		if (resolvedName) duplicatedDocument.header.name = resolvedName;
+		await reactor.drives.addFile(driveId, duplicatedDocument, target?.id);
+	} catch (e) {
+		logger.error(`Error copying document ${fileNodeToCopy.srcId}: ${String(e)}`);
+	}
+	return await queueActions(drive, copyNodesInput.map((copyNodeInput) => copyNode(copyNodeInput)));
+}
+const baseDocumentModelsMap = {
+	DocumentModel: documentModelDocumentModelModule,
+	DocumentDrive: driveDocumentModelModule,
+	ReactorDrive: reactorDriveDocumentModelModule
+};
+Object.values(baseDocumentModelsMap);
+const isExternalControlsEnabledEventFunctions = makePHEventFunctions("isExternalControlsEnabled");
+/** Sets whether external controls are enabled for a given editor. */
+const setIsExternalControlsEnabled = isExternalControlsEnabledEventFunctions.setValue;
+/** Gets whether external controls are enabled for a given editor. */
+const useIsExternalControlsEnabled = isExternalControlsEnabledEventFunctions.useValue;
+isExternalControlsEnabledEventFunctions.addEventHandler;
+const isDragAndDropEnabledEventFunctions = makePHEventFunctions("isDragAndDropEnabled");
+/** Sets whether drag and drop is enabled for a given app. */
+const setIsDragAndDropEnabled = isDragAndDropEnabledEventFunctions.setValue;
+/** Gets whether drag and drop is enabled for a given app. */
+const useIsDragAndDropEnabled = isDragAndDropEnabledEventFunctions.useValue;
+isDragAndDropEnabledEventFunctions.addEventHandler;
+const allowedDocumentTypesEventFunctions = makePHEventFunctions("allowedDocumentTypes");
+/** Sets the allowed document types for a given app. */
+const setAllowedDocumentTypes = allowedDocumentTypesEventFunctions.setValue;
+/** Defines the document types a drive supports.
+*
+* Defaults to all of the document types registered in the reactor.
+*/
+function useAllowedDocumentTypes() {
+	return allowedDocumentTypesEventFunctions.useValue();
+}
+allowedDocumentTypesEventFunctions.addEventHandler;
+const phAppConfigSetters = {
+	allowedDocumentTypes: setAllowedDocumentTypes,
+	isDragAndDropEnabled: setIsDragAndDropEnabled
+};
+const phDocumentEditorConfigSetters = { isExternalControlsEnabled: setIsExternalControlsEnabled };
+const phAppConfigHooks = {
+	allowedDocumentTypes: useAllowedDocumentTypes,
+	isDragAndDropEnabled: useIsDragAndDropEnabled
+};
+const phDocumentEditorConfigHooks = { isExternalControlsEnabled: useIsExternalControlsEnabled };
+const { useValue: useRouterBasename, setValue: setRouterBasename, addEventHandler: addRouterBasenameEventHandler } = makePHEventFunctions("routerBasename");
+const { useValue: useVersion, setValue: setVersion, addEventHandler: addVersionEventHandler } = makePHEventFunctions("version");
+const { useValue: useRequiresHardRefresh, setValue: setRequiresHardRefresh, addEventHandler: addRequiresHardRefreshEventHandler } = makePHEventFunctions("requiresHardRefresh");
+const { useValue: useWarnOutdatedApp, setValue: setWarnOutdatedApp, addEventHandler: addWarnOutdatedAppEventHandler } = makePHEventFunctions("warnOutdatedApp");
+const { useValue: useStudioMode, setValue: setStudioMode, addEventHandler: addStudioModeEventHandler } = makePHEventFunctions("studioMode");
+const { useValue: useBasePath, setValue: setBasePath, addEventHandler: addBasePathEventHandler } = makePHEventFunctions("basePath");
+const { useValue: useVersionCheckInterval, setValue: setVersionCheckInterval, addEventHandler: addVersionCheckIntervalEventHandler } = makePHEventFunctions("versionCheckInterval");
+const { useValue: useCliVersion, setValue: setCliVersion, addEventHandler: addCliVersionEventHandler } = makePHEventFunctions("cliVersion");
+const { useValue: useFileUploadOperationsChunkSize, setValue: setFileUploadOperationsChunkSize, addEventHandler: addFileUploadOperationsChunkSizeEventHandler } = makePHEventFunctions("fileUploadOperationsChunkSize");
+const { useValue: useIsDocumentModelSelectionSettingsEnabled, setValue: setIsDocumentModelSelectionSettingsEnabled, addEventHandler: addIsDocumentModelSelectionSettingsEnabledEventHandler } = makePHEventFunctions("isDocumentModelSelectionSettingsEnabled");
+const { useValue: useGaTrackingId, setValue: setGaTrackingId, addEventHandler: addGaTrackingIdEventHandler } = makePHEventFunctions("gaTrackingId");
+const { useValue: useDefaultDrivesUrl, setValue: setDefaultDrivesUrl, addEventHandler: addDefaultDrivesUrlEventHandler } = makePHEventFunctions("defaultDrivesUrl");
+const { useValue: useDrivesPreserveStrategy, setValue: setDrivesPreserveStrategy, addEventHandler: addDrivesPreserveStrategyEventHandler } = makePHEventFunctions("drivesPreserveStrategy");
+const { useValue: useIsLocalDrivesEnabled, setValue: setIsLocalDrivesEnabled, addEventHandler: addIsLocalDrivesEnabledEventHandler } = makePHEventFunctions("isLocalDrivesEnabled");
+const { useValue: useIsAddDriveEnabled, setValue: setIsAddDriveEnabled, addEventHandler: addIsAddDriveEnabledEventHandler } = makePHEventFunctions("isAddDriveEnabled");
+const { useValue: useIsPublicDrivesEnabled, setValue: setIsPublicDrivesEnabled, addEventHandler: addIsPublicDrivesEnabledEventHandler } = makePHEventFunctions("isPublicDrivesEnabled");
+const { useValue: useIsAddPublicDrivesEnabled, setValue: setIsAddPublicDrivesEnabled, addEventHandler: addIsAddPublicDrivesEnabledEventHandler } = makePHEventFunctions("isAddPublicDrivesEnabled");
+const { useValue: useIsDeletePublicDrivesEnabled, setValue: setIsDeletePublicDrivesEnabled, addEventHandler: addIsDeletePublicDrivesEnabledEventHandler } = makePHEventFunctions("isDeletePublicDrivesEnabled");
+const { useValue: useIsCloudDrivesEnabled, setValue: setIsCloudDrivesEnabled, addEventHandler: addIsCloudDrivesEnabledEventHandler } = makePHEventFunctions("isCloudDrivesEnabled");
+const { useValue: useIsAddCloudDrivesEnabled, setValue: setIsAddCloudDrivesEnabled, addEventHandler: addIsAddCloudDrivesEnabledEventHandler } = makePHEventFunctions("isAddCloudDrivesEnabled");
+const { useValue: useIsDeleteCloudDrivesEnabled, setValue: setIsDeleteCloudDrivesEnabled, addEventHandler: addIsDeleteCloudDrivesEnabledEventHandler } = makePHEventFunctions("isDeleteCloudDrivesEnabled");
+const { useValue: useLocalDrivesEnabled, setValue: setLocalDrivesEnabled, addEventHandler: addLocalDrivesEnabledEventHandler } = makePHEventFunctions("isLocalDrivesEnabled");
+const { useValue: useIsAddLocalDrivesEnabled, setValue: setIsAddLocalDrivesEnabled, addEventHandler: addIsAddLocalDrivesEnabledEventHandler } = makePHEventFunctions("isAddLocalDrivesEnabled");
+const { useValue: useIsDeleteLocalDrivesEnabled, setValue: setIsDeleteLocalDrivesEnabled, addEventHandler: addIsDeleteLocalDrivesEnabledEventHandler } = makePHEventFunctions("isDeleteLocalDrivesEnabled");
+const { useValue: useIsEditorDebugModeEnabled, setValue: setIsEditorDebugModeEnabled, addEventHandler: addIsEditorDebugModeEnabledEventHandler } = makePHEventFunctions("isEditorDebugModeEnabled");
+const { useValue: useIsEditorReadModeEnabled, setValue: setIsEditorReadModeEnabled, addEventHandler: addIsEditorReadModeEnabledEventHandler } = makePHEventFunctions("isEditorReadModeEnabled");
+const { useValue: useIsAnalyticsDatabaseWorkerEnabled, setValue: setIsAnalyticsDatabaseWorkerEnabled, addEventHandler: addIsAnalyticsDatabaseWorkerEnabledEventHandler } = makePHEventFunctions("isAnalyticsDatabaseWorkerEnabled");
+const { useValue: useIsDiffAnalyticsEnabled, setValue: setIsDiffAnalyticsEnabled, addEventHandler: addIsDiffAnalyticsEnabledEventHandler } = makePHEventFunctions("isDiffAnalyticsEnabled");
+const { useValue: useIsDriveAnalyticsEnabled, setValue: setIsDriveAnalyticsEnabled, addEventHandler: addIsDriveAnalyticsEnabledEventHandler } = makePHEventFunctions("isDriveAnalyticsEnabled");
+const { useValue: useRenownUrl, setValue: setRenownUrl, addEventHandler: addRenownUrlEventHandler } = makePHEventFunctions("renownUrl");
+const { useValue: useRenownNetworkId, setValue: setRenownNetworkId, addEventHandler: addRenownNetworkIdEventHandler } = makePHEventFunctions("renownNetworkId");
+const { useValue: useRenownChainId, setValue: setRenownChainId, addEventHandler: addRenownChainIdEventHandler } = makePHEventFunctions("renownChainId");
+const { useValue: useSentryRelease, setValue: setSentryRelease, addEventHandler: addSentryReleaseEventHandler } = makePHEventFunctions("sentryRelease");
+const { useValue: useSentryDsn, setValue: setSentryDsn, addEventHandler: addSentryDsnEventHandler } = makePHEventFunctions("sentryDsn");
+const { useValue: useSentryEnv, setValue: setSentryEnv, addEventHandler: addSentryEnvEventHandler } = makePHEventFunctions("sentryEnv");
+const { useValue: useIsSentryTracingEnabled, setValue: setIsSentryTracingEnabled, addEventHandler: addIsSentryTracingEnabledEventHandler } = makePHEventFunctions("isSentryTracingEnabled");
+const { useValue: useIsExternalProcessorsEnabled, setValue: setIsExternalProcessorsEnabled, addEventHandler: addIsExternalProcessorsEnabledEventHandler } = makePHEventFunctions("isExternalProcessorsEnabled");
+const { useValue: useIsExternalPackagesEnabled, setValue: setIsExternalPackagesEnabled, addEventHandler: addIsExternalPackagesEnabledEventHandler } = makePHEventFunctions("isExternalPackagesEnabled");
+const enabledEditorsEventFunctions = makePHEventFunctions("enabledEditors");
+/** Sets the enabled editors for Connect. */
+const setEnabledEditors = enabledEditorsEventFunctions.setValue;
+/** Gets the enabled editors for Connect. */
+const useEnabledEditors = enabledEditorsEventFunctions.useValue;
+enabledEditorsEventFunctions.addEventHandler;
+const disabledEditorsEventFunctions = makePHEventFunctions("disabledEditors");
+/** Sets the disabled editors for Connect. */
+const setDisabledEditors = disabledEditorsEventFunctions.setValue;
+/** Gets the disabled editors for Connect. */
+const useDisabledEditors = disabledEditorsEventFunctions.useValue;
+disabledEditorsEventFunctions.addEventHandler;
+const isRelationalProcessorsEnabled = makePHEventFunctions("isRelationalProcessorsEnabled");
+/** Sets the isRelationalProcessorsEnabled for Connect. */
+const setIsRelationalProcessorsEnabled = isRelationalProcessorsEnabled.setValue;
+/** Gets the isRelationalProcessorsEnabled for Connect. */
+const useIsRelationalProcessorsEnabled = isRelationalProcessorsEnabled.useValue;
+isRelationalProcessorsEnabled.addEventHandler;
+const isExternalRelationalProcessorsEnabled = makePHEventFunctions("isExternalRelationalProcessorsEnabled");
+/** Sets the isExternalRelationalProcessorsEnabled for Connect. */
+const setIsExternalRelationalProcessorsEnabled = isExternalRelationalProcessorsEnabled.setValue;
+/** Gets the isExternalRelationalProcessorsEnabled for Connect. */
+const useIsExternalRelationalProcessorsEnabled = isExternalRelationalProcessorsEnabled.useValue;
+isExternalRelationalProcessorsEnabled.addEventHandler;
+const isAnalyticsEnabledEventFunctions = makePHEventFunctions("isAnalyticsEnabled");
+/** Sets the isAnalyticsEnabled for Connect. */
+const setIsAnalyticsEnabled = isAnalyticsEnabledEventFunctions.setValue;
+/** Gets the isAnalyticsEnabled for Connect. */
+const useIsAnalyticsEnabled = isAnalyticsEnabledEventFunctions.useValue;
+isAnalyticsEnabledEventFunctions.addEventHandler;
+const isAnalyticsExternalProcessorsEnabled = makePHEventFunctions("isAnalyticsExternalProcessorsEnabled");
+/** Sets the isAnalyticsExternalProcessorsEnabled for Connect. */
+const setIsAnalyticsExternalProcessorsEnabled = isAnalyticsExternalProcessorsEnabled.setValue;
+/** Gets the isAnalyticsExternalProcessorsEnabled for Connect. */
+const useIsAnalyticsExternalProcessorsEnabled = isAnalyticsExternalProcessorsEnabled.useValue;
+isAnalyticsExternalProcessorsEnabled.addEventHandler;
+const analyticsDatabaseNameEventFunctions = makePHEventFunctions("analyticsDatabaseName");
+/** Sets the analytics database name for Connect. */
+const setAnalyticsDatabaseName = analyticsDatabaseNameEventFunctions.setValue;
+/** Gets the analytics database name for Connect. */
+const useAnalyticsDatabaseName = analyticsDatabaseNameEventFunctions.useValue;
+analyticsDatabaseNameEventFunctions.addEventHandler;
+const logLevelEventFunctions = makePHEventFunctions("logLevel");
+/** Sets the log level for Connect. */
+const setLogLevel = logLevelEventFunctions.setValue;
+/** Gets the log level for Connect. */
+const useLogLevel = logLevelEventFunctions.useValue;
+logLevelEventFunctions.addEventHandler;
+const allowListEventFunctions = makePHEventFunctions("allowList");
+/** Sets the allow list for Connect. */
+const setAllowList = allowListEventFunctions.setValue;
+/** Gets the allow list for Connect. */
+const useAllowList = allowListEventFunctions.useValue;
+allowListEventFunctions.addEventHandler;
+const nonUserConfigSetters = {
+	routerBasename: setRouterBasename,
+	version: setVersion,
+	requiresHardRefresh: setRequiresHardRefresh,
+	warnOutdatedApp: setWarnOutdatedApp,
+	studioMode: setStudioMode,
+	basePath: setBasePath,
+	versionCheckInterval: setVersionCheckInterval,
+	cliVersion: setCliVersion,
+	fileUploadOperationsChunkSize: setFileUploadOperationsChunkSize,
+	isDocumentModelSelectionSettingsEnabled: setIsDocumentModelSelectionSettingsEnabled,
+	gaTrackingId: setGaTrackingId,
+	defaultDrivesUrl: setDefaultDrivesUrl,
+	drivesPreserveStrategy: setDrivesPreserveStrategy,
+	isLocalDrivesEnabled: setIsLocalDrivesEnabled,
+	isAddDriveEnabled: setIsAddDriveEnabled,
+	isPublicDrivesEnabled: setIsPublicDrivesEnabled,
+	isAddPublicDrivesEnabled: setIsAddPublicDrivesEnabled,
+	isDeletePublicDrivesEnabled: setIsDeletePublicDrivesEnabled,
+	isCloudDrivesEnabled: setIsCloudDrivesEnabled,
+	isAddCloudDrivesEnabled: setIsAddCloudDrivesEnabled,
+	isDeleteCloudDrivesEnabled: setIsDeleteCloudDrivesEnabled,
+	isAddLocalDrivesEnabled: setIsAddLocalDrivesEnabled,
+	isDeleteLocalDrivesEnabled: setIsDeleteLocalDrivesEnabled,
+	isEditorDebugModeEnabled: setIsEditorDebugModeEnabled,
+	isEditorReadModeEnabled: setIsEditorReadModeEnabled,
+	isRelationalProcessorsEnabled: setIsRelationalProcessorsEnabled,
+	isExternalRelationalProcessorsEnabled: setIsExternalRelationalProcessorsEnabled,
+	isAnalyticsEnabled: setIsAnalyticsEnabled,
+	analyticsDatabaseName: setAnalyticsDatabaseName,
+	isAnalyticsExternalProcessorsEnabled: setIsAnalyticsExternalProcessorsEnabled,
+	isAnalyticsDatabaseWorkerEnabled: setIsAnalyticsDatabaseWorkerEnabled,
+	isDiffAnalyticsEnabled: setIsDiffAnalyticsEnabled,
+	isDriveAnalyticsEnabled: setIsDriveAnalyticsEnabled,
+	renownUrl: setRenownUrl,
+	renownNetworkId: setRenownNetworkId,
+	renownChainId: setRenownChainId,
+	sentryRelease: setSentryRelease,
+	sentryDsn: setSentryDsn,
+	sentryEnv: setSentryEnv,
+	isSentryTracingEnabled: setIsSentryTracingEnabled,
+	isExternalProcessorsEnabled: setIsExternalProcessorsEnabled,
+	isExternalPackagesEnabled: setIsExternalPackagesEnabled,
+	allowList: setAllowList,
+	logLevel: setLogLevel,
+	disabledEditors: setDisabledEditors,
+	enabledEditors: setEnabledEditors
+};
+const phGlobalConfigSetters = {
+	...phAppConfigSetters,
+	...phDocumentEditorConfigSetters,
+	...nonUserConfigSetters
+};
+const nonUserConfigHooks = {
+	routerBasename: useRouterBasename,
+	version: useVersion,
+	requiresHardRefresh: useRequiresHardRefresh,
+	warnOutdatedApp: useWarnOutdatedApp,
+	studioMode: useStudioMode,
+	basePath: useBasePath,
+	versionCheckInterval: useVersionCheckInterval,
+	cliVersion: useCliVersion,
+	fileUploadOperationsChunkSize: useFileUploadOperationsChunkSize,
+	isDocumentModelSelectionSettingsEnabled: useIsDocumentModelSelectionSettingsEnabled,
+	gaTrackingId: useGaTrackingId,
+	defaultDrivesUrl: useDefaultDrivesUrl,
+	drivesPreserveStrategy: useDrivesPreserveStrategy,
+	isAddDriveEnabled: useIsAddDriveEnabled,
+	isPublicDrivesEnabled: useIsPublicDrivesEnabled,
+	isAddPublicDrivesEnabled: useIsAddPublicDrivesEnabled,
+	isDeletePublicDrivesEnabled: useIsDeletePublicDrivesEnabled,
+	isCloudDrivesEnabled: useIsCloudDrivesEnabled,
+	isAddCloudDrivesEnabled: useIsAddCloudDrivesEnabled,
+	isDeleteCloudDrivesEnabled: useIsDeleteCloudDrivesEnabled,
+	isLocalDrivesEnabled: useIsLocalDrivesEnabled,
+	isAddLocalDrivesEnabled: useIsAddLocalDrivesEnabled,
+	isDeleteLocalDrivesEnabled: useIsDeleteLocalDrivesEnabled,
+	isEditorDebugModeEnabled: useIsEditorDebugModeEnabled,
+	isEditorReadModeEnabled: useIsEditorReadModeEnabled,
+	isAnalyticsDatabaseWorkerEnabled: useIsAnalyticsDatabaseWorkerEnabled,
+	isDiffAnalyticsEnabled: useIsDiffAnalyticsEnabled,
+	isDriveAnalyticsEnabled: useIsDriveAnalyticsEnabled,
+	renownUrl: useRenownUrl,
+	renownNetworkId: useRenownNetworkId,
+	renownChainId: useRenownChainId,
+	sentryRelease: useSentryRelease,
+	sentryDsn: useSentryDsn,
+	sentryEnv: useSentryEnv,
+	isSentryTracingEnabled: useIsSentryTracingEnabled,
+	isExternalProcessorsEnabled: useIsExternalProcessorsEnabled,
+	isExternalPackagesEnabled: useIsExternalPackagesEnabled,
+	allowList: useAllowList,
+	isAnalyticsEnabled: useIsAnalyticsEnabled,
+	isAnalyticsExternalProcessorsEnabled: useIsAnalyticsExternalProcessorsEnabled,
+	isRelationalProcessorsEnabled: useIsRelationalProcessorsEnabled,
+	isExternalRelationalProcessorsEnabled: useIsExternalRelationalProcessorsEnabled,
+	analyticsDatabaseName: useAnalyticsDatabaseName,
+	logLevel: useLogLevel,
+	disabledEditors: useDisabledEditors,
+	enabledEditors: useEnabledEditors
+};
+({
+	...phAppConfigHooks,
+	...phDocumentEditorConfigHooks,
+	...nonUserConfigHooks
+});
+const attachmentServiceEventFunctions = makePHEventFunctions("attachmentService");
+attachmentServiceEventFunctions.useValue;
+attachmentServiceEventFunctions.setValue;
+attachmentServiceEventFunctions.addEventHandler;
+const featuresEventFunctions = makePHEventFunctions("features");
+featuresEventFunctions.useValue;
+featuresEventFunctions.setValue;
+featuresEventFunctions.addEventHandler;
+function resolveUrlPathname(path) {
+	return new URL(path.replace(/^\/+/, ""), window.location.origin + (window.ph?.basePath ?? "/")).pathname;
+}
+/** Returns the current path without the base path */
+function getPathWithoutBase(path) {
+	const basePath = window.ph?.basePath ?? "/";
+	return path.replace(basePath, basePath.endsWith("/") ? "/" : "");
+}
+/** Makes a URL component for a node. */
+function makeNodeSlug(node) {
+	if (!node) return "";
+	const nodeName = node.name;
+	if (!nodeName) return slug(node.id);
+	return slug(`${nodeName}-${node.id}`);
+}
+/** Extracts the node slug from a path.
+*
+* The path is expected to be in the format `/d/<drive-slug>/<node-slug>`.
+*/
+function extractNodeSlugFromPath(path) {
+	const currentPath = getPathWithoutBase(path);
+	return /^\/d\/[^/]+\/([^/]+)$/.exec(currentPath)?.[1];
+}
+/** Finds a UUID in a string, used for extracting node ids from node slugs in the URL. */
+function findUuid(input) {
+	if (!input) return void 0;
+	return /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/.exec(input)?.[0];
+}
+function extractNodeIdFromSlug(nodeSlug) {
+	return findUuid(nodeSlug);
+}
+/** Extracts the drive slug from a path.
+* Used for extracting drive ids from drive slugs in the URL.
+* Expects the path to be in the format `/d/<drive-slug>`.
+*/
+function extractDriveSlugFromPath(path) {
+	const currentPath = getPathWithoutBase(path);
+	return /^\/d\/([^/]+)/.exec(currentPath)?.[1] ?? "";
+}
+/**
+* Creates a URL string with the given pathname while preserving existing query parameters.
+*/
+function createUrlWithPreservedParams(pathname) {
+	const search = window.location.search;
+	return search ? `${pathname}${search}` : pathname;
+}
+const drivesEventFunctions = makePHEventFunctions("drives");
+/** Returns all of the drives in the reactor */
+const useDrives = drivesEventFunctions.useValue;
+/** Sets the drives in the reactor */
+const setDrives = drivesEventFunctions.setValue;
+drivesEventFunctions.addEventHandler;
+const selectedNodeIdEventFunctions = makePHEventFunctions("selectedNodeId");
+const useSelectedNodeId = selectedNodeIdEventFunctions.useValue;
+const setSelectedNodeId = selectedNodeIdEventFunctions.setValue;
+selectedNodeIdEventFunctions.addEventHandler;
+/** Sets the selected node (file or folder). */
+function setSelectedNode(nodeOrNodeSlug) {
+	const nodeSlug = typeof nodeOrNodeSlug === "string" ? nodeOrNodeSlug : makeNodeSlug(nodeOrNodeSlug);
+	setSelectedNodeId(extractNodeIdFromSlug(nodeSlug));
+	const driveSlugFromPath = extractDriveSlugFromPath(window.location.pathname);
+	if (!driveSlugFromPath) return;
+	if (!nodeSlug) {
+		const pathname = resolveUrlPathname(`/d/${driveSlugFromPath}`);
+		if (pathname === window.location.pathname) return;
+		window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+		return;
+	}
+	const pathname = resolveUrlPathname(`/d/${driveSlugFromPath}/${nodeSlug}`);
+	if (pathname === window.location.pathname) return;
+	window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+}
+const selectedDriveIdEventFunctions = makePHEventFunctions("selectedDriveId");
+/** Returns the selected drive id */
+const useSelectedDriveId = selectedDriveIdEventFunctions.useValue;
+/** Sets the selected drive id */
+const setSelectedDriveId = selectedDriveIdEventFunctions.setValue;
+selectedDriveIdEventFunctions.addEventHandler;
+/** Returns the selected drive, or undefined if no drive is selected */
+function useSelectedDriveSafe() {
+	const selectedDriveId = useSelectedDriveId();
+	const selectedDrive = useDrives()?.find((drive) => drive.header.id === selectedDriveId);
+	const [drive, dispatch] = useDispatch(selectedDrive);
+	if (!selectedDrive) return [void 0, void 0];
+	return [drive, dispatch];
+}
+function setSelectedDrive(driveOrDriveSlug) {
+	const driveSlug = typeof driveOrDriveSlug === "string" ? driveOrDriveSlug : driveOrDriveSlug?.header.slug;
+	const drives = window.ph?.drives;
+	const driveId = (typeof driveOrDriveSlug === "object" && driveOrDriveSlug !== null ? driveOrDriveSlug : drives?.find((d) => d.header.slug === driveSlug))?.header.id;
+	if (!driveId && driveSlug && extractDriveSlugFromPath(window.location.pathname) === driveSlug) {
+		if (window.ph?.selectedDriveId) setSelectedDriveId(void 0);
+		deferDriveSelection(driveSlug);
+		return;
+	}
+	cancelPendingDriveSelection();
+	setSelectedDriveId(driveId);
+	if (!driveId) {
+		const pathname = resolveUrlPathname("/");
+		if (pathname === window.location.pathname) return;
+		window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+		return;
+	}
+	const pathname = resolveUrlPathname(`/d/${driveSlug}`);
+	if (pathname === window.location.pathname) return;
+	window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+}
+const DEFERRED_DRIVE_TICK_MS = 2e3;
+const DEFERRED_DRIVE_MAX_WAIT_MS = 15e3;
+function isInitialSyncInFlight() {
+	const remotes = window.ph?.reactorClientModule?.reactorModule?.syncModule?.syncManager?.list();
+	if (!remotes?.length) return false;
+	return remotes.some((remote) => {
+		try {
+			const snapshot = remote.channel.getConnectionState();
+			return snapshot.receivingPages || !snapshot.lastSuccessUtcMs && snapshot.state !== "error";
+		} catch {
+			return false;
+		}
+	});
+}
+let pendingHandler;
+let pendingTimeout;
+function cancelPendingDriveSelection() {
+	if (pendingHandler) {
+		window.removeEventListener("ph:drivesUpdated", pendingHandler);
+		pendingHandler = void 0;
+	}
+	if (pendingTimeout) {
+		clearTimeout(pendingTimeout);
+		pendingTimeout = void 0;
+	}
+}
+function deferDriveSelection(driveSlug) {
+	cancelPendingDriveSelection();
+	const nodeSlug = extractNodeSlugFromPath(window.location.pathname);
+	const handler = () => {
+		if (!window.ph?.drives?.find((d) => d.header.slug === driveSlug)) return;
+		cancelPendingDriveSelection();
+		setSelectedDrive(driveSlug);
+		setSelectedNode(nodeSlug);
+	};
+	pendingHandler = handler;
+	window.addEventListener("ph:drivesUpdated", handler);
+	const deadline = Date.now() + DEFERRED_DRIVE_MAX_WAIT_MS;
+	const scheduleTick = () => {
+		pendingTimeout = setTimeout(() => {
+			if (Date.now() < deadline && isInitialSyncInFlight()) {
+				scheduleTick();
+				return;
+			}
+			cancelPendingDriveSelection();
+			const pathname = resolveUrlPathname("/");
+			if (pathname === window.location.pathname) return;
+			window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+		}, DEFERRED_DRIVE_TICK_MS);
+	};
+	scheduleTick();
+}
+function useDropTarget() {
+	const [isDropTarget, setIsDropTarget] = useState(false);
+	const isDragAndDropEnabled = useIsDragAndDropEnabled();
+	const targetSetter = n$1(() => setIsDropTarget(true), {
+		triggerAt: "start",
+		minQuietPeriodMs: 100
+	});
+	const targetUnsetter = n$1(() => setIsDropTarget(false), {
+		triggerAt: "start",
+		minQuietPeriodMs: 100
+	});
+	function setTarget() {
+		if (!isDragAndDropEnabled) return;
+		targetUnsetter.cancel();
+		targetSetter.call();
+	}
+	function unsetTarget() {
+		if (!isDragAndDropEnabled) return;
+		targetSetter.cancel();
+		targetUnsetter.call();
+	}
+	return {
+		isDropTarget,
+		setTarget,
+		unsetTarget
+	};
+}
+const draggingNodeEventFunctions = makePHEventFunctions("draggingNode");
+const useDraggingNode = draggingNodeEventFunctions.useValue;
+const setDraggingNode = draggingNodeEventFunctions.setValue;
+draggingNodeEventFunctions.addEventHandler;
+const draggingNodeSetter = n$1((node) => setDraggingNode(node), {
+	reducer: (_, newNode) => newNode,
+	triggerAt: "start",
+	minQuietPeriodMs: 100
+});
+const draggingNodeUnsetter = n$1(() => setDraggingNode(void 0), {
+	triggerAt: "start",
+	minQuietPeriodMs: 100
+});
+function setDragging(node) {
+	draggingNodeUnsetter.cancel();
+	draggingNodeSetter.call(node);
+}
+function unsetDragging() {
+	draggingNodeSetter.cancel();
+	draggingNodeUnsetter.call();
+}
+const isNodeDrag = (params) => t$3(params, [({ srcId }) => e$3(e$1)(srcId), e$6(false)], [({ driveId }) => e$3(e$1)(driveId), e$6(false)], [({ driveId, srcId }) => t(driveId, srcId), e$6(false)], e$6(true));
+function useDragNode(args) {
+	const { srcId, parentId } = args;
+	const driveId = useSelectedDriveId();
+	const draggingNodeId = useDraggingNode()?.srcId;
+	const params = {
+		driveId,
+		srcId,
+		parentId
+	};
+	const draggable = isNodeDrag(params);
+	const isDragging = t$4({
+		srcId,
+		draggingNodeId
+	}, [
+		() => draggable,
+		({ srcId }) => e$2(srcId),
+		({ draggingNodeId }) => e$2(draggingNodeId),
+		({ srcId, draggingNodeId }) => t(srcId, draggingNodeId)
+	]);
+	const onDragStart = () => {
+		if (!draggable) return;
+		setDragging(params);
+	};
+	const onDragEnd = () => {
+		if (!draggable) return;
+		unsetDragging();
+	};
+	return {
+		isDragging,
+		draggable,
+		onDragStart,
+		onDragEnd
+	};
+}
+const isNodeDrop = (params) => t$3(params, [({ srcId }) => e$3(e$1)(srcId), e$6(false)], [({ driveId }) => e$3(e$4)(driveId), e$6(false)], [({ srcId, targetId }) => t(srcId, targetId), e$6(false)], [({ driveId, parentId, targetId }) => e$3(e$1)(parentId) && t(targetId, driveId), e$6(false)], [({ targetId, parentId }) => t(targetId, parentId), e$6(false)], e$6(true));
+function useDropNode(targetId) {
+	const driveId = useSelectedDriveId();
+	const { srcId, parentId } = useDraggingNode() ?? {};
+	const { isDropTarget, setTarget, unsetTarget } = useDropTarget();
+	const params = {
+		driveId,
+		parentId,
+		targetId,
+		srcId
+	};
+	function handleNodeDrop(event, cb) {
+		if (!isNodeDrop(params)) return;
+		event.preventDefault();
+		event.stopPropagation();
+		cb?.();
+	}
+	const onDragEnter = (event) => handleNodeDrop(event);
+	const onDragOver = (event) => handleNodeDrop(event, e(setTarget));
+	const onDragLeave = (event) => handleNodeDrop(event, e(unsetTarget));
+	const onDrop = (event) => handleNodeDrop(event, e(() => {
+		unsetDragging();
+		unsetTarget();
+		moveNodeById(params).catch(console.error);
+	}));
+	return {
+		isDropTarget,
+		onDragEnter,
+		onDragOver,
+		onDragLeave,
+		onDrop
+	};
+}
+const graphQLReactorClientEventFunctions = makePHEventFunctions("reactorGraphQLClient");
+graphQLReactorClientEventFunctions.useValue;
+graphQLReactorClientEventFunctions.setValue;
+graphQLReactorClientEventFunctions.addEventHandler;
+const modalEventFunctions = makePHEventFunctions("modal");
+modalEventFunctions.useValue;
+/** Sets the current modal */
+const setPHModal = modalEventFunctions.setValue;
+modalEventFunctions.addEventHandler;
+/** Shows a modal */
+function showPHModal(modal) {
+	setPHModal(modal);
+}
+/** Shows the create document modal */
+function showCreateDocumentModal(documentType) {
+	setPHModal({
+		type: "createDocument",
+		documentType
+	});
+}
+/** Shows the delete node modal */
+function showDeleteNodeModal(nodeOrId) {
+	setPHModal({
+		type: "deleteItem",
+		id: typeof nodeOrId === "string" ? nodeOrId : nodeOrId.id
+	});
+}
+const packageDiscoveryFunctions = makePHEventFunctions("packageDiscoveryService");
+packageDiscoveryFunctions.useValue;
+packageDiscoveryFunctions.setValue;
+packageDiscoveryFunctions.addEventHandler;
+const reactorClientModuleEventFunctions = makePHEventFunctions("reactorClientModule");
+const reactorClientEventFunctions = makePHEventFunctions("reactorClient");
+/** Returns the reactor client module */
+const useReactorClientModule = reactorClientModuleEventFunctions.useValue;
+reactorClientModuleEventFunctions.setValue;
+reactorClientModuleEventFunctions.addEventHandler;
+reactorClientEventFunctions.useValue;
+reactorClientEventFunctions.setValue;
+reactorClientEventFunctions.addEventHandler;
+const useSync = () => useReactorClientModule()?.reactorModule?.syncModule?.syncManager;
+const useSyncList = () => {
+	return useSync()?.list() ?? [];
+};
+const revisionHistoryEventFunctions = makePHEventFunctions("revisionHistoryVisible");
+revisionHistoryEventFunctions.useValue;
+/** Sets revision history visibility */
+const setRevisionHistoryVisible = revisionHistoryEventFunctions.setValue;
+revisionHistoryEventFunctions.addEventHandler;
+/** Shows the revision history */
+function showRevisionHistory() {
+	setRevisionHistoryVisible(true);
+}
+/** Sorts nodes by name. */
+function sortNodesByName(nodes) {
+	return nodes.toSorted((a, b) => a.name.localeCompare(b.name));
+}
+/** Returns whether a node is a file. */
+function isFileNodeKind(node) {
+	if (!node) return false;
+	return node.kind.toUpperCase() === "FILE";
+}
+/** Returns whether a node is a folder. */
+function isFolderNodeKind(node) {
+	if (!node) return false;
+	return node.kind.toUpperCase() === "FOLDER";
+}
+/** Returns the nodes in the selected drive. */
+function useNodesInSelectedDrive() {
+	const [selectedDrive] = useSelectedDriveSafe();
+	return selectedDrive?.state.global.nodes;
+}
+/** Returns the folder nodes in the selected drive. */
+function useFolderNodesInSelectedDrive() {
+	return useNodesInSelectedDrive()?.filter((n) => isFolderNodeKind(n));
+}
+/** Returns the selected node. */
+function useSelectedNode() {
+	const selectedNodeId = useSelectedNodeId();
+	return useNodesInSelectedDrive()?.find((n) => n.id === selectedNodeId);
+}
+const selectedTimelineItemEventFunctions = makePHEventFunctions("selectedTimelineItem");
+selectedTimelineItemEventFunctions.useValue;
+selectedTimelineItemEventFunctions.setValue;
+selectedTimelineItemEventFunctions.addEventHandler;
+const selectedTimelineRevisionEventFunctions = makePHEventFunctions("selectedTimelineRevision");
+selectedTimelineRevisionEventFunctions.useValue;
+selectedTimelineRevisionEventFunctions.setValue;
+selectedTimelineRevisionEventFunctions.addEventHandler;
+const toastEventFunctions = makePHEventFunctions("toast");
+/** Returns the toast function */
+const usePHToast = toastEventFunctions.useValue;
+toastEventFunctions.setValue;
+toastEventFunctions.addEventHandler;
+const vetraPackageManagerFunctions = makePHEventFunctions("vetraPackageManager");
+const useVetraPackageManager = vetraPackageManagerFunctions.useValue;
+/** Returns all of the Vetra packages loaded by the Connect instance */
+const useVetraPackages = () => {
+	const packageManager = useVetraPackageManager();
+	return useSyncExternalStore((cb) => packageManager ? packageManager.subscribe(cb) : () => {}, () => packageManager?.packages ?? []);
+};
+vetraPackageManagerFunctions.addEventHandler;
+function useDocumentModelModules() {
+	return useVetraPackages().flatMap((pkg) => pkg.documentModels).filter((module, index, modules) => modules.findIndex((m) => m.documentModel.global.id === module.documentModel.global.id && m.version === module.version) === index);
+}
+function useDocumentModelModuleById(id) {
+	return useDocumentModelModules()?.find((module) => module.documentModel.global.id === id);
+}
+/** Returns the selected folder. */
+function useSelectedFolder() {
+	const selectedNode = useSelectedNode();
+	if (isFolderNodeKind(selectedNode)) return selectedNode;
+}
+/** Returns the child nodes for the selected drive or folder. */
+function useNodesInSelectedDriveOrFolder() {
+	const nodes = useNodesInSelectedDrive();
+	const selectedFolderId = useSelectedFolder()?.id;
+	if (!nodes) return [];
+	if (!selectedFolderId) return sortNodesByName(nodes.filter((n) => !n.parentFolder));
+	return sortNodesByName(nodes.filter((n) => n.parentFolder === selectedFolderId));
+}
+function callGlobalSetterForKey(key, value) {
+	const setter = phGlobalConfigSetters[key];
+	setter(value);
+}
+/** Sets the global drive config.
+*
+* Pass in a partial object of the global drive config to set.
+*/
+function setPHAppConfig(config) {
+	for (const key of Object.keys(config)) callGlobalSetterForKey(key, config[key]);
+}
+/** Sets the global document config.
+*
+* Pass in a partial object of the global document config to set.
+*/
+function setPHDocumentEditorConfig(config) {
+	for (const key of Object.keys(config)) callGlobalSetterForKey(key, config[key]);
+}
+/** Wrapper hook for setting the global app config.
+*
+* Automatically sets the global app config when the component mounts.
+*
+* Pass in a partial object of the global app config to set.
+*/
+function useSetPHAppConfig(config) {
+	const [isInitialized, setIsInitialized] = useState(false);
+	useEffect(() => {
+		if (isInitialized) return;
+		setPHAppConfig(config);
+		setIsInitialized(true);
+	}, [config, isInitialized]);
+}
+/** Wrapper hook for setting the global document editor config.
+*
+* Automatically sets the global document editor config when the component mounts.
+*
+* Pass in a partial object of the global document editor config to set.
+*/
+function useSetPHDocumentEditorConfig(config) {
+	const [isInitialized, setIsInitialized] = useState(false);
+	useEffect(() => {
+		if (isInitialized) return;
+		setPHDocumentEditorConfig(config);
+		setIsInitialized(true);
+	}, [config, isInitialized]);
+}
+/** Returns a document of a specific type, throws an error if the found document has a different type */
+function useDocumentOfType(documentId, documentType) {
+	const [document, dispatch] = useDocumentById(documentId);
+	const documentModelModule = useDocumentModelModuleById(documentType);
+	if (!documentId || !documentType) return [];
+	if (!document) throw new Error(`Document not found: ${documentId}`);
+	if (!documentModelModule) throw new ModuleNotFoundError(documentType);
+	if (document.header.documentType !== documentType) throw new DocumentTypeMismatchError(documentId, documentType, document.header.documentType);
+	return [document, dispatch];
+}
+const validateDocument = (document) => {
+	const errors = [];
+	if (document.header.documentType !== "powerhouse/document-model") return errors;
+	const doc = document;
+	const specs = doc.state.global.specifications[0];
+	const initialStateErrors = Object.keys(specs.state).reduce((acc, scopeKey) => {
+		const scope = scopeKey;
+		return [...acc, ...validateInitialState(specs.state[scope].initialValue, scope !== "global").map((err) => ({
+			...err,
+			message: `${err.message}. Scope: ${scope}`,
+			details: {
+				...err.details,
+				scope
+			}
+		}))];
+	}, []);
+	const schemaStateErrors = Object.keys(specs.state).reduce((acc, scopeKey) => {
+		const scope = scopeKey;
+		const isGlobalScope = scope === "global";
+		return [...acc, ...validateStateSchemaName(specs.state[scope].schema, doc.state.global?.name || doc.header.name || "", !isGlobalScope ? scope : "", !isGlobalScope).map((err) => ({
+			...err,
+			message: `${err.message}. Scope: ${scope}`,
+			details: {
+				...err.details,
+				scope
+			}
+		}))];
+	}, []);
+	const modulesErrors = validateModules(specs.modules);
+	return [
+		...initialStateErrors,
+		...schemaStateErrors,
+		...modulesErrors
+	];
+};
+function defaultHandleError(error) {
+	console.error(`Failed to export document: ${error.message}`);
+}
+function handleDocumentValidation(document) {
+	if (t$2(validateDocument(document), 1)) return false;
+	return true;
+}
+function downloadDocument(document, handleError = defaultHandleError) {
+	if (!document) return;
+	if (!handleDocumentValidation(document)) {
+		showPHModal({
+			type: "downloadDocumentWithErrors",
+			documentId: document.header.id
+		});
+		return;
+	}
+	exportFile(document).catch((error) => handleError(normalizeException(error)));
+}
+function useDownloadDocument(id) {
+	const [document] = useDocumentById(id);
+	const toast = usePHToast();
+	return () => downloadDocument(document, (error) => toast?.(`Failed to export document: ${error.message}`));
+}
+function useFolderById(id) {
+	return useFolderNodesInSelectedDrive()?.find((n) => n.id === id);
+}
+function resolveNode(driveId, node) {
+	return node?.id !== driveId ? node : void 0;
+}
+function useNodeActions() {
+	const [selectedDrive] = useSelectedDriveSafe();
+	const selectedFolder = useSelectedFolder();
+	const selectedParentFolder = useFolderById(useSelectedNode()?.parentFolder);
+	const selectedDriveId = selectedDrive?.header.id;
+	const drives = useDrives();
+	async function onAddFile(file, parent) {
+		if (!selectedDriveId) return;
+		return addFile(file, selectedDriveId, file.name.replace(/\..+/gim, ""), resolveNode(selectedDriveId, parent)?.id);
+	}
+	async function onAddFolder(name, parent) {
+		if (!selectedDriveId) return;
+		return addFolder(selectedDriveId, name, resolveNode(selectedDriveId, parent)?.id);
+	}
+	async function onRenameNode(newName, node) {
+		if (!selectedDriveId) return;
+		if (!resolveNode(selectedDriveId, node)) {
+			console.error(`Node ${node.id} not found`);
+			return;
+		}
+		return await renameNode(selectedDriveId, node.id, newName);
+	}
+	async function onCopyNode(src, target) {
+		if (!selectedDriveId) return;
+		const resolvedSrc = resolveNode(selectedDriveId, src);
+		if (!resolvedSrc) {
+			console.error(`Node ${src.id} not found`);
+			return;
+		}
+		await copyNode$1(selectedDriveId, resolvedSrc, resolveNode(selectedDriveId, target));
+	}
+	async function onMoveNode(src, target) {
+		if (!selectedDriveId) return;
+		const resolvedSrc = resolveNode(selectedDriveId, src);
+		if (!resolvedSrc) {
+			console.error(`Node ${src.id} not found`);
+			return;
+		}
+		const resolvedTarget = resolveNode(selectedDriveId, target);
+		if (!resolvedTarget?.id && !src.parentFolder || resolvedTarget?.id === src.parentFolder) return;
+		await moveNode$1(selectedDriveId, resolvedSrc, resolvedTarget);
+	}
+	async function onDuplicateNode(src) {
+		if (!selectedDriveId) return;
+		const resolvedSrc = resolveNode(selectedDriveId, src);
+		if (!resolvedSrc) {
+			console.error(`Node ${src.id} not found`);
+			return;
+		}
+		await copyNode$1(selectedDriveId, resolvedSrc, resolveNode(selectedDriveId, selectedFolder ?? selectedParentFolder));
+	}
+	async function onAddAndSelectNewFolder(name) {
+		if (!name) return;
+		if (!selectedDriveId) return;
+		const resolvedTarget = resolveNode(selectedDriveId, selectedFolder ?? selectedParentFolder);
+		if (!resolvedTarget) return;
+		const newFolder = await onAddFolder(name, resolvedTarget);
+		if (newFolder) setSelectedNode(newFolder);
+	}
+	async function onRenameDriveNodes(newName, nodeId) {
+		if (!drives) return;
+		const drivesWithNode = drives.filter((drive) => drive.state.global.nodes.some((n) => n.id === nodeId));
+		await Promise.all(drivesWithNode.map((drive) => renameDriveNode(drive.header.id, nodeId, newName)));
+	}
+	return {
+		onAddFile,
+		onAddFolder,
+		onRenameNode,
+		onCopyNode,
+		onMoveNode,
+		onDuplicateNode,
+		onAddAndSelectNewFolder,
+		onRenameDriveNodes
+	};
+}
+/** Returns a node in the selected drive by id. */
+function useNodeById(id) {
+	return useNodesInSelectedDrive()?.find((n) => n.id === id);
+}
+/** Returns the path to a node in the selected drive */
+function useNodePathById(id) {
+	const nodes = useNodesInSelectedDrive();
+	if (!nodes) return [];
+	const path = [];
+	let current = nodes.find((n) => n.id === id);
+	while (current) {
+		path.push(current);
+		if (!current.parentFolder) break;
+		current = nodes.find((n) => n.id === current?.parentFolder);
+	}
+	return path.reverse();
+}
+/** Returns the path to the currently selected node in the selected drive. */
+function useSelectedNodePath() {
+	return useNodePathById(useSelectedNode()?.id);
+}
+function useNodeParentFolderById(id) {
+	return useFolderById(useNodeById(id)?.parentFolder);
+}
+/** Returns the selected document id */
+function useSelectedDocumentId() {
+	const selectedNode = useSelectedNode();
+	return selectedNode && isFileNode(selectedNode) ? selectedNode.id : void 0;
+}
+/** Returns the selected document. */
+function useSelectedDocumentSafe() {
+	return useDocumentById(useSelectedDocumentId());
+}
+function useSelectedDocumentOfType(documentType) {
+	const documentId = useSelectedDocumentId();
+	if (!documentType) return [];
+	if (!documentId) throw new NoSelectedDocumentError();
+	return useDocumentOfType(documentId, documentType);
+}
+const STORED_THEME_KEY = "ph:theme";
+const UPDATE_STORED_THEME = "ph:updateStoredTheme";
+const STORED_THEME_UPDATED = "ph:storedThemeUpdated";
+const SYSTEM_THEME_UPDATED = "ph:systemThemeUpdated";
+const isServer = typeof window === "undefined";
+function setTheme(storedTheme) {
+	if (isServer) return;
+	const updateStoredThemeEvent = new CustomEvent(UPDATE_STORED_THEME, { detail: { storedTheme } });
+	window.dispatchEvent(updateStoredThemeEvent);
+}
+function getStoredTheme() {
+	if (isServer) return void 0;
+	return localStorage.getItem(STORED_THEME_KEY) ?? void 0;
+}
+function getPrefersDarkMediaQuery() {
+	if (isServer) return;
+	return window.matchMedia("(prefers-color-scheme: dark)");
+}
+function getPrefersDark() {
+	if (isServer) return false;
+	if (getPrefersDarkMediaQuery()?.matches) return true;
+	return false;
+}
+function getSystemTheme() {
+	if (isServer) return "light";
+	if (getPrefersDark()) return "dark";
+	return "light";
+}
+function toggleDark(isDark) {
+	if (isServer) return;
+	document.documentElement.classList.toggle("dark", isDark);
+}
+function subscribeToStoredTheme(onStoreChange) {
+	if (isServer) return () => {};
+	window.addEventListener(STORED_THEME_UPDATED, onStoreChange);
+	return () => {
+		window.removeEventListener(STORED_THEME_UPDATED, onStoreChange);
+	};
+}
+function subscribeToSystemTheme(onStoreChange) {
+	if (isServer) return () => {};
+	window.addEventListener(SYSTEM_THEME_UPDATED, onStoreChange);
+	return () => {
+		window.removeEventListener(SYSTEM_THEME_UPDATED, onStoreChange);
+	};
+}
+function useTheme() {
+	const storedTheme = useSyncExternalStore(subscribeToStoredTheme, () => getStoredTheme(), () => "system");
+	const systemTheme = useSyncExternalStore(subscribeToSystemTheme, () => getSystemTheme(), () => "light");
+	const isSystem = storedTheme === void 0 || storedTheme === "system";
+	const theme = isSystem ? systemTheme : storedTheme;
+	const isDark = theme === "dark";
+	useEffect(() => {
+		toggleDark(isDark);
+	}, [isDark]);
+	return {
+		theme,
+		isSystem,
+		setTheme
+	};
+}
+const syncStatusToUI = {
+	[SyncStatus.Synced]: "SUCCESS",
+	[SyncStatus.Outgoing]: "SYNCING",
+	[SyncStatus.Incoming]: "SYNCING",
+	[SyncStatus.OutgoingAndIncoming]: "SYNCING",
+	[SyncStatus.Error]: "ERROR"
+};
+async function getDrives(reactor) {
+	return (await reactor.find({ type: "powerhouse/document-drive" })).results;
+}
+function getSyncStatusSync(documentId, sharingType) {
+	if (sharingType === "LOCAL") return;
+	const syncManager = window.ph?.reactorClientModule?.reactorModule?.syncModule?.syncManager;
+	if (!syncManager) return;
+	const status = syncManager.getSyncStatus(documentId);
+	if (status === void 0) return;
+	return syncStatusToUI[status];
+}
+function getDocumentGraphqlQuery() {
+	const loc = GetDocumentWithOperationsDocument.loc;
+	if (!loc) throw new Error("GetDocumentWithOperationsDocument is misconfigured, loc is missing.");
+	return loc.source.body;
+}
+function buildDocumentSubgraphQuery(identifier, authToken) {
+	const query = getDocumentGraphqlQuery();
+	const variables = { identifier };
+	const headers = authToken ? { Authorization: `Bearer ${authToken}` } : void 0;
+	const payload = {
+		document: query.trim(),
+		variables: JSON.stringify(variables, null, 2)
+	};
+	if (headers) payload.headers = JSON.stringify(headers);
+	return import_lz_string.compressToEncodedURIComponent(JSON.stringify(payload));
+}
+function buildDocumentSubgraphUrl(driveUrl, identifier, authToken) {
+	return `${driveUrl}?explorerURLState=${buildDocumentSubgraphQuery(identifier, authToken)}`;
+}
+/**
+* Hook that returns a function to generate a document's switchboard URL.
+* Only returns a function for documents in remote drives.
+* Returns null for local drives or when the document/drive cannot be determined.
+*
+* The returned function generates a fresh bearer token and builds the switchboard URL
+* with authentication when called.
+*
+* @param document - The document to create a switchboard URL generator for
+* @returns An async function that returns the switchboard URL, or null if not applicable
+*/
+function useGetSwitchboardLink(document) {
+	const [drive] = useSelectedDriveSafe();
+	const remotes = useSyncList();
+	const isRemoteDrive = useMemo(() => {
+		if (!e$4(drive)) return false;
+		return remotes.some((remote) => remote.collectionId === driveCollectionId("main", drive.header.id));
+	}, [remotes, drive]);
+	const remoteUrl = useMemo(() => {
+		if (!e$4(drive)) return null;
+		try {
+			const channelUrl = (remotes.find((remote) => remote.collectionId === driveCollectionId("main", drive.header.id))?.channel)?.config.url;
+			if (typeof channelUrl === "string") return channelUrl;
+			return null;
+		} catch (error) {
+			console.error("Error determining remote URL:", error);
+			return null;
+		}
+	}, [remotes, drive]);
+	const renown = useRenown();
+	const user = useUser();
+	return useMemo(() => {
+		if (!isRemoteDrive || !document?.header.id || !remoteUrl) return null;
+		return async () => {
+			const token = user?.address ? await renown?.getBearerToken({
+				expiresIn: 600,
+				aud: remoteUrl
+			}) : void 0;
+			return buildDocumentSubgraphUrl(remoteUrl, document.header.id, token);
+		};
+	}, [
+		isRemoteDrive,
+		remoteUrl,
+		document,
+		user,
+		renown
+	]);
+}
+function useUserPermissions() {
+	const user = useUser();
+	const allowList = useAllowList();
+	if (!allowList) return {
+		isAllowedToCreateDocuments: true,
+		isAllowedToEditDocuments: true
+	};
+	return {
+		isAllowedToCreateDocuments: allowList.includes(user?.address ?? ""),
+		isAllowedToEditDocuments: allowList.includes(user?.address ?? "")
+	};
+}
+const DEFAULT_DEBOUNCE_DELAY_MS = 200;
+const DEFAULT_IMMEDIATE_THRESHOLD_MS = 1e3;
+async function _refreshReactorData(reactor) {
+	setDrives(await getDrives(reactor));
+}
+async function _refreshReactorDataClient(reactor) {
+	if (!reactor) return;
+	setDrives((await reactor.find({ type: "powerhouse/document-drive" })).results);
+}
+function createDebouncedRefreshReactorData(debounceDelayMs = DEFAULT_DEBOUNCE_DELAY_MS, immediateThresholdMs = DEFAULT_IMMEDIATE_THRESHOLD_MS) {
+	let timeout = null;
+	let lastRefreshTime = 0;
+	return (reactor, immediate = false) => {
+		const now = Date.now();
+		const timeSinceLastRefresh = now - lastRefreshTime;
+		if (timeout !== null) clearTimeout(timeout);
+		if (immediate || timeSinceLastRefresh >= immediateThresholdMs) {
+			lastRefreshTime = now;
+			return _refreshReactorData(reactor);
+		}
+		return new Promise((resolve) => {
+			timeout = setTimeout(() => {
+				lastRefreshTime = Date.now();
+				_refreshReactorData(reactor).then(resolve);
+			}, debounceDelayMs);
+		});
+	};
+}
+function createDebouncedRefreshReactorDataClient(debounceDelayMs = DEFAULT_DEBOUNCE_DELAY_MS, immediateThresholdMs = DEFAULT_IMMEDIATE_THRESHOLD_MS) {
+	let timeout = null;
+	let lastRefreshTime = 0;
+	return (reactor, immediate = false) => {
+		const now = Date.now();
+		const timeSinceLastRefresh = now - lastRefreshTime;
+		if (timeout !== null) clearTimeout(timeout);
+		if (immediate || timeSinceLastRefresh >= immediateThresholdMs) {
+			lastRefreshTime = now;
+			return _refreshReactorDataClient(reactor);
+		}
+		return new Promise((resolve) => {
+			timeout = setTimeout(() => {
+				lastRefreshTime = Date.now();
+				_refreshReactorDataClient(reactor).then(resolve);
+			}, debounceDelayMs);
+		});
+	};
+}
+createDebouncedRefreshReactorData();
+createDebouncedRefreshReactorDataClient();
+//#endregion
+export { e$4 as A, useSelectedDriveSafe as C, useTheme as D, useSetPHDocumentEditorConfig as E, t$5 as M, useDocumentById as N, useUserPermissions as O, useSelectedDriveId as S, useSetPHAppConfig as T, useNodeParentFolderById as _, setSelectedDrive as a, useSelectedDocumentOfType as b, showDeleteNodeModal as c, useDownloadDocument as d, useDragNode as f, useNodeById as g, useNodeActions as h, isFolderNodeKind as i, t$2 as j, e$1 as k, showRevisionHistory as l, useGetSwitchboardLink as m, getSyncStatusSync as n, setSelectedNode as o, useDropNode as p, isFileNodeKind as r, showCreateDocumentModal as s, addFolder as t, useDocumentModelModules as u, useNodesInSelectedDriveOrFolder as v, useSelectedNodePath as w, useSelectedDocumentSafe as x, usePHToast as y };
+
+//# sourceMappingURL=dist-C1nRM9t2.js.map