@powerhousedao/reactor-browser 6.0.0-dev.7 → 6.0.0-dev.78

package/dist/src/connect.js

@@ -1,2 +1,2516 @@
-export * from "./hooks/connect.js";
-//# sourceMappingURL=connect.js.map
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/renown/utils.ts
+import { logger } from "document-drive";
+
+// src/renown/constants.ts
+var RENOWN_URL = "https://www.renown.id";
+var RENOWN_NETWORK_ID = "eip155";
+var RENOWN_CHAIN_ID = "1";
+var DOMAIN_TYPE = [
+  { name: "name", type: "string" },
+  { name: "version", type: "string" },
+  { name: "chainId", type: "uint256" },
+  { name: "verifyingContract", type: "address" }
+];
+var VERIFIABLE_CREDENTIAL_EIP712_TYPE = [
+  { name: "@context", type: "string[]" },
+  { name: "type", type: "string[]" },
+  { name: "id", type: "string" },
+  { name: "issuer", type: "Issuer" },
+  { name: "credentialSubject", type: "CredentialSubject" },
+  { name: "credentialSchema", type: "CredentialSchema" },
+  { name: "issuanceDate", type: "string" },
+  { name: "expirationDate", type: "string" }
+];
+var CREDENTIAL_SCHEMA_EIP712_TYPE = [
+  { name: "id", type: "string" },
+  { name: "type", type: "string" }
+];
+var CREDENTIAL_SUBJECT_TYPE = [
+  { name: "app", type: "string" },
+  { name: "id", type: "string" },
+  { name: "name", type: "string" }
+];
+var ISSUER_TYPE = [
+  { name: "id", type: "string" },
+  { name: "ethereumAddress", type: "string" }
+];
+var CREDENTIAL_TYPES = {
+  EIP712Domain: DOMAIN_TYPE,
+  VerifiableCredential: VERIFIABLE_CREDENTIAL_EIP712_TYPE,
+  CredentialSchema: CREDENTIAL_SCHEMA_EIP712_TYPE,
+  CredentialSubject: CREDENTIAL_SUBJECT_TYPE,
+  Issuer: ISSUER_TYPE
+};
+
+// src/renown/utils.ts
+function openRenown(documentId) {
+  if (documentId) {
+    window.open(`${RENOWN_URL}/profile/${documentId}`, "_blank")?.focus();
+    return;
+  }
+  const url = new URL(RENOWN_URL);
+  url.searchParams.set("connect", window.ph?.renown?.did ?? "");
+  url.searchParams.set("network", RENOWN_NETWORK_ID);
+  url.searchParams.set("chain", RENOWN_CHAIN_ID);
+  const returnUrl = new URL(window.location.pathname, window.location.origin);
+  url.searchParams.set("returnUrl", returnUrl.toJSON());
+  window.open(url, "_self")?.focus();
+}
+function consumeDidFromUrl() {
+  if (typeof window === "undefined")
+    return;
+  const urlParams = new URLSearchParams(window.location.search);
+  const userParam = urlParams.get("user");
+  if (!userParam)
+    return;
+  const userDid = decodeURIComponent(userParam);
+  const cleanUrl = new URL(window.location.href);
+  cleanUrl.searchParams.delete("user");
+  window.history.replaceState({}, "", cleanUrl.toString());
+  return userDid;
+}
+async function login(userDid, renown) {
+  if (!renown) {
+    return;
+  }
+  const did = userDid ?? consumeDidFromUrl();
+  try {
+    const user = renown.user;
+    if (user?.did && (user.did === did || !did)) {
+      return user;
+    }
+    if (!did) {
+      return;
+    }
+    return await renown.login(did);
+  } catch (error) {
+    logger.error("@error", error);
+  }
+}
+async function logout() {
+  const renown = window.ph?.renown;
+  await renown?.logout();
+  const url = new URL(window.location.href);
+  if (url.searchParams.has("user")) {
+    url.searchParams.delete("user");
+    window.history.replaceState(null, "", url.toString());
+  }
+}
+// ../../node_modules/.pnpm/change-case@5.4.4/node_modules/change-case/dist/index.js
+var SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+var SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+var SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+var SPLIT_REPLACE_VALUE = "$1\x00$2";
+var DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\x00");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\x00")
+    start++;
+  if (start === end)
+    return [];
+  while (result.charAt(end - 1) === "\x00")
+    end--;
+  return result.slice(start, end).split(/\0/g);
+}
+function splitSeparateNumbers(value) {
+  const words = split(value);
+  for (let i = 0;i < words.length; i++) {
+    const word = words[i];
+    const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+    if (match) {
+      const offset = match.index + (match[1] ?? match[2]).length;
+      words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+    }
+  }
+  return words;
+}
+function capitalCase(input, options) {
+  const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+  const lower = lowerFactory(options?.locale);
+  const upper = upperFactory(options?.locale);
+  return prefix + words.map(capitalCaseTransformFactory(lower, upper)).join(options?.delimiter ?? " ") + suffix;
+}
+function lowerFactory(locale) {
+  return locale === false ? (input) => input.toLowerCase() : (input) => input.toLocaleLowerCase(locale);
+}
+function upperFactory(locale) {
+  return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
+}
+function capitalCaseTransformFactory(lower, upper) {
+  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+}
+function splitPrefixSuffix(input, options = {}) {
+  const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+  const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+  let prefixIndex = 0;
+  let suffixIndex = input.length;
+  while (prefixIndex < input.length) {
+    const char = input.charAt(prefixIndex);
+    if (!prefixCharacters.includes(char))
+      break;
+    prefixIndex++;
+  }
+  while (suffixIndex > prefixIndex) {
+    const index = suffixIndex - 1;
+    const char = input.charAt(index);
+    if (!suffixCharacters.includes(char))
+      break;
+    suffixIndex = index;
+  }
+  return [
+    input.slice(0, prefixIndex),
+    splitFn(input.slice(prefixIndex, suffixIndex)),
+    input.slice(suffixIndex)
+  ];
+}
+
+// src/hooks/make-ph-event-functions.ts
+import { useSyncExternalStore } from "react";
+function makePHEventFunctions(key) {
+  const setEventName = `ph:set${capitalCase(key)}`;
+  const updateEventName = `ph:${key}Updated`;
+  function setValue(value) {
+    const event = new CustomEvent(setEventName, {
+      detail: { [key]: value }
+    });
+    window.dispatchEvent(event);
+  }
+  function dispatchUpdatedEvent() {
+    const event = new CustomEvent(updateEventName);
+    window.dispatchEvent(event);
+  }
+  function handleSetValueEvent(event) {
+    const value = event.detail[key];
+    if (!window.ph)
+      throw new Error("ph global store is not defined");
+    window.ph[key] = value;
+    dispatchUpdatedEvent();
+  }
+  function addEventHandler() {
+    window.addEventListener(setEventName, handleSetValueEvent);
+  }
+  function subscribeToValue(onStoreChange) {
+    window.addEventListener(updateEventName, onStoreChange);
+    return () => {
+      window.removeEventListener(updateEventName, onStoreChange);
+    };
+  }
+  function getSnapshot() {
+    if (!window.ph)
+      throw new Error("ph global store is not defined");
+    return window.ph[key];
+  }
+  function useValue() {
+    return useSyncExternalStore(subscribeToValue, getSnapshot);
+  }
+  return {
+    useValue,
+    setValue,
+    addEventHandler
+  };
+}
+
+// src/hooks/config/editor.ts
+var isExternalControlsEnabledEventFunctions = makePHEventFunctions("isExternalControlsEnabled");
+var setIsExternalControlsEnabled = isExternalControlsEnabledEventFunctions.setValue;
+var useIsExternalControlsEnabled = isExternalControlsEnabledEventFunctions.useValue;
+var addIsExternalControlsEnabledEventHandler = isExternalControlsEnabledEventFunctions.addEventHandler;
+var isDragAndDropEnabledEventFunctions = makePHEventFunctions("isDragAndDropEnabled");
+var setIsDragAndDropEnabled = isDragAndDropEnabledEventFunctions.setValue;
+var useIsDragAndDropEnabled = isDragAndDropEnabledEventFunctions.useValue;
+var addIsDragAndDropEnabledEventHandler = isDragAndDropEnabledEventFunctions.addEventHandler;
+var allowedDocumentTypesEventFunctions = makePHEventFunctions("allowedDocumentTypes");
+var setAllowedDocumentTypes = allowedDocumentTypesEventFunctions.setValue;
+function useAllowedDocumentTypes() {
+  const definedAllowedDocumentTypes = allowedDocumentTypesEventFunctions.useValue();
+  return definedAllowedDocumentTypes;
+}
+var addAllowedDocumentTypesEventHandler = allowedDocumentTypesEventFunctions.addEventHandler;
+var phDriveEditorConfigSetters = {
+  allowedDocumentTypes: setAllowedDocumentTypes,
+  isDragAndDropEnabled: setIsDragAndDropEnabled
+};
+var phDocumentEditorConfigSetters = {
+  isExternalControlsEnabled: setIsExternalControlsEnabled
+};
+var phDriveEditorConfigHooks = {
+  allowedDocumentTypes: useAllowedDocumentTypes,
+  isDragAndDropEnabled: useIsDragAndDropEnabled
+};
+var phDocumentEditorConfigHooks = {
+  isExternalControlsEnabled: useIsExternalControlsEnabled
+};
+
+// src/hooks/config/connect.ts
+var {
+  useValue: useRouterBasename,
+  setValue: setRouterBasename,
+  addEventHandler: addRouterBasenameEventHandler
+} = makePHEventFunctions("routerBasename");
+var {
+  useValue: useVersion,
+  setValue: setVersion,
+  addEventHandler: addVersionEventHandler
+} = makePHEventFunctions("version");
+var {
+  useValue: useRequiresHardRefresh,
+  setValue: setRequiresHardRefresh,
+  addEventHandler: addRequiresHardRefreshEventHandler
+} = makePHEventFunctions("requiresHardRefresh");
+var {
+  useValue: useWarnOutdatedApp,
+  setValue: setWarnOutdatedApp,
+  addEventHandler: addWarnOutdatedAppEventHandler
+} = makePHEventFunctions("warnOutdatedApp");
+var {
+  useValue: useStudioMode,
+  setValue: setStudioMode,
+  addEventHandler: addStudioModeEventHandler
+} = makePHEventFunctions("studioMode");
+var {
+  useValue: useBasePath,
+  setValue: setBasePath,
+  addEventHandler: addBasePathEventHandler
+} = makePHEventFunctions("basePath");
+var {
+  useValue: useVersionCheckInterval,
+  setValue: setVersionCheckInterval,
+  addEventHandler: addVersionCheckIntervalEventHandler
+} = makePHEventFunctions("versionCheckInterval");
+var {
+  useValue: useCliVersion,
+  setValue: setCliVersion,
+  addEventHandler: addCliVersionEventHandler
+} = makePHEventFunctions("cliVersion");
+var {
+  useValue: useFileUploadOperationsChunkSize,
+  setValue: setFileUploadOperationsChunkSize,
+  addEventHandler: addFileUploadOperationsChunkSizeEventHandler
+} = makePHEventFunctions("fileUploadOperationsChunkSize");
+var {
+  useValue: useIsDocumentModelSelectionSettingsEnabled,
+  setValue: setIsDocumentModelSelectionSettingsEnabled,
+  addEventHandler: addIsDocumentModelSelectionSettingsEnabledEventHandler
+} = makePHEventFunctions("isDocumentModelSelectionSettingsEnabled");
+var {
+  useValue: useGaTrackingId,
+  setValue: setGaTrackingId,
+  addEventHandler: addGaTrackingIdEventHandler
+} = makePHEventFunctions("gaTrackingId");
+var {
+  useValue: useDefaultDrivesUrl,
+  setValue: setDefaultDrivesUrl,
+  addEventHandler: addDefaultDrivesUrlEventHandler
+} = makePHEventFunctions("defaultDrivesUrl");
+var {
+  useValue: useDrivesPreserveStrategy,
+  setValue: setDrivesPreserveStrategy,
+  addEventHandler: addDrivesPreserveStrategyEventHandler
+} = makePHEventFunctions("drivesPreserveStrategy");
+var {
+  useValue: useIsLocalDrivesEnabled,
+  setValue: setIsLocalDrivesEnabled,
+  addEventHandler: addIsLocalDrivesEnabledEventHandler
+} = makePHEventFunctions("isLocalDrivesEnabled");
+var {
+  useValue: useIsAddDriveEnabled,
+  setValue: setIsAddDriveEnabled,
+  addEventHandler: addIsAddDriveEnabledEventHandler
+} = makePHEventFunctions("isAddDriveEnabled");
+var {
+  useValue: useIsPublicDrivesEnabled,
+  setValue: setIsPublicDrivesEnabled,
+  addEventHandler: addIsPublicDrivesEnabledEventHandler
+} = makePHEventFunctions("isPublicDrivesEnabled");
+var {
+  useValue: useIsAddPublicDrivesEnabled,
+  setValue: setIsAddPublicDrivesEnabled,
+  addEventHandler: addIsAddPublicDrivesEnabledEventHandler
+} = makePHEventFunctions("isAddPublicDrivesEnabled");
+var {
+  useValue: useIsDeletePublicDrivesEnabled,
+  setValue: setIsDeletePublicDrivesEnabled,
+  addEventHandler: addIsDeletePublicDrivesEnabledEventHandler
+} = makePHEventFunctions("isDeletePublicDrivesEnabled");
+var {
+  useValue: useIsCloudDrivesEnabled,
+  setValue: setIsCloudDrivesEnabled,
+  addEventHandler: addIsCloudDrivesEnabledEventHandler
+} = makePHEventFunctions("isCloudDrivesEnabled");
+var {
+  useValue: useIsAddCloudDrivesEnabled,
+  setValue: setIsAddCloudDrivesEnabled,
+  addEventHandler: addIsAddCloudDrivesEnabledEventHandler
+} = makePHEventFunctions("isAddCloudDrivesEnabled");
+var {
+  useValue: useIsDeleteCloudDrivesEnabled,
+  setValue: setIsDeleteCloudDrivesEnabled,
+  addEventHandler: addIsDeleteCloudDrivesEnabledEventHandler
+} = makePHEventFunctions("isDeleteCloudDrivesEnabled");
+var {
+  useValue: useLocalDrivesEnabled,
+  setValue: setLocalDrivesEnabled,
+  addEventHandler: addLocalDrivesEnabledEventHandler
+} = makePHEventFunctions("isLocalDrivesEnabled");
+var {
+  useValue: useIsAddLocalDrivesEnabled,
+  setValue: setIsAddLocalDrivesEnabled,
+  addEventHandler: addIsAddLocalDrivesEnabledEventHandler
+} = makePHEventFunctions("isAddLocalDrivesEnabled");
+var {
+  useValue: useIsDeleteLocalDrivesEnabled,
+  setValue: setIsDeleteLocalDrivesEnabled,
+  addEventHandler: addIsDeleteLocalDrivesEnabledEventHandler
+} = makePHEventFunctions("isDeleteLocalDrivesEnabled");
+var {
+  useValue: useIsEditorDebugModeEnabled,
+  setValue: setIsEditorDebugModeEnabled,
+  addEventHandler: addIsEditorDebugModeEnabledEventHandler
+} = makePHEventFunctions("isEditorDebugModeEnabled");
+var {
+  useValue: useIsEditorReadModeEnabled,
+  setValue: setIsEditorReadModeEnabled,
+  addEventHandler: addIsEditorReadModeEnabledEventHandler
+} = makePHEventFunctions("isEditorReadModeEnabled");
+var {
+  useValue: useIsAnalyticsDatabaseWorkerEnabled,
+  setValue: setIsAnalyticsDatabaseWorkerEnabled,
+  addEventHandler: addIsAnalyticsDatabaseWorkerEnabledEventHandler
+} = makePHEventFunctions("isAnalyticsDatabaseWorkerEnabled");
+var {
+  useValue: useIsDiffAnalyticsEnabled,
+  setValue: setIsDiffAnalyticsEnabled,
+  addEventHandler: addIsDiffAnalyticsEnabledEventHandler
+} = makePHEventFunctions("isDiffAnalyticsEnabled");
+var {
+  useValue: useIsDriveAnalyticsEnabled,
+  setValue: setIsDriveAnalyticsEnabled,
+  addEventHandler: addIsDriveAnalyticsEnabledEventHandler
+} = makePHEventFunctions("isDriveAnalyticsEnabled");
+var {
+  useValue: useRenownUrl,
+  setValue: setRenownUrl,
+  addEventHandler: addRenownUrlEventHandler
+} = makePHEventFunctions("renownUrl");
+var {
+  useValue: useRenownNetworkId,
+  setValue: setRenownNetworkId,
+  addEventHandler: addRenownNetworkIdEventHandler
+} = makePHEventFunctions("renownNetworkId");
+var {
+  useValue: useRenownChainId,
+  setValue: setRenownChainId,
+  addEventHandler: addRenownChainIdEventHandler
+} = makePHEventFunctions("renownChainId");
+var {
+  useValue: useSentryRelease,
+  setValue: setSentryRelease,
+  addEventHandler: addSentryReleaseEventHandler
+} = makePHEventFunctions("sentryRelease");
+var {
+  useValue: useSentryDsn,
+  setValue: setSentryDsn,
+  addEventHandler: addSentryDsnEventHandler
+} = makePHEventFunctions("sentryDsn");
+var {
+  useValue: useSentryEnv,
+  setValue: setSentryEnv,
+  addEventHandler: addSentryEnvEventHandler
+} = makePHEventFunctions("sentryEnv");
+var {
+  useValue: useIsSentryTracingEnabled,
+  setValue: setIsSentryTracingEnabled,
+  addEventHandler: addIsSentryTracingEnabledEventHandler
+} = makePHEventFunctions("isSentryTracingEnabled");
+var {
+  useValue: useIsExternalProcessorsEnabled,
+  setValue: setIsExternalProcessorsEnabled,
+  addEventHandler: addIsExternalProcessorsEnabledEventHandler
+} = makePHEventFunctions("isExternalProcessorsEnabled");
+var {
+  useValue: useIsExternalPackagesEnabled,
+  setValue: setIsExternalPackagesEnabled,
+  addEventHandler: addIsExternalPackagesEnabledEventHandler
+} = makePHEventFunctions("isExternalPackagesEnabled");
+var enabledEditorsEventFunctions = makePHEventFunctions("enabledEditors");
+var setEnabledEditors = enabledEditorsEventFunctions.setValue;
+var useEnabledEditors = enabledEditorsEventFunctions.useValue;
+var addEnabledEditorsEventHandler = enabledEditorsEventFunctions.addEventHandler;
+var disabledEditorsEventFunctions = makePHEventFunctions("disabledEditors");
+var setDisabledEditors = disabledEditorsEventFunctions.setValue;
+var useDisabledEditors = disabledEditorsEventFunctions.useValue;
+var addDisabledEditorsEventHandler = disabledEditorsEventFunctions.addEventHandler;
+var isRelationalProcessorsEnabled = makePHEventFunctions("isRelationalProcessorsEnabled");
+var setIsRelationalProcessorsEnabled = isRelationalProcessorsEnabled.setValue;
+var useIsRelationalProcessorsEnabled = isRelationalProcessorsEnabled.useValue;
+var addIsRelationalProcessorsEnabledEventHandler = isRelationalProcessorsEnabled.addEventHandler;
+var isExternalRelationalProcessorsEnabled = makePHEventFunctions("isExternalRelationalProcessorsEnabled");
+var setIsExternalRelationalProcessorsEnabled = isExternalRelationalProcessorsEnabled.setValue;
+var useIsExternalRelationalProcessorsEnabled = isExternalRelationalProcessorsEnabled.useValue;
+var addIsExternalRelationalProcessorsEnabledEventHandler = isExternalRelationalProcessorsEnabled.addEventHandler;
+var isAnalyticsEnabledEventFunctions = makePHEventFunctions("isAnalyticsEnabled");
+var setIsAnalyticsEnabled = isAnalyticsEnabledEventFunctions.setValue;
+var useIsAnalyticsEnabled = isAnalyticsEnabledEventFunctions.useValue;
+var addIsAnalyticsEnabledEventHandler = isAnalyticsEnabledEventFunctions.addEventHandler;
+var isAnalyticsExternalProcessorsEnabled = makePHEventFunctions("isAnalyticsExternalProcessorsEnabled");
+var setIsAnalyticsExternalProcessorsEnabled = isAnalyticsExternalProcessorsEnabled.setValue;
+var useIsAnalyticsExternalProcessorsEnabled = isAnalyticsExternalProcessorsEnabled.useValue;
+var addIsAnalyticsExternalProcessorsEnabledEventHandler = isAnalyticsExternalProcessorsEnabled.addEventHandler;
+var analyticsDatabaseNameEventFunctions = makePHEventFunctions("analyticsDatabaseName");
+var setAnalyticsDatabaseName = analyticsDatabaseNameEventFunctions.setValue;
+var useAnalyticsDatabaseName = analyticsDatabaseNameEventFunctions.useValue;
+var addAnalyticsDatabaseNameEventHandler = analyticsDatabaseNameEventFunctions.addEventHandler;
+var logLevelEventFunctions = makePHEventFunctions("logLevel");
+var setLogLevel = logLevelEventFunctions.setValue;
+var useLogLevel = logLevelEventFunctions.useValue;
+var addLogLevelEventHandler = logLevelEventFunctions.addEventHandler;
+var allowListEventFunctions = makePHEventFunctions("allowList");
+var setAllowList = allowListEventFunctions.setValue;
+var useAllowList = allowListEventFunctions.useValue;
+var addAllowListEventHandler = allowListEventFunctions.addEventHandler;
+var 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
+};
+var phGlobalConfigSetters = {
+  ...phDriveEditorConfigSetters,
+  ...phDocumentEditorConfigSetters,
+  ...nonUserConfigSetters
+};
+var 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
+};
+var phGlobalConfigHooks = {
+  ...phDriveEditorConfigHooks,
+  ...phDocumentEditorConfigHooks,
+  ...nonUserConfigHooks
+};
+
+// src/hooks/features.ts
+var featuresEventFunctions = makePHEventFunctions("features");
+var useFeatures = featuresEventFunctions.useValue;
+var setFeatures = featuresEventFunctions.setValue;
+var addFeaturesEventHandler = featuresEventFunctions.addEventHandler;
+
+// src/hooks/document-cache.ts
+import { use, useCallback, useSyncExternalStore as useSyncExternalStore2 } from "react";
+
+// src/document-cache.ts
+function addPromiseState(promise) {
+  if ("status" in promise) {
+    return promise;
+  }
+  const promiseWithState = promise;
+  promiseWithState.status = "pending";
+  promiseWithState.then((value) => {
+    promiseWithState.status = "fulfilled";
+    promiseWithState.value = value;
+  }, (reason) => {
+    promiseWithState.status = "rejected";
+    promiseWithState.reason = reason;
+    throw reason;
+  });
+  return promiseWithState;
+}
+function readPromiseState(promise) {
+  return "status" in promise ? promise : { status: "pending" };
+}
+
+class DocumentCache {
+  reactor;
+  documents = new Map;
+  batchPromises = new Map;
+  listeners = new Map;
+  constructor(reactor) {
+    this.reactor = reactor;
+    reactor.on("documentDeleted", (documentId) => {
+      const listeners = this.listeners.get(documentId);
+      this.documents.delete(documentId);
+      this.#invalidateBatchesContaining(documentId);
+      if (listeners) {
+        listeners.forEach((listener) => listener());
+      }
+      this.listeners.delete(documentId);
+    });
+    reactor.on("operationsAdded", (documentId) => {
+      if (this.documents.has(documentId)) {
+        this.#updateDocument(documentId).catch(console.warn);
+      }
+    });
+  }
+  #invalidateBatchesContaining(documentId) {
+    for (const key of this.batchPromises.keys()) {
+      if (key.split(",").includes(documentId)) {
+        this.batchPromises.delete(key);
+      }
+    }
+  }
+  async#updateDocument(documentId) {
+    const result = this.get(documentId, true);
+    await result;
+    const listeners = this.listeners.get(documentId);
+    if (listeners) {
+      listeners.forEach((listener) => listener());
+    }
+  }
+  get(id, refetch) {
+    const currentData = this.documents.get(id);
+    if (currentData) {
+      if (currentData.status === "pending") {
+        return currentData;
+      }
+      if (!refetch) {
+        return currentData;
+      }
+    }
+    const documentPromise = this.reactor.getDocument(id);
+    this.documents.set(id, addPromiseState(documentPromise));
+    return documentPromise;
+  }
+  getBatch(ids) {
+    const key = ids.join(",");
+    const cached = this.batchPromises.get(key);
+    const hasDeletedDocuments = ids.some((id) => !this.documents.has(id));
+    const currentPromises = ids.map((id) => this.get(id));
+    if (hasDeletedDocuments) {
+      const batchPromise2 = Promise.all(currentPromises);
+      this.batchPromises.set(key, {
+        promises: currentPromises,
+        promise: batchPromise2
+      });
+      return batchPromise2;
+    }
+    if (cached) {
+      const samePromises = currentPromises.every((p, i) => p === cached.promises[i]);
+      if (samePromises) {
+        return cached.promise;
+      }
+    }
+    const states = currentPromises.map((p) => readPromiseState(p));
+    const allFulfilled = states.every((s) => s.status === "fulfilled");
+    if (allFulfilled) {
+      const values = states.map((s) => s.value);
+      const batchPromise2 = Promise.resolve(values);
+      batchPromise2.status = "fulfilled";
+      batchPromise2.value = values;
+      this.batchPromises.set(key, {
+        promises: currentPromises,
+        promise: batchPromise2
+      });
+      return batchPromise2;
+    }
+    if (cached) {
+      return cached.promise;
+    }
+    const batchPromise = Promise.all(currentPromises);
+    this.batchPromises.set(key, {
+      promises: currentPromises,
+      promise: batchPromise
+    });
+    return batchPromise;
+  }
+  subscribe(id, callback) {
+    const ids = Array.isArray(id) ? id : [id];
+    for (const id2 of ids) {
+      const listeners = this.listeners.get(id2) ?? [];
+      this.listeners.set(id2, [...listeners, callback]);
+    }
+    return () => {
+      for (const id2 of ids) {
+        const listeners = this.listeners.get(id2) ?? [];
+        this.listeners.set(id2, listeners.filter((listener) => listener !== callback));
+      }
+    };
+  }
+}
+
+// src/hooks/document-cache.ts
+var documentEventFunctions = makePHEventFunctions("documentCache");
+var useDocumentCache = documentEventFunctions.useValue;
+var setDocumentCache = documentEventFunctions.setValue;
+var addDocumentCacheEventHandler = documentEventFunctions.addEventHandler;
+function getDocumentQueryState(promise) {
+  const state = readPromiseState(promise);
+  switch (state.status) {
+    case "pending":
+      return {
+        status: "pending",
+        isPending: true,
+        error: undefined,
+        data: undefined
+      };
+    case "fulfilled":
+      return {
+        status: "success",
+        isPending: false,
+        error: undefined,
+        data: state.value
+      };
+    case "rejected":
+      return {
+        status: "error",
+        isPending: false,
+        error: state.reason,
+        data: undefined
+      };
+  }
+}
+function useDocument(id) {
+  const documentCache = useDocumentCache();
+  const document = useSyncExternalStore2((cb) => id && documentCache ? documentCache.subscribe(id, cb) : () => {}, () => id ? documentCache?.get(id) : undefined);
+  return document ? use(document) : undefined;
+}
+function useDocuments(ids) {
+  const documentCache = useDocumentCache();
+  const documents = useSyncExternalStore2((cb) => ids?.length && documentCache ? documentCache.subscribe(ids, cb) : () => {}, () => ids?.length && documentCache ? documentCache.getBatch(ids) : undefined);
+  return documents ? use(documents) : [];
+}
+function useGetDocument() {
+  const documentCache = useDocumentCache();
+  return useCallback((id) => {
+    if (!documentCache) {
+      return Promise.reject(new Error("Document cache not initialized"));
+    }
+    return documentCache.get(id);
+  }, [documentCache]);
+}
+function useGetDocuments() {
+  const documentCache = useDocumentCache();
+  return useCallback((ids) => {
+    if (!documentCache) {
+      return Promise.reject(new Error("Document cache not initialized"));
+    }
+    return documentCache.getBatch(ids);
+  }, [documentCache]);
+}
+function useGetDocumentAsync(id) {
+  const documentCache = useDocumentCache();
+  if (!id || !documentCache) {
+    return {
+      status: "initial",
+      data: undefined,
+      isPending: false,
+      error: undefined,
+      reload: undefined
+    };
+  }
+  const promise = documentCache.get(id);
+  const state = getDocumentQueryState(promise);
+  return { ...state, reload: () => documentCache.get(id, true) };
+}
+
+// src/hooks/drives.ts
+var drivesEventFunctions = makePHEventFunctions("drives");
+var useDrives = drivesEventFunctions.useValue;
+var setDrives = drivesEventFunctions.setValue;
+var addDrivesEventHandler = drivesEventFunctions.addEventHandler;
+
+// src/hooks/loading.ts
+var {
+  useValue: useLoading,
+  setValue: setLoading,
+  addEventHandler: addLoadingEventHandler
+} = makePHEventFunctions("loading");
+
+// src/hooks/modals.ts
+var modalEventFunctions = makePHEventFunctions("modal");
+var usePHModal = modalEventFunctions.useValue;
+var setPHModal = modalEventFunctions.setValue;
+var addModalEventHandler = modalEventFunctions.addEventHandler;
+function showPHModal(modal) {
+  setPHModal(modal);
+}
+function closePHModal() {
+  setPHModal(undefined);
+}
+function showCreateDocumentModal(documentType) {
+  setPHModal({ type: "createDocument", documentType });
+}
+function showDeleteNodeModal(nodeOrId) {
+  const id = typeof nodeOrId === "string" ? nodeOrId : nodeOrId.id;
+  setPHModal({ type: "deleteItem", id });
+}
+
+// src/hooks/reactor.ts
+var reactorClientModuleEventFunctions = makePHEventFunctions("reactorClientModule");
+var reactorClientEventFunctions = makePHEventFunctions("reactorClient");
+var useReactorClientModule = reactorClientModuleEventFunctions.useValue;
+var setReactorClientModule = reactorClientModuleEventFunctions.setValue;
+var addReactorClientModuleEventHandler = reactorClientModuleEventFunctions.addEventHandler;
+var useReactorClient = reactorClientEventFunctions.useValue;
+var setReactorClient = reactorClientEventFunctions.setValue;
+var addReactorClientEventHandler = reactorClientEventFunctions.addEventHandler;
+var useSync = () => useReactorClientModule()?.reactorModule?.syncModule?.syncManager;
+var useSyncList = () => {
+  const sync = useSync();
+  return sync?.list() ?? [];
+};
+var useModelRegistry = () => useReactorClientModule()?.reactorModule?.documentModelRegistry;
+var useDatabase = () => useReactorClientModule()?.reactorModule?.database;
+var usePGlite = () => useReactorClientModule()?.pg;
+
+// src/hooks/renown.ts
+import { useEffect, useState } from "react";
+var renownEventFunctions = makePHEventFunctions("renown");
+var useRenown = renownEventFunctions.useValue;
+var setRenown = renownEventFunctions.setValue;
+function useDid() {
+  const renown = useRenown();
+  return renown?.did;
+}
+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 useLoginStatus() {
+  const renown = useRenown();
+  const [status, setStatus] = useState(() => renown ? renown.status : "initializing");
+  useEffect(() => {
+    setStatus(renown ? renown.status : "initializing");
+    if (!renown)
+      return;
+    return renown.on("status", setStatus);
+  }, [renown]);
+  return status;
+}
+var addRenownEventHandler = renownEventFunctions.addEventHandler;
+
+// src/hooks/revision-history.ts
+var revisionHistoryEventFunctions = makePHEventFunctions("revisionHistoryVisible");
+var useRevisionHistoryVisible = revisionHistoryEventFunctions.useValue;
+var setRevisionHistoryVisible = revisionHistoryEventFunctions.setValue;
+var addRevisionHistoryVisibleEventHandler = revisionHistoryEventFunctions.addEventHandler;
+function showRevisionHistory() {
+  setRevisionHistoryVisible(true);
+}
+function hideRevisionHistory() {
+  setRevisionHistoryVisible(false);
+}
+
+// ../../node_modules/.pnpm/slug@11.0.1/node_modules/slug/slug.js
+var 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);
+        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);
+  const fallback = opts && opts.fallback !== undefined ? opts.fallback : slug.defaults.fallback;
+  if (fallback === true && result === "") {
+    result = slugify(base64(string), opts);
+  }
+  return result;
+}
+var 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" }
+};
+var 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;
+}
+var 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"
+};
+var 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] || {};
+};
+var slug_default = slug;
+
+// src/utils/url.ts
+function resolveUrlPathname(path) {
+  return new URL(path.replace(/^\/+/, ""), window.location.origin + (window.ph?.basePath ?? "/")).pathname;
+}
+function getPathWithoutBase(path) {
+  const basePath = window.ph?.basePath ?? "/";
+  return path.replace(basePath, basePath.endsWith("/") ? "/" : "");
+}
+function makeDriveUrlComponent(drive) {
+  if (!drive)
+    return "";
+  return `/d/${slug_default(drive.header.slug)}`;
+}
+function makeNodeSlug(node) {
+  if (!node)
+    return "";
+  const nodeName = node.name;
+  if (!nodeName)
+    return slug_default(node.id);
+  return slug_default(`${nodeName}-${node.id}`);
+}
+function extractNodeSlugFromPath(path) {
+  const currentPath = getPathWithoutBase(path);
+  const match = /^\/d\/[^/]+\/([^/]+)$/.exec(currentPath);
+  return match?.[1];
+}
+function findUuid(input) {
+  if (!input)
+    return;
+  const uuidRegex = /\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/;
+  const match = uuidRegex.exec(input);
+  return match?.[0];
+}
+function extractNodeIdFromSlug(nodeSlug) {
+  const nodeId = findUuid(nodeSlug);
+  return nodeId;
+}
+function extractNodeIdFromPath(path) {
+  const nodeSlug = extractNodeSlugFromPath(path);
+  const nodeId = extractNodeIdFromSlug(nodeSlug);
+  return nodeId;
+}
+function extractDriveSlugFromPath(path) {
+  const currentPath = getPathWithoutBase(path);
+  const match = /^\/d\/([^/]+)/.exec(currentPath);
+  return match?.[1] ?? "";
+}
+function extractDriveIdFromSlug(driveSlug) {
+  const driveId = findUuid(driveSlug);
+  return driveId;
+}
+function extractDriveIdFromPath(path) {
+  const driveSlug = extractDriveSlugFromPath(path);
+  const driveId = extractDriveIdFromSlug(driveSlug);
+  return driveId;
+}
+function createUrlWithPreservedParams(pathname) {
+  const search = window.location.search;
+  return search ? `${pathname}${search}` : pathname;
+}
+
+// src/hooks/dispatch.ts
+import { logger as logger5 } from "document-drive";
+
+// src/actions/dispatch.ts
+import { logger as logger4 } from "document-drive";
+
+// src/actions/queue.ts
+import { logger as logger2 } from "document-drive";
+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;
+  logger2.verbose(`uploadDocumentOperations(documentId:${documentId}, ops: ${Object.keys(allOperations).join(",")}, limit:${operationsLimit})`);
+  const allOperationsArray = Object.values(allOperations).filter((ops) => ops !== undefined);
+  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) {
+      logger2.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) {
+        const progress = Math.round(uploadedOperations / totalOperations * 100);
+        onProgress({
+          stage: "uploading",
+          progress,
+          totalOperations,
+          uploadedOperations
+        });
+      }
+      logger2.verbose(`uploadDocumentOperations:for:waitForUpdate(${documentId}:${scope} rev ${operation.index}): NEXT`);
+    }
+  }
+  logger2.verbose(`uploadDocumentOperations:for:waitForUpdate(${documentId}): END`);
+}
+
+// src/actions/sign.ts
+import { logger as logger3 } from "document-drive";
+import { buildSignedAction } from "document-model/core";
+async function signAction(action, document) {
+  const reactor = window.ph?.reactorClient;
+  if (!reactor)
+    return action;
+  const documentModelModule = await reactor.getDocumentModelModule(document.header.documentType);
+  const reducer = documentModelModule.reducer;
+  const renown = window.ph?.renown;
+  if (!renown?.user)
+    return action;
+  if (!action.context?.signer)
+    return action;
+  const actionSigner = action.context.signer;
+  const unsafeSignedAction = await buildSignedAction(action, reducer, document, actionSigner, renown.crypto.sign);
+  return unsafeSignedAction;
+}
+function addActionContext(action) {
+  const renown = window.ph?.renown;
+  if (!renown?.user)
+    return action;
+  const signer = {
+    app: {
+      name: "Connect",
+      key: renown.did
+    },
+    user: {
+      address: renown.user.address,
+      networkId: renown.user.networkId,
+      chainId: renown.user.chainId
+    },
+    signatures: []
+  };
+  return {
+    context: { signer },
+    ...action
+  };
+}
+async function makeSignedActionWithContext(action, document) {
+  if (!action) {
+    logger3.error("No action found");
+    return;
+  }
+  if (!document) {
+    logger3.error("No document found");
+    return;
+  }
+  const signedAction = await signAction(action, document);
+  const signedActionWithContext = addActionContext(signedAction);
+  return signedActionWithContext;
+}
+async function makeSignedActionsWithContext(actionOrActions, document) {
+  if (!actionOrActions) {
+    logger3.error("No actions found");
+    return;
+  }
+  const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions];
+  const signedActionsWithContext = await Promise.all(actions.map((action) => makeSignedActionWithContext(action, document)));
+  return signedActionsWithContext.filter((a) => a !== undefined);
+}
+
+// src/actions/dispatch.ts
+async function getDocument(documentId) {
+  try {
+    return await window.ph?.reactorClient?.get(documentId);
+  } catch (error) {
+    logger4.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((op2) => op2.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) {
+    logger4.error(`Document with id ${JSON.stringify(documentOrDocumentId)} not found`);
+    return;
+  }
+  const signedActionsWithContext = await makeSignedActionsWithContext(actionOrActions, document);
+  if (!signedActionsWithContext) {
+    logger4.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;
+}
+
+// src/hooks/dispatch.ts
+function useDispatch(document) {
+  function dispatch(actionOrActions, onErrors, onSuccess) {
+    dispatchActions(actionOrActions, document, onErrors, onSuccess).catch(logger5.error);
+  }
+  return [document, dispatch];
+}
+
+// src/hooks/selected-drive.ts
+var selectedDriveIdEventFunctions = makePHEventFunctions("selectedDriveId");
+var useSelectedDriveId = selectedDriveIdEventFunctions.useValue;
+var setSelectedDriveId = selectedDriveIdEventFunctions.setValue;
+var addSelectedDriveIdEventHandler = selectedDriveIdEventFunctions.addEventHandler;
+function useSelectedDrive() {
+  const drive = useSelectedDriveSafe();
+  if (!drive[0]) {
+    throw new Error("There is no drive selected. Did you mean to call 'useSelectedDriveSafe'?");
+  }
+  return drive;
+}
+function useSelectedDriveSafe() {
+  const selectedDriveId = useSelectedDriveId();
+  const drives = useDrives();
+  const selectedDrive = drives?.find((drive2) => drive2.header.id === selectedDriveId);
+  const [drive, dispatch] = useDispatch(selectedDrive);
+  if (!selectedDrive) {
+    return [undefined, undefined];
+  }
+  return [drive, dispatch];
+}
+function setSelectedDrive(driveOrDriveSlug) {
+  const driveSlug = typeof driveOrDriveSlug === "string" ? driveOrDriveSlug : driveOrDriveSlug?.header.slug;
+  const drive = window.ph?.drives?.find((d) => d.header.slug === driveSlug);
+  const driveId = drive?.header.id;
+  setSelectedDriveId(driveId);
+  if (!driveId) {
+    const pathname2 = resolveUrlPathname("/");
+    if (pathname2 === window.location.pathname) {
+      return;
+    }
+    window.history.pushState(null, "", createUrlWithPreservedParams(pathname2));
+    return;
+  }
+  const pathname = resolveUrlPathname(`/d/${driveSlug}`);
+  if (pathname === window.location.pathname) {
+    return;
+  }
+  window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+}
+function addSetSelectedDriveOnPopStateEventHandler() {
+  window.addEventListener("popstate", () => {
+    const pathname = window.location.pathname;
+    const driveId = extractDriveIdFromPath(pathname);
+    const selectedDriveId = window.ph?.selectedDriveId;
+    if (driveId !== selectedDriveId) {
+      setSelectedDrive(driveId);
+    }
+  });
+}
+
+// src/utils/nodes.ts
+function sortNodesByName(nodes) {
+  return nodes.toSorted((a, b) => a.name.localeCompare(b.name));
+}
+function isFileNodeKind(node) {
+  if (!node)
+    return false;
+  return node.kind.toUpperCase() === "FILE";
+}
+function isFolderNodeKind(node) {
+  if (!node)
+    return false;
+  return node.kind.toUpperCase() === "FOLDER";
+}
+
+// src/hooks/document-by-id.ts
+function useDocumentById(id) {
+  const document = useDocument(id);
+  const [, dispatch] = useDispatch(document);
+  return [document, dispatch];
+}
+function useDocumentsByIds(ids) {
+  return useDocuments(ids);
+}
+
+// src/hooks/items-in-selected-drive.ts
+function useNodesInSelectedDrive() {
+  const [selectedDrive] = useSelectedDriveSafe();
+  return selectedDrive?.state.global.nodes;
+}
+function useFileNodesInSelectedDrive() {
+  const nodes = useNodesInSelectedDrive();
+  return nodes?.filter((n) => isFileNodeKind(n));
+}
+function useFolderNodesInSelectedDrive() {
+  const nodes = useNodesInSelectedDrive();
+  return nodes?.filter((n) => isFolderNodeKind(n));
+}
+function useDocumentsInSelectedDrive() {
+  const fileNodes = useFileNodesInSelectedDrive();
+  const fileNodeIds = fileNodes?.map((node) => node.id);
+  return useDocumentsByIds(fileNodeIds);
+}
+function useDocumentTypesInSelectedDrive() {
+  const documentsInSelectedDrive = useDocumentsInSelectedDrive();
+  const documentModelDocumentsInSelectedDrive = documentsInSelectedDrive?.filter(isDocumentModelDocument);
+  const documentTypesFromDocumentModelDocuments = documentModelDocumentsInSelectedDrive?.map((doc) => doc.state.global.id);
+  return documentTypesFromDocumentModelDocuments;
+}
+function isDocumentModelDocument(document) {
+  return document.header.documentType === "powerhouse/document-model";
+}
+
+// src/hooks/selected-node.ts
+var selectedNodeIdEventFunctions = makePHEventFunctions("selectedNodeId");
+var useSelectedNodeId = selectedNodeIdEventFunctions.useValue;
+var setSelectedNodeId = selectedNodeIdEventFunctions.setValue;
+var addSelectedNodeIdEventHandler = selectedNodeIdEventFunctions.addEventHandler;
+function useSelectedNode() {
+  const selectedNodeId = useSelectedNodeId();
+  const nodes = useNodesInSelectedDrive();
+  return nodes?.find((n) => n.id === selectedNodeId);
+}
+function setSelectedNode(nodeOrNodeSlug) {
+  const nodeSlug = typeof nodeOrNodeSlug === "string" ? nodeOrNodeSlug : makeNodeSlug(nodeOrNodeSlug);
+  const nodeId = extractNodeIdFromSlug(nodeSlug);
+  setSelectedNodeId(nodeId);
+  const driveSlugFromPath = extractDriveSlugFromPath(window.location.pathname);
+  if (!driveSlugFromPath) {
+    return;
+  }
+  if (!nodeSlug) {
+    const pathname2 = resolveUrlPathname(`/d/${driveSlugFromPath}`);
+    if (pathname2 === window.location.pathname) {
+      return;
+    }
+    window.history.pushState(null, "", createUrlWithPreservedParams(pathname2));
+    return;
+  }
+  const pathname = resolveUrlPathname(`/d/${driveSlugFromPath}/${nodeSlug}`);
+  if (pathname === window.location.pathname) {
+    return;
+  }
+  window.history.pushState(null, "", createUrlWithPreservedParams(pathname));
+}
+function addResetSelectedNodeEventHandler() {
+  window.addEventListener("ph:selectedDriveIdUpdated", () => {
+    setSelectedNodeId(undefined);
+  });
+}
+function addSetSelectedNodeOnPopStateEventHandler() {
+  window.addEventListener("popstate", () => {
+    const pathname = window.location.pathname;
+    const nodeSlug = extractNodeSlugFromPath(pathname);
+    const selectedNodeId = window.ph?.selectedNodeId;
+    if (nodeSlug !== selectedNodeId) {
+      setSelectedNode(nodeSlug);
+    }
+  });
+}
+
+// src/hooks/selected-timeline-item.ts
+var selectedTimelineItemEventFunctions = makePHEventFunctions("selectedTimelineItem");
+var useSelectedTimelineItem = selectedTimelineItemEventFunctions.useValue;
+var setSelectedTimelineItem = selectedTimelineItemEventFunctions.setValue;
+var addSelectedTimelineItemEventHandler = selectedTimelineItemEventFunctions.addEventHandler;
+
+// src/hooks/timeline-revision.ts
+var selectedTimelineRevisionEventFunctions = makePHEventFunctions("selectedTimelineRevision");
+var useSelectedTimelineRevision = selectedTimelineRevisionEventFunctions.useValue;
+var setSelectedTimelineRevision = selectedTimelineRevisionEventFunctions.setValue;
+var addSelectedTimelineRevisionEventHandler = selectedTimelineRevisionEventFunctions.addEventHandler;
+
+// src/hooks/toast.ts
+var toastEventFunctions = makePHEventFunctions("toast");
+var usePHToast = toastEventFunctions.useValue;
+var setPHToast = toastEventFunctions.setValue;
+var addToastEventHandler = toastEventFunctions.addEventHandler;
+
+// src/hooks/vetra-packages.ts
+import { DuplicateModuleError } from "@powerhousedao/reactor";
+import { useSyncExternalStore as useSyncExternalStore3 } from "react";
+var vetraPackageManagerFunctions = makePHEventFunctions("vetraPackageManager");
+var useVetraPackageManager = vetraPackageManagerFunctions.useValue;
+var useVetraPackages = () => {
+  const packageManager = useVetraPackageManager();
+  return useSyncExternalStore3((cb) => packageManager ? packageManager.subscribe(cb) : () => {}, () => packageManager?.packages ?? []);
+};
+var addVetraPackageManagerEventHandler = vetraPackageManagerFunctions.addEventHandler;
+function setVetraPackageManager(packageManager) {
+  vetraPackageManagerFunctions.setValue(packageManager);
+  updateReactorClientDocumentModels(packageManager.packages);
+  packageManager.subscribe(({ packages }) => {
+    updateReactorClientDocumentModels(packages);
+  });
+}
+function updateReactorClientDocumentModels(packages) {
+  const documentModelModules = packages.flatMap((pkg) => pkg.modules.documentModelModules).filter((module) => module !== undefined);
+  const registry = window.ph?.reactorClientModule?.reactorModule?.documentModelRegistry;
+  if (!registry || documentModelModules.length === 0)
+    return;
+  for (const module of documentModelModules) {
+    try {
+      registry.registerModules(module);
+    } catch (error) {
+      if (DuplicateModuleError.isError(error)) {
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+// src/hooks/add-ph-event-handlers.ts
+var phGlobalEventHandlerRegisterFunctions = {
+  loading: addLoadingEventHandler,
+  reactorClientModule: addReactorClientModuleEventHandler,
+  reactorClient: addReactorClientEventHandler,
+  features: addFeaturesEventHandler,
+  modal: addModalEventHandler,
+  renown: addRenownEventHandler,
+  drives: addDrivesEventHandler,
+  documentCache: addDocumentCacheEventHandler,
+  selectedDriveId: () => {
+    addSelectedDriveIdEventHandler();
+    addSetSelectedDriveOnPopStateEventHandler();
+    addResetSelectedNodeEventHandler();
+  },
+  selectedNodeId: () => {
+    addSelectedNodeIdEventHandler();
+    addSetSelectedNodeOnPopStateEventHandler();
+  },
+  vetraPackageManager: addVetraPackageManagerEventHandler,
+  selectedTimelineRevision: addSelectedTimelineRevisionEventHandler,
+  revisionHistoryVisible: addRevisionHistoryVisibleEventHandler,
+  selectedTimelineItem: addSelectedTimelineItemEventHandler,
+  routerBasename: addRouterBasenameEventHandler,
+  version: addVersionEventHandler,
+  logLevel: addLogLevelEventHandler,
+  requiresHardRefresh: addRequiresHardRefreshEventHandler,
+  warnOutdatedApp: addWarnOutdatedAppEventHandler,
+  studioMode: addStudioModeEventHandler,
+  basePath: addBasePathEventHandler,
+  versionCheckInterval: addVersionCheckIntervalEventHandler,
+  cliVersion: addCliVersionEventHandler,
+  fileUploadOperationsChunkSize: addFileUploadOperationsChunkSizeEventHandler,
+  isDocumentModelSelectionSettingsEnabled: addIsDocumentModelSelectionSettingsEnabledEventHandler,
+  gaTrackingId: addGaTrackingIdEventHandler,
+  allowList: addAllowListEventHandler,
+  defaultDrivesUrl: addDefaultDrivesUrlEventHandler,
+  drivesPreserveStrategy: addDrivesPreserveStrategyEventHandler,
+  allowedDocumentTypes: addAllowedDocumentTypesEventHandler,
+  enabledEditors: addEnabledEditorsEventHandler,
+  disabledEditors: addDisabledEditorsEventHandler,
+  isAddDriveEnabled: addIsAddDriveEnabledEventHandler,
+  isLocalDrivesEnabled: addIsLocalDrivesEnabledEventHandler,
+  isPublicDrivesEnabled: addIsPublicDrivesEnabledEventHandler,
+  isAddPublicDrivesEnabled: addIsAddPublicDrivesEnabledEventHandler,
+  isDeletePublicDrivesEnabled: addIsDeletePublicDrivesEnabledEventHandler,
+  isCloudDrivesEnabled: addIsCloudDrivesEnabledEventHandler,
+  isAddCloudDrivesEnabled: addIsAddCloudDrivesEnabledEventHandler,
+  isDeleteCloudDrivesEnabled: addIsDeleteCloudDrivesEnabledEventHandler,
+  isAddLocalDrivesEnabled: addIsAddLocalDrivesEnabledEventHandler,
+  isDeleteLocalDrivesEnabled: addIsDeleteLocalDrivesEnabledEventHandler,
+  isDragAndDropEnabled: addIsDragAndDropEnabledEventHandler,
+  isExternalControlsEnabled: addIsExternalControlsEnabledEventHandler,
+  isEditorDebugModeEnabled: addIsEditorDebugModeEnabledEventHandler,
+  isEditorReadModeEnabled: addIsEditorReadModeEnabledEventHandler,
+  isRelationalProcessorsEnabled: addIsRelationalProcessorsEnabledEventHandler,
+  isExternalRelationalProcessorsEnabled: addIsExternalRelationalProcessorsEnabledEventHandler,
+  isAnalyticsEnabled: addIsAnalyticsEnabledEventHandler,
+  isAnalyticsExternalProcessorsEnabled: addIsAnalyticsExternalProcessorsEnabledEventHandler,
+  analyticsDatabaseName: addAnalyticsDatabaseNameEventHandler,
+  isAnalyticsDatabaseWorkerEnabled: addIsAnalyticsDatabaseWorkerEnabledEventHandler,
+  isDiffAnalyticsEnabled: addIsDiffAnalyticsEnabledEventHandler,
+  isDriveAnalyticsEnabled: addIsDriveAnalyticsEnabledEventHandler,
+  renownUrl: addRenownUrlEventHandler,
+  renownNetworkId: addRenownNetworkIdEventHandler,
+  renownChainId: addRenownChainIdEventHandler,
+  sentryRelease: addSentryReleaseEventHandler,
+  sentryDsn: addSentryDsnEventHandler,
+  sentryEnv: addSentryEnvEventHandler,
+  isSentryTracingEnabled: addIsSentryTracingEnabledEventHandler,
+  isExternalProcessorsEnabled: addIsExternalProcessorsEnabledEventHandler,
+  isExternalPackagesEnabled: addIsExternalPackagesEnabledEventHandler,
+  toast: addToastEventHandler
+};
+function addPHEventHandlers() {
+  for (const fn of Object.values(phGlobalEventHandlerRegisterFunctions)) {
+    fn();
+  }
+}
+// src/hooks/config/set-config-by-key.ts
+function setPHGlobalConfigByKey(key, value) {
+  const setter = phGlobalConfigSetters[key];
+  setter(value);
+}
+function setPHDriveEditorConfigByKey(key, value) {
+  const setter = phDriveEditorConfigSetters[key];
+  setter(value);
+}
+function setPHDocumentEditorConfigByKey(key, value) {
+  const setter = phDocumentEditorConfigSetters[key];
+  setter(value);
+}
+// src/hooks/config/set-config-by-object.ts
+import { useEffect as useEffect2, useState as useState2 } from "react";
+
+// src/hooks/config/utils.ts
+function callGlobalSetterForKey(key, value) {
+  const setter = phGlobalConfigSetters[key];
+  setter(value);
+}
+
+// src/hooks/config/set-config-by-object.ts
+function setDefaultPHGlobalConfig(config) {
+  for (const key of Object.keys(config)) {
+    callGlobalSetterForKey(key, config[key]);
+  }
+}
+function useSetDefaultPHGlobalConfig(config) {
+  const [isInitialized, setIsInitialized] = useState2(false);
+  useEffect2(() => {
+    if (isInitialized)
+      return;
+    setDefaultPHGlobalConfig(config);
+    setIsInitialized(true);
+  }, [config, isInitialized]);
+}
+function useResetPHGlobalConfig(defaultConfigForReset) {
+  return function reset() {
+    setPHGlobalConfig(defaultConfigForReset);
+  };
+}
+function setPHGlobalConfig(config) {
+  for (const key of Object.keys(config)) {
+    callGlobalSetterForKey(key, config[key]);
+  }
+}
+function useSetPHGlobalConfig(config) {
+  const [isInitialized, setIsInitialized] = useState2(false);
+  useEffect2(() => {
+    if (isInitialized)
+      return;
+    setPHGlobalConfig(config);
+    setIsInitialized(true);
+  }, [config, isInitialized]);
+}
+function setPHDriveEditorConfig(config) {
+  for (const key of Object.keys(config)) {
+    callGlobalSetterForKey(key, config[key]);
+  }
+}
+function setPHDocumentEditorConfig(config) {
+  for (const key of Object.keys(config)) {
+    callGlobalSetterForKey(key, config[key]);
+  }
+}
+function useSetPHDriveEditorConfig(config) {
+  const [isInitialized, setIsInitialized] = useState2(false);
+  useEffect2(() => {
+    if (isInitialized)
+      return;
+    setPHDriveEditorConfig(config);
+    setIsInitialized(true);
+  }, [config, isInitialized]);
+}
+function useSetPHDocumentEditorConfig(config) {
+  const [isInitialized, setIsInitialized] = useState2(false);
+  useEffect2(() => {
+    if (isInitialized)
+      return;
+    setPHDocumentEditorConfig(config);
+    setIsInitialized(true);
+  }, [config, isInitialized]);
+}
+// src/hooks/config/use-value-by-key.ts
+function usePHGlobalConfigByKey(key) {
+  const useValueHook = phGlobalConfigHooks[key];
+  return useValueHook();
+}
+function usePHDriveEditorConfigByKey(key) {
+  const useValueHook = phDriveEditorConfigHooks[key];
+  return useValueHook();
+}
+function usePHDocumentEditorConfigByKey(key) {
+  const useValueHook = phDocumentEditorConfigHooks[key];
+  return useValueHook();
+}
+// src/hooks/connection-state.ts
+import { useEffect as useEffect3, useRef, useState as useState3 } from "react";
+function useConnectionStates() {
+  const syncManager = useSync();
+  const [states, setStates] = useState3(() => buildSnapshot(syncManager));
+  const unsubscribesRef = useRef([]);
+  useEffect3(() => {
+    if (!syncManager)
+      return;
+    function subscribe() {
+      for (const unsub of unsubscribesRef.current) {
+        unsub();
+      }
+      unsubscribesRef.current = [];
+      const remotes = syncManager.list();
+      for (const remote of remotes) {
+        const unsub = remote.channel.onConnectionStateChange(() => {
+          setStates(buildSnapshot(syncManager));
+        });
+        unsubscribesRef.current.push(unsub);
+      }
+      setStates(buildSnapshot(syncManager));
+    }
+    subscribe();
+    const interval = setInterval(subscribe, 5000);
+    return () => {
+      clearInterval(interval);
+      for (const unsub of unsubscribesRef.current) {
+        unsub();
+      }
+      unsubscribesRef.current = [];
+    };
+  }, [syncManager]);
+  return states;
+}
+function useConnectionState(remoteName) {
+  const states = useConnectionStates();
+  return states.get(remoteName);
+}
+function buildSnapshot(syncManager) {
+  const map = new Map;
+  if (!syncManager)
+    return map;
+  for (const remote of syncManager.list()) {
+    map.set(remote.name, remote.channel.getConnectionState());
+  }
+  return map;
+}
+export {
+  useWarnOutdatedApp,
+  useVersionCheckInterval,
+  useVersion,
+  useUser,
+  useSyncList,
+  useSync,
+  useStudioMode,
+  useSetPHGlobalConfig,
+  useSetDefaultPHGlobalConfig,
+  useSentryRelease,
+  useSentryEnv,
+  useSentryDsn,
+  useRouterBasename,
+  useResetPHGlobalConfig,
+  useRequiresHardRefresh,
+  useRenownUrl,
+  useRenownNetworkId,
+  useRenownChainId,
+  useRenown,
+  useReactorClientModule,
+  useReactorClient,
+  usePHGlobalConfigByKey,
+  usePGlite,
+  useModelRegistry,
+  useLoginStatus,
+  useLogLevel,
+  useLoading,
+  useIsSentryTracingEnabled,
+  useIsPublicDrivesEnabled,
+  useIsLocalDrivesEnabled,
+  useIsExternalProcessorsEnabled,
+  useIsExternalPackagesEnabled,
+  useIsEditorReadModeEnabled,
+  useIsEditorDebugModeEnabled,
+  useIsDriveAnalyticsEnabled,
+  useIsDocumentModelSelectionSettingsEnabled,
+  useIsDiffAnalyticsEnabled,
+  useIsDeletePublicDrivesEnabled,
+  useIsDeleteLocalDrivesEnabled,
+  useIsDeleteCloudDrivesEnabled,
+  useIsCloudDrivesEnabled,
+  useIsAnalyticsDatabaseWorkerEnabled,
+  useIsAddPublicDrivesEnabled,
+  useIsAddLocalDrivesEnabled,
+  useIsAddDriveEnabled,
+  useIsAddCloudDrivesEnabled,
+  useGaTrackingId,
+  useFileUploadOperationsChunkSize,
+  useEnabledEditors,
+  useDrivesPreserveStrategy,
+  useDocumentCache,
+  useDisabledEditors,
+  useDid,
+  useDefaultDrivesUrl,
+  useDatabase,
+  useConnectionStates,
+  useConnectionState,
+  useCliVersion,
+  useBasePath,
+  useAnalyticsDatabaseName,
+  useAllowList,
+  setWarnOutdatedApp,
+  setVersionCheckInterval,
+  setVersion,
+  setStudioMode,
+  setSentryRelease,
+  setSentryEnv,
+  setSentryDsn,
+  setRouterBasename,
+  setRequiresHardRefresh,
+  setRenownUrl,
+  setRenownNetworkId,
+  setRenownChainId,
+  setRenown,
+  setReactorClientModule,
+  setReactorClient,
+  setPHGlobalConfigByKey,
+  setPHGlobalConfig,
+  setLogLevel,
+  setLoading,
+  setIsSentryTracingEnabled,
+  setIsPublicDrivesEnabled,
+  setIsLocalDrivesEnabled,
+  setIsExternalProcessorsEnabled,
+  setIsExternalPackagesEnabled,
+  setIsEditorReadModeEnabled,
+  setIsEditorDebugModeEnabled,
+  setIsDriveAnalyticsEnabled,
+  setIsDocumentModelSelectionSettingsEnabled,
+  setIsDiffAnalyticsEnabled,
+  setIsDeletePublicDrivesEnabled,
+  setIsDeleteLocalDrivesEnabled,
+  setIsDeleteCloudDrivesEnabled,
+  setIsCloudDrivesEnabled,
+  setIsAnalyticsDatabaseWorkerEnabled,
+  setIsAddPublicDrivesEnabled,
+  setIsAddLocalDrivesEnabled,
+  setIsAddDriveEnabled,
+  setIsAddCloudDrivesEnabled,
+  setGaTrackingId,
+  setFileUploadOperationsChunkSize,
+  setEnabledEditors,
+  setDrivesPreserveStrategy,
+  setDrives,
+  setDocumentCache,
+  setDisabledEditors,
+  setDefaultPHGlobalConfig,
+  setDefaultDrivesUrl,
+  setCliVersion,
+  setBasePath,
+  setAnalyticsDatabaseName,
+  setAllowList,
+  openRenown,
+  logout,
+  login,
+  addPHEventHandlers
+};