@rpcbase/client 0.286.0 → 0.288.0

package/dist/index.js

@@ -1,5 +1,1477 @@
-export * from "./apiClient";
-export * from "./initWithRoutes";
-export * from "./types";
-export * from "./getFeatureFlag";
-export * from "./RootProvider";
+import { jsx } from "react/jsx-runtime";
+import { StrictMode, useRef, useEffect, useCallback, useState, useSyncExternalStore } from "react";
+import posthog from "posthog-js";
+import { createRoutesFromElements, createBrowserRouter, RouterProvider, useLocation } from "@rpcbase/router";
+import { hydrateRoot } from "react-dom/client";
+import { PostHogProvider } from "posthog-js/react/dist/esm/index.js";
+import useMeasure from "react-use/lib/useMeasure.js";
+let apiClient;
+const initApiClient = async (args) => {
+  {
+    const axios = (await import("axios")).default;
+    const axiosClient = axios.create({
+      baseURL: "/",
+      withCredentials: true,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    const createMethod = (method) => {
+      return async (path, payload, _ctx) => {
+        const config = {
+          method,
+          url: path,
+          data: payload,
+          headers: {
+            // ...(typeof ctxOrPath !== 'string' && {
+            //   // 'X-Custom-Header': ctxOrPath.someHeaderValue,
+            //   // ...ctxOrPath.additionalHeaders,
+            // }),
+          }
+        };
+        try {
+          const response = await axiosClient(config);
+          return response.data;
+        } catch (error) {
+          console.log("AXIOS API ERROR", error);
+          throw error;
+        }
+      };
+    };
+    apiClient = {
+      get: createMethod("get"),
+      put: createMethod("put"),
+      post: createMethod("post"),
+      delete: createMethod("delete")
+    };
+  }
+};
+const CLEANUP_WAIT_DELAY = 1e3;
+const cleanupURL = () => {
+  const runCleanup = () => {
+    setTimeout(() => {
+      const url = new URL(window.location.href);
+      const params = new URLSearchParams(url.search);
+      const paramKeys = Array.from(params.keys());
+      paramKeys.forEach((key) => {
+        if (key.startsWith("utm_")) {
+          params.delete(key);
+        }
+      });
+      const cleanUrl = url.pathname + (params.toString() ? "?" + params.toString() : "") + url.hash;
+      window.history.replaceState({}, document.title, cleanUrl);
+    }, CLEANUP_WAIT_DELAY);
+  };
+  if (document.readyState === "complete" || document.readyState === "interactive") {
+    runCleanup();
+  } else {
+    document.addEventListener("DOMContentLoaded", runCleanup, { once: true });
+  }
+};
+const showErrorOverlay = (err) => {
+  const ErrorOverlay = customElements.get("vite-error-overlay");
+  if (!ErrorOverlay) {
+    return;
+  }
+  console.log(err);
+  const overlay = new ErrorOverlay(err);
+  document.body.appendChild(overlay);
+};
+const handleServerErrors = () => {
+  if (window.__staticRouterHydrationData?.errors) {
+    const { errors } = window.__staticRouterHydrationData;
+    Object.values(errors).forEach((error) => {
+      showErrorOverlay({
+        plugin: "ssr-router",
+        ...error.reason
+      });
+    });
+  }
+};
+const initWithRoutes = async (routesElement, opts) => {
+  await initApiClient();
+  cleanupURL();
+  handleServerErrors();
+  const routes = createRoutesFromElements(routesElement);
+  const router = createBrowserRouter(routes);
+  const toError = (error) => error instanceof Error ? error : new Error(String(error));
+  const phReactHandler = (react_context) => (error, errorInfo) => {
+    const err = toError(error);
+    posthog.captureException(err, {
+      react_context,
+      component_stack: errorInfo?.componentStack
+    });
+    if (react_context === "uncaught") {
+      console.warn("Uncaught error", err, errorInfo?.componentStack);
+    }
+  };
+  const hydrationOptions = {
+    onUncaughtError: phReactHandler("uncaught"),
+    onCaughtError: phReactHandler("caught"),
+    onRecoverableError: phReactHandler("recoverable")
+  };
+  hydrateRoot(
+    document.getElementById("root"),
+    /* @__PURE__ */ jsx(StrictMode, { children: /* @__PURE__ */ jsx(RouterProvider, { router }) }),
+    hydrationOptions
+  );
+};
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var _arrayReduce;
+var hasRequired_arrayReduce;
+function require_arrayReduce() {
+  if (hasRequired_arrayReduce) return _arrayReduce;
+  hasRequired_arrayReduce = 1;
+  function arrayReduce(array, iteratee, accumulator, initAccum) {
+    var index = -1, length = array == null ? 0 : array.length;
+    if (initAccum && length) {
+      accumulator = array[++index];
+    }
+    while (++index < length) {
+      accumulator = iteratee(accumulator, array[index], index, array);
+    }
+    return accumulator;
+  }
+  _arrayReduce = arrayReduce;
+  return _arrayReduce;
+}
+var _basePropertyOf;
+var hasRequired_basePropertyOf;
+function require_basePropertyOf() {
+  if (hasRequired_basePropertyOf) return _basePropertyOf;
+  hasRequired_basePropertyOf = 1;
+  function basePropertyOf(object) {
+    return function(key) {
+      return object == null ? void 0 : object[key];
+    };
+  }
+  _basePropertyOf = basePropertyOf;
+  return _basePropertyOf;
+}
+var _deburrLetter;
+var hasRequired_deburrLetter;
+function require_deburrLetter() {
+  if (hasRequired_deburrLetter) return _deburrLetter;
+  hasRequired_deburrLetter = 1;
+  var basePropertyOf = require_basePropertyOf();
+  var deburredLetters = {
+    // Latin-1 Supplement block.
+    "À": "A",
+    "Á": "A",
+    "Â": "A",
+    "Ã": "A",
+    "Ä": "A",
+    "Å": "A",
+    "à": "a",
+    "á": "a",
+    "â": "a",
+    "ã": "a",
+    "ä": "a",
+    "å": "a",
+    "Ç": "C",
+    "ç": "c",
+    "Ð": "D",
+    "ð": "d",
+    "È": "E",
+    "É": "E",
+    "Ê": "E",
+    "Ë": "E",
+    "è": "e",
+    "é": "e",
+    "ê": "e",
+    "ë": "e",
+    "Ì": "I",
+    "Í": "I",
+    "Î": "I",
+    "Ï": "I",
+    "ì": "i",
+    "í": "i",
+    "î": "i",
+    "ï": "i",
+    "Ñ": "N",
+    "ñ": "n",
+    "Ò": "O",
+    "Ó": "O",
+    "Ô": "O",
+    "Õ": "O",
+    "Ö": "O",
+    "Ø": "O",
+    "ò": "o",
+    "ó": "o",
+    "ô": "o",
+    "õ": "o",
+    "ö": "o",
+    "ø": "o",
+    "Ù": "U",
+    "Ú": "U",
+    "Û": "U",
+    "Ü": "U",
+    "ù": "u",
+    "ú": "u",
+    "û": "u",
+    "ü": "u",
+    "Ý": "Y",
+    "ý": "y",
+    "ÿ": "y",
+    "Æ": "Ae",
+    "æ": "ae",
+    "Þ": "Th",
+    "þ": "th",
+    "ß": "ss",
+    // Latin Extended-A block.
+    "Ā": "A",
+    "Ă": "A",
+    "Ą": "A",
+    "ā": "a",
+    "ă": "a",
+    "ą": "a",
+    "Ć": "C",
+    "Ĉ": "C",
+    "Ċ": "C",
+    "Č": "C",
+    "ć": "c",
+    "ĉ": "c",
+    "ċ": "c",
+    "č": "c",
+    "Ď": "D",
+    "Đ": "D",
+    "ď": "d",
+    "đ": "d",
+    "Ē": "E",
+    "Ĕ": "E",
+    "Ė": "E",
+    "Ę": "E",
+    "Ě": "E",
+    "ē": "e",
+    "ĕ": "e",
+    "ė": "e",
+    "ę": "e",
+    "ě": "e",
+    "Ĝ": "G",
+    "Ğ": "G",
+    "Ġ": "G",
+    "Ģ": "G",
+    "ĝ": "g",
+    "ğ": "g",
+    "ġ": "g",
+    "ģ": "g",
+    "Ĥ": "H",
+    "Ħ": "H",
+    "ĥ": "h",
+    "ħ": "h",
+    "Ĩ": "I",
+    "Ī": "I",
+    "Ĭ": "I",
+    "Į": "I",
+    "İ": "I",
+    "ĩ": "i",
+    "ī": "i",
+    "ĭ": "i",
+    "į": "i",
+    "ı": "i",
+    "Ĵ": "J",
+    "ĵ": "j",
+    "Ķ": "K",
+    "ķ": "k",
+    "ĸ": "k",
+    "Ĺ": "L",
+    "Ļ": "L",
+    "Ľ": "L",
+    "Ŀ": "L",
+    "Ł": "L",
+    "ĺ": "l",
+    "ļ": "l",
+    "ľ": "l",
+    "ŀ": "l",
+    "ł": "l",
+    "Ń": "N",
+    "Ņ": "N",
+    "Ň": "N",
+    "Ŋ": "N",
+    "ń": "n",
+    "ņ": "n",
+    "ň": "n",
+    "ŋ": "n",
+    "Ō": "O",
+    "Ŏ": "O",
+    "Ő": "O",
+    "ō": "o",
+    "ŏ": "o",
+    "ő": "o",
+    "Ŕ": "R",
+    "Ŗ": "R",
+    "Ř": "R",
+    "ŕ": "r",
+    "ŗ": "r",
+    "ř": "r",
+    "Ś": "S",
+    "Ŝ": "S",
+    "Ş": "S",
+    "Š": "S",
+    "ś": "s",
+    "ŝ": "s",
+    "ş": "s",
+    "š": "s",
+    "Ţ": "T",
+    "Ť": "T",
+    "Ŧ": "T",
+    "ţ": "t",
+    "ť": "t",
+    "ŧ": "t",
+    "Ũ": "U",
+    "Ū": "U",
+    "Ŭ": "U",
+    "Ů": "U",
+    "Ű": "U",
+    "Ų": "U",
+    "ũ": "u",
+    "ū": "u",
+    "ŭ": "u",
+    "ů": "u",
+    "ű": "u",
+    "ų": "u",
+    "Ŵ": "W",
+    "ŵ": "w",
+    "Ŷ": "Y",
+    "ŷ": "y",
+    "Ÿ": "Y",
+    "Ź": "Z",
+    "Ż": "Z",
+    "Ž": "Z",
+    "ź": "z",
+    "ż": "z",
+    "ž": "z",
+    "IJ": "IJ",
+    "ij": "ij",
+    "Œ": "Oe",
+    "œ": "oe",
+    "ʼn": "'n",
+    "ſ": "s"
+  };
+  var deburrLetter = basePropertyOf(deburredLetters);
+  _deburrLetter = deburrLetter;
+  return _deburrLetter;
+}
+var _freeGlobal;
+var hasRequired_freeGlobal;
+function require_freeGlobal() {
+  if (hasRequired_freeGlobal) return _freeGlobal;
+  hasRequired_freeGlobal = 1;
+  var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+  _freeGlobal = freeGlobal;
+  return _freeGlobal;
+}
+var _root;
+var hasRequired_root;
+function require_root() {
+  if (hasRequired_root) return _root;
+  hasRequired_root = 1;
+  var freeGlobal = require_freeGlobal();
+  var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+  var root = freeGlobal || freeSelf || Function("return this")();
+  _root = root;
+  return _root;
+}
+var _Symbol;
+var hasRequired_Symbol;
+function require_Symbol() {
+  if (hasRequired_Symbol) return _Symbol;
+  hasRequired_Symbol = 1;
+  var root = require_root();
+  var Symbol = root.Symbol;
+  _Symbol = Symbol;
+  return _Symbol;
+}
+var _arrayMap;
+var hasRequired_arrayMap;
+function require_arrayMap() {
+  if (hasRequired_arrayMap) return _arrayMap;
+  hasRequired_arrayMap = 1;
+  function arrayMap(array, iteratee) {
+    var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+    while (++index < length) {
+      result[index] = iteratee(array[index], index, array);
+    }
+    return result;
+  }
+  _arrayMap = arrayMap;
+  return _arrayMap;
+}
+var isArray_1;
+var hasRequiredIsArray;
+function requireIsArray() {
+  if (hasRequiredIsArray) return isArray_1;
+  hasRequiredIsArray = 1;
+  var isArray2 = Array.isArray;
+  isArray_1 = isArray2;
+  return isArray_1;
+}
+var _getRawTag;
+var hasRequired_getRawTag;
+function require_getRawTag() {
+  if (hasRequired_getRawTag) return _getRawTag;
+  hasRequired_getRawTag = 1;
+  var Symbol = require_Symbol();
+  var objectProto = Object.prototype;
+  var hasOwnProperty2 = objectProto.hasOwnProperty;
+  var nativeObjectToString = objectProto.toString;
+  var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
+    try {
+      value[symToStringTag] = void 0;
+      var unmasked = true;
+    } catch (e) {
+    }
+    var result = nativeObjectToString.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag] = tag;
+      } else {
+        delete value[symToStringTag];
+      }
+    }
+    return result;
+  }
+  _getRawTag = getRawTag;
+  return _getRawTag;
+}
+var _objectToString;
+var hasRequired_objectToString;
+function require_objectToString() {
+  if (hasRequired_objectToString) return _objectToString;
+  hasRequired_objectToString = 1;
+  var objectProto = Object.prototype;
+  var nativeObjectToString = objectProto.toString;
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+  _objectToString = objectToString;
+  return _objectToString;
+}
+var _baseGetTag;
+var hasRequired_baseGetTag;
+function require_baseGetTag() {
+  if (hasRequired_baseGetTag) return _baseGetTag;
+  hasRequired_baseGetTag = 1;
+  var Symbol = require_Symbol(), getRawTag = require_getRawTag(), objectToString = require_objectToString();
+  var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+  var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === void 0 ? undefinedTag : nullTag;
+    }
+    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+  }
+  _baseGetTag = baseGetTag;
+  return _baseGetTag;
+}
+var isObjectLike_1;
+var hasRequiredIsObjectLike;
+function requireIsObjectLike() {
+  if (hasRequiredIsObjectLike) return isObjectLike_1;
+  hasRequiredIsObjectLike = 1;
+  function isObjectLike(value) {
+    return value != null && typeof value == "object";
+  }
+  isObjectLike_1 = isObjectLike;
+  return isObjectLike_1;
+}
+var isSymbol_1;
+var hasRequiredIsSymbol;
+function requireIsSymbol() {
+  if (hasRequiredIsSymbol) return isSymbol_1;
+  hasRequiredIsSymbol = 1;
+  var baseGetTag = require_baseGetTag(), isObjectLike = requireIsObjectLike();
+  var symbolTag = "[object Symbol]";
+  function isSymbol(value) {
+    return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+  }
+  isSymbol_1 = isSymbol;
+  return isSymbol_1;
+}
+var _baseToString;
+var hasRequired_baseToString;
+function require_baseToString() {
+  if (hasRequired_baseToString) return _baseToString;
+  hasRequired_baseToString = 1;
+  var Symbol = require_Symbol(), arrayMap = require_arrayMap(), isArray2 = requireIsArray(), isSymbol = requireIsSymbol();
+  var symbolProto = Symbol ? Symbol.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+  function baseToString(value) {
+    if (typeof value == "string") {
+      return value;
+    }
+    if (isArray2(value)) {
+      return arrayMap(value, baseToString) + "";
+    }
+    if (isSymbol(value)) {
+      return symbolToString ? symbolToString.call(value) : "";
+    }
+    var result = value + "";
+    return result == "0" && 1 / value == -Infinity ? "-0" : result;
+  }
+  _baseToString = baseToString;
+  return _baseToString;
+}
+var toString_1;
+var hasRequiredToString;
+function requireToString() {
+  if (hasRequiredToString) return toString_1;
+  hasRequiredToString = 1;
+  var baseToString = require_baseToString();
+  function toString(value) {
+    return value == null ? "" : baseToString(value);
+  }
+  toString_1 = toString;
+  return toString_1;
+}
+var deburr_1;
+var hasRequiredDeburr;
+function requireDeburr() {
+  if (hasRequiredDeburr) return deburr_1;
+  hasRequiredDeburr = 1;
+  var deburrLetter = require_deburrLetter(), toString = requireToString();
+  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+  var rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+  var rsCombo = "[" + rsComboRange + "]";
+  var reComboMark = RegExp(rsCombo, "g");
+  function deburr(string) {
+    string = toString(string);
+    return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
+  }
+  deburr_1 = deburr;
+  return deburr_1;
+}
+var _asciiWords;
+var hasRequired_asciiWords;
+function require_asciiWords() {
+  if (hasRequired_asciiWords) return _asciiWords;
+  hasRequired_asciiWords = 1;
+  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+  function asciiWords(string) {
+    return string.match(reAsciiWord) || [];
+  }
+  _asciiWords = asciiWords;
+  return _asciiWords;
+}
+var _hasUnicodeWord;
+var hasRequired_hasUnicodeWord;
+function require_hasUnicodeWord() {
+  if (hasRequired_hasUnicodeWord) return _hasUnicodeWord;
+  hasRequired_hasUnicodeWord = 1;
+  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+  function hasUnicodeWord(string) {
+    return reHasUnicodeWord.test(string);
+  }
+  _hasUnicodeWord = hasUnicodeWord;
+  return _hasUnicodeWord;
+}
+var _unicodeWords;
+var hasRequired_unicodeWords;
+function require_unicodeWords() {
+  if (hasRequired_unicodeWords) return _unicodeWords;
+  hasRequired_unicodeWords = 1;
+  var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+  var rsApos = "['’]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
+  var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq;
+  var reUnicodeWord = RegExp([
+    rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
+    rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
+    rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
+    rsUpper + "+" + rsOptContrUpper,
+    rsOrdUpper,
+    rsOrdLower,
+    rsDigits,
+    rsEmoji
+  ].join("|"), "g");
+  function unicodeWords(string) {
+    return string.match(reUnicodeWord) || [];
+  }
+  _unicodeWords = unicodeWords;
+  return _unicodeWords;
+}
+var words_1;
+var hasRequiredWords;
+function requireWords() {
+  if (hasRequiredWords) return words_1;
+  hasRequiredWords = 1;
+  var asciiWords = require_asciiWords(), hasUnicodeWord = require_hasUnicodeWord(), toString = requireToString(), unicodeWords = require_unicodeWords();
+  function words(string, pattern, guard) {
+    string = toString(string);
+    pattern = guard ? void 0 : pattern;
+    if (pattern === void 0) {
+      return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
+    }
+    return string.match(pattern) || [];
+  }
+  words_1 = words;
+  return words_1;
+}
+var _createCompounder;
+var hasRequired_createCompounder;
+function require_createCompounder() {
+  if (hasRequired_createCompounder) return _createCompounder;
+  hasRequired_createCompounder = 1;
+  var arrayReduce = require_arrayReduce(), deburr = requireDeburr(), words = requireWords();
+  var rsApos = "['’]";
+  var reApos = RegExp(rsApos, "g");
+  function createCompounder(callback) {
+    return function(string) {
+      return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
+    };
+  }
+  _createCompounder = createCompounder;
+  return _createCompounder;
+}
+var snakeCase_1;
+var hasRequiredSnakeCase;
+function requireSnakeCase() {
+  if (hasRequiredSnakeCase) return snakeCase_1;
+  hasRequiredSnakeCase = 1;
+  var createCompounder = require_createCompounder();
+  var snakeCase = createCompounder(function(result, word, index) {
+    return result + (index ? "_" : "") + word.toLowerCase();
+  });
+  snakeCase_1 = snakeCase;
+  return snakeCase_1;
+}
+var snakeCaseExports = requireSnakeCase();
+const _snakeCase = /* @__PURE__ */ getDefaultExportFromCjs(snakeCaseExports);
+const __vite_import_meta_env__ = { "BASE_URL": "/", "DEV": false, "MODE": "production", "PROD": true, "SSR": false };
+const getFeatureFlag = async (flag) => {
+  const envKey = `RB_PUBLIC_FLAG_${_snakeCase(flag).toUpperCase()}`;
+  {
+    let waitForFeatureFlags = function() {
+      return new Promise((resolve) => {
+        if (hasLoadedFeatureFlags) {
+          resolve();
+        } else {
+          posthog2.onFeatureFlags(() => {
+            hasLoadedFeatureFlags = true;
+            resolve();
+          });
+        }
+      });
+    };
+    if (__vite_import_meta_env__[envKey] !== void 0) {
+      return __vite_import_meta_env__[envKey];
+    }
+    const startTime = performance.now();
+    const { posthog: posthog2 } = await import("posthog-js");
+    let hasLoadedFeatureFlags = false;
+    await waitForFeatureFlags();
+    const endTime = performance.now();
+    console.log(`Client: Feature flag "${flag}" loaded in ${(endTime - startTime).toFixed(2)}ms`);
+    return posthog2.getFeatureFlag(flag);
+  }
+};
+function throttle(callback, limit) {
+  let wait = false;
+  return (...args) => {
+    if (!wait) {
+      callback(...args);
+      wait = true;
+      setTimeout(() => {
+        wait = false;
+      }, limit);
+    }
+  };
+}
+function useApplyScroll() {
+  const location = useLocation();
+  const previousPathRef = useRef(location.pathname);
+  const isScrollingProgrammatically = useRef(false);
+  const scrollTimeoutRef = useRef(null);
+  const lastAppliedHashRef = useRef("");
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      lastAppliedHashRef.current = window.location.hash || "";
+    }
+  }, []);
+  useEffect(() => {
+    lastAppliedHashRef.current = location.hash || "";
+  }, [location.hash]);
+  const replaceHashSilently = useCallback((hash) => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (lastAppliedHashRef.current === hash) {
+      return;
+    }
+    const base = `${window.location.pathname}${window.location.search}`;
+    window.history.replaceState(window.history.state, "", `${base}${hash}`);
+    lastAppliedHashRef.current = hash;
+  }, []);
+  const markProgrammaticScroll = useCallback(() => {
+    isScrollingProgrammatically.current = true;
+    if (scrollTimeoutRef.current) {
+      clearTimeout(scrollTimeoutRef.current);
+    }
+    scrollTimeoutRef.current = setTimeout(() => {
+      isScrollingProgrammatically.current = false;
+    }, 1e3);
+  }, []);
+  useEffect(() => {
+    const pathChanged = previousPathRef.current !== location.pathname;
+    if (pathChanged) {
+      previousPathRef.current = location.pathname;
+      if (!location.hash) {
+        window.scrollTo({ top: 0, left: 0, behavior: "auto" });
+        return;
+      }
+      setTimeout(() => {
+        const id2 = location.hash.substring(1);
+        const element2 = document.getElementById(id2);
+        if (element2) {
+          markProgrammaticScroll();
+          element2.scrollIntoView({ behavior: "smooth" });
+        }
+      }, 100);
+      return;
+    }
+    if (!location.hash) {
+      return;
+    }
+    const id = location.hash.substring(1);
+    const element = document.getElementById(id);
+    if (element) {
+      markProgrammaticScroll();
+      element.scrollIntoView({ behavior: "smooth" });
+    }
+  }, [location.hash, location.pathname, markProgrammaticScroll]);
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const handleScroll = throttle(() => {
+      if (isScrollingProgrammatically.current) {
+        return;
+      }
+      const sections = Array.from(document.querySelectorAll("section[id]"));
+      if (sections.length === 0) {
+        replaceHashSilently("");
+        return;
+      }
+      const scrollPosition = window.scrollY;
+      const viewportHeight = window.innerHeight;
+      const checkPoint = scrollPosition + viewportHeight / 3;
+      let activeSectionId = null;
+      for (const section of sections) {
+        if (section.offsetTop <= checkPoint && section.offsetTop + section.offsetHeight > checkPoint) {
+          activeSectionId = section.id;
+          break;
+        }
+      }
+      const newHash = activeSectionId ? `#${activeSectionId}` : "";
+      replaceHashSilently(newHash);
+    }, 150);
+    document.addEventListener("scroll", handleScroll);
+    return () => {
+      document.removeEventListener("scroll", handleScroll);
+      if (scrollTimeoutRef.current) {
+        clearTimeout(scrollTimeoutRef.current);
+        scrollTimeoutRef.current = null;
+      }
+    };
+  }, [replaceHashSilently]);
+  useEffect(() => {
+    const handleClick = (event) => {
+      const target = event.target;
+      const link = target?.closest("a");
+      const currentHash = typeof window !== "undefined" ? window.location.hash : location.hash || "";
+      if (!link || !link.hash || link.pathname !== location.pathname || link.hash !== currentHash) {
+        return;
+      }
+      const id = link.hash.substring(1);
+      const element = document.getElementById(id);
+      if (element) {
+        event.preventDefault();
+        event.stopPropagation();
+        markProgrammaticScroll();
+        element.scrollIntoView({ behavior: "smooth" });
+      }
+    };
+    document.addEventListener("click", handleClick, true);
+    return () => document.removeEventListener("click", handleClick, true);
+  }, [location.hash, location.pathname, markProgrammaticScroll]);
+}
+const RootProvider = ({ children }) => {
+  useApplyScroll();
+  return /* @__PURE__ */ jsx(PostHogProvider, { client: posthog, children });
+};
+var isObject_1;
+var hasRequiredIsObject;
+function requireIsObject() {
+  if (hasRequiredIsObject) return isObject_1;
+  hasRequiredIsObject = 1;
+  function isObject(value) {
+    var type = typeof value;
+    return value != null && (type == "object" || type == "function");
+  }
+  isObject_1 = isObject;
+  return isObject_1;
+}
+var now_1;
+var hasRequiredNow;
+function requireNow() {
+  if (hasRequiredNow) return now_1;
+  hasRequiredNow = 1;
+  var root = require_root();
+  var now = function() {
+    return root.Date.now();
+  };
+  now_1 = now;
+  return now_1;
+}
+var _trimmedEndIndex;
+var hasRequired_trimmedEndIndex;
+function require_trimmedEndIndex() {
+  if (hasRequired_trimmedEndIndex) return _trimmedEndIndex;
+  hasRequired_trimmedEndIndex = 1;
+  var reWhitespace = /\s/;
+  function trimmedEndIndex(string) {
+    var index = string.length;
+    while (index-- && reWhitespace.test(string.charAt(index))) {
+    }
+    return index;
+  }
+  _trimmedEndIndex = trimmedEndIndex;
+  return _trimmedEndIndex;
+}
+var _baseTrim;
+var hasRequired_baseTrim;
+function require_baseTrim() {
+  if (hasRequired_baseTrim) return _baseTrim;
+  hasRequired_baseTrim = 1;
+  var trimmedEndIndex = require_trimmedEndIndex();
+  var reTrimStart = /^\s+/;
+  function baseTrim(string) {
+    return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+  }
+  _baseTrim = baseTrim;
+  return _baseTrim;
+}
+var toNumber_1;
+var hasRequiredToNumber;
+function requireToNumber() {
+  if (hasRequiredToNumber) return toNumber_1;
+  hasRequiredToNumber = 1;
+  var baseTrim = require_baseTrim(), isObject = requireIsObject(), isSymbol = requireIsSymbol();
+  var NAN = 0 / 0;
+  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+  var reIsBinary = /^0b[01]+$/i;
+  var reIsOctal = /^0o[0-7]+$/i;
+  var freeParseInt = parseInt;
+  function toNumber(value) {
+    if (typeof value == "number") {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return NAN;
+    }
+    if (isObject(value)) {
+      var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+      value = isObject(other) ? other + "" : other;
+    }
+    if (typeof value != "string") {
+      return value === 0 ? value : +value;
+    }
+    value = baseTrim(value);
+    var isBinary = reIsBinary.test(value);
+    return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+  }
+  toNumber_1 = toNumber;
+  return toNumber_1;
+}
+var debounce_1;
+var hasRequiredDebounce;
+function requireDebounce() {
+  if (hasRequiredDebounce) return debounce_1;
+  hasRequiredDebounce = 1;
+  var isObject = requireIsObject(), now = requireNow(), toNumber = requireToNumber();
+  var FUNC_ERROR_TEXT = "Expected a function";
+  var nativeMax = Math.max, nativeMin = Math.min;
+  function debounce(func, wait, options) {
+    var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+    if (typeof func != "function") {
+      throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    wait = toNumber(wait) || 0;
+    if (isObject(options)) {
+      leading = !!options.leading;
+      maxing = "maxWait" in options;
+      maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+      trailing = "trailing" in options ? !!options.trailing : trailing;
+    }
+    function invokeFunc(time) {
+      var args = lastArgs, thisArg = lastThis;
+      lastArgs = lastThis = void 0;
+      lastInvokeTime = time;
+      result = func.apply(thisArg, args);
+      return result;
+    }
+    function leadingEdge(time) {
+      lastInvokeTime = time;
+      timerId = setTimeout(timerExpired, wait);
+      return leading ? invokeFunc(time) : result;
+    }
+    function remainingWait(time) {
+      var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+      return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+    }
+    function shouldInvoke(time) {
+      var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+      return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+    }
+    function timerExpired() {
+      var time = now();
+      if (shouldInvoke(time)) {
+        return trailingEdge(time);
+      }
+      timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+    function trailingEdge(time) {
+      timerId = void 0;
+      if (trailing && lastArgs) {
+        return invokeFunc(time);
+      }
+      lastArgs = lastThis = void 0;
+      return result;
+    }
+    function cancel() {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      lastInvokeTime = 0;
+      lastArgs = lastCallTime = lastThis = timerId = void 0;
+    }
+    function flush() {
+      return timerId === void 0 ? result : trailingEdge(now());
+    }
+    function debounced() {
+      var time = now(), isInvoking = shouldInvoke(time);
+      lastArgs = arguments;
+      lastThis = this;
+      lastCallTime = time;
+      if (isInvoking) {
+        if (timerId === void 0) {
+          return leadingEdge(lastCallTime);
+        }
+        if (maxing) {
+          clearTimeout(timerId);
+          timerId = setTimeout(timerExpired, wait);
+          return invokeFunc(lastCallTime);
+        }
+      }
+      if (timerId === void 0) {
+        timerId = setTimeout(timerExpired, wait);
+      }
+      return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+  }
+  debounce_1 = debounce;
+  return debounce_1;
+}
+var throttle_1;
+var hasRequiredThrottle;
+function requireThrottle() {
+  if (hasRequiredThrottle) return throttle_1;
+  hasRequiredThrottle = 1;
+  var debounce = requireDebounce(), isObject = requireIsObject();
+  var FUNC_ERROR_TEXT = "Expected a function";
+  function throttle2(func, wait, options) {
+    var leading = true, trailing = true;
+    if (typeof func != "function") {
+      throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    if (isObject(options)) {
+      leading = "leading" in options ? !!options.leading : leading;
+      trailing = "trailing" in options ? !!options.trailing : trailing;
+    }
+    return debounce(func, wait, {
+      "leading": leading,
+      "maxWait": wait,
+      "trailing": trailing
+    });
+  }
+  throttle_1 = throttle2;
+  return throttle_1;
+}
+var throttleExports = requireThrottle();
+const _throttle = /* @__PURE__ */ getDefaultExportFromCjs(throttleExports);
+var getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function combineComparators(comparatorA, comparatorB) {
+  return function isEqual(a, b, state) {
+    return comparatorA(a, b, state) && comparatorB(a, b, state);
+  };
+}
+function createIsCircular(areItemsEqual) {
+  return function isCircular(a, b, state) {
+    if (!a || !b || typeof a !== "object" || typeof b !== "object") {
+      return areItemsEqual(a, b, state);
+    }
+    var cache = state.cache;
+    var cachedA = cache.get(a);
+    var cachedB = cache.get(b);
+    if (cachedA && cachedB) {
+      return cachedA === b && cachedB === a;
+    }
+    cache.set(a, b);
+    cache.set(b, a);
+    var result = areItemsEqual(a, b, state);
+    cache.delete(a);
+    cache.delete(b);
+    return result;
+  };
+}
+function getStrictProperties(object) {
+  return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+}
+var hasOwn = Object.hasOwn || (function(object, property) {
+  return hasOwnProperty.call(object, property);
+});
+function sameValueZeroEqual(a, b) {
+  return a === b || !a && !b && a !== a && b !== b;
+}
+var PREACT_VNODE = "__v";
+var PREACT_OWNER = "__o";
+var REACT_OWNER = "_owner";
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, keys = Object.keys;
+function areArraysEqual(a, b, state) {
+  var index = a.length;
+  if (b.length !== index) {
+    return false;
+  }
+  while (index-- > 0) {
+    if (!state.equals(a[index], b[index], index, index, a, b, state)) {
+      return false;
+    }
+  }
+  return true;
+}
+function areDatesEqual(a, b) {
+  return sameValueZeroEqual(a.getTime(), b.getTime());
+}
+function areErrorsEqual(a, b) {
+  return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
+}
+function areFunctionsEqual(a, b) {
+  return a === b;
+}
+function areMapsEqual(a, b, state) {
+  var size = a.size;
+  if (size !== b.size) {
+    return false;
+  }
+  if (!size) {
+    return true;
+  }
+  var matchedIndices = new Array(size);
+  var aIterable = a.entries();
+  var aResult;
+  var bResult;
+  var index = 0;
+  while (aResult = aIterable.next()) {
+    if (aResult.done) {
+      break;
+    }
+    var bIterable = b.entries();
+    var hasMatch = false;
+    var matchIndex = 0;
+    while (bResult = bIterable.next()) {
+      if (bResult.done) {
+        break;
+      }
+      if (matchedIndices[matchIndex]) {
+        matchIndex++;
+        continue;
+      }
+      var aEntry = aResult.value;
+      var bEntry = bResult.value;
+      if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
+        hasMatch = matchedIndices[matchIndex] = true;
+        break;
+      }
+      matchIndex++;
+    }
+    if (!hasMatch) {
+      return false;
+    }
+    index++;
+  }
+  return true;
+}
+var areNumbersEqual = sameValueZeroEqual;
+function areObjectsEqual(a, b, state) {
+  var properties = keys(a);
+  var index = properties.length;
+  if (keys(b).length !== index) {
+    return false;
+  }
+  while (index-- > 0) {
+    if (!isPropertyEqual(a, b, state, properties[index])) {
+      return false;
+    }
+  }
+  return true;
+}
+function areObjectsEqualStrict(a, b, state) {
+  var properties = getStrictProperties(a);
+  var index = properties.length;
+  if (getStrictProperties(b).length !== index) {
+    return false;
+  }
+  var property;
+  var descriptorA;
+  var descriptorB;
+  while (index-- > 0) {
+    property = properties[index];
+    if (!isPropertyEqual(a, b, state, property)) {
+      return false;
+    }
+    descriptorA = getOwnPropertyDescriptor(a, property);
+    descriptorB = getOwnPropertyDescriptor(b, property);
+    if ((descriptorA || descriptorB) && (!descriptorA || !descriptorB || descriptorA.configurable !== descriptorB.configurable || descriptorA.enumerable !== descriptorB.enumerable || descriptorA.writable !== descriptorB.writable)) {
+      return false;
+    }
+  }
+  return true;
+}
+function arePrimitiveWrappersEqual(a, b) {
+  return sameValueZeroEqual(a.valueOf(), b.valueOf());
+}
+function areRegExpsEqual(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+function areSetsEqual(a, b, state) {
+  var size = a.size;
+  if (size !== b.size) {
+    return false;
+  }
+  if (!size) {
+    return true;
+  }
+  var matchedIndices = new Array(size);
+  var aIterable = a.values();
+  var aResult;
+  var bResult;
+  while (aResult = aIterable.next()) {
+    if (aResult.done) {
+      break;
+    }
+    var bIterable = b.values();
+    var hasMatch = false;
+    var matchIndex = 0;
+    while (bResult = bIterable.next()) {
+      if (bResult.done) {
+        break;
+      }
+      if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+        hasMatch = matchedIndices[matchIndex] = true;
+        break;
+      }
+      matchIndex++;
+    }
+    if (!hasMatch) {
+      return false;
+    }
+  }
+  return true;
+}
+function areTypedArraysEqual(a, b) {
+  var index = a.length;
+  if (b.length !== index) {
+    return false;
+  }
+  while (index-- > 0) {
+    if (a[index] !== b[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function areUrlsEqual(a, b) {
+  return a.hostname === b.hostname && a.pathname === b.pathname && a.protocol === b.protocol && a.port === b.port && a.hash === b.hash && a.username === b.username && a.password === b.password;
+}
+function isPropertyEqual(a, b, state, property) {
+  if ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE) && (a.$$typeof || b.$$typeof)) {
+    return true;
+  }
+  return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
+}
+var ARGUMENTS_TAG = "[object Arguments]";
+var BOOLEAN_TAG = "[object Boolean]";
+var DATE_TAG = "[object Date]";
+var ERROR_TAG = "[object Error]";
+var MAP_TAG = "[object Map]";
+var NUMBER_TAG = "[object Number]";
+var OBJECT_TAG = "[object Object]";
+var REG_EXP_TAG = "[object RegExp]";
+var SET_TAG = "[object Set]";
+var STRING_TAG = "[object String]";
+var URL_TAG = "[object URL]";
+var isArray = Array.isArray;
+var isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView ? ArrayBuffer.isView : null;
+var assign = Object.assign;
+var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+function createEqualityComparator(_a) {
+  var areArraysEqual2 = _a.areArraysEqual, areDatesEqual2 = _a.areDatesEqual, areErrorsEqual2 = _a.areErrorsEqual, areFunctionsEqual2 = _a.areFunctionsEqual, areMapsEqual2 = _a.areMapsEqual, areNumbersEqual2 = _a.areNumbersEqual, areObjectsEqual2 = _a.areObjectsEqual, arePrimitiveWrappersEqual2 = _a.arePrimitiveWrappersEqual, areRegExpsEqual2 = _a.areRegExpsEqual, areSetsEqual2 = _a.areSetsEqual, areTypedArraysEqual2 = _a.areTypedArraysEqual, areUrlsEqual2 = _a.areUrlsEqual;
+  return function comparator(a, b, state) {
+    if (a === b) {
+      return true;
+    }
+    if (a == null || b == null) {
+      return false;
+    }
+    var type = typeof a;
+    if (type !== typeof b) {
+      return false;
+    }
+    if (type !== "object") {
+      if (type === "number") {
+        return areNumbersEqual2(a, b, state);
+      }
+      if (type === "function") {
+        return areFunctionsEqual2(a, b, state);
+      }
+      return false;
+    }
+    var constructor = a.constructor;
+    if (constructor !== b.constructor) {
+      return false;
+    }
+    if (constructor === Object) {
+      return areObjectsEqual2(a, b, state);
+    }
+    if (isArray(a)) {
+      return areArraysEqual2(a, b, state);
+    }
+    if (isTypedArray != null && isTypedArray(a)) {
+      return areTypedArraysEqual2(a, b, state);
+    }
+    if (constructor === Date) {
+      return areDatesEqual2(a, b, state);
+    }
+    if (constructor === RegExp) {
+      return areRegExpsEqual2(a, b, state);
+    }
+    if (constructor === Map) {
+      return areMapsEqual2(a, b, state);
+    }
+    if (constructor === Set) {
+      return areSetsEqual2(a, b, state);
+    }
+    var tag = getTag(a);
+    if (tag === DATE_TAG) {
+      return areDatesEqual2(a, b, state);
+    }
+    if (tag === REG_EXP_TAG) {
+      return areRegExpsEqual2(a, b, state);
+    }
+    if (tag === MAP_TAG) {
+      return areMapsEqual2(a, b, state);
+    }
+    if (tag === SET_TAG) {
+      return areSetsEqual2(a, b, state);
+    }
+    if (tag === OBJECT_TAG) {
+      return typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual2(a, b, state);
+    }
+    if (tag === URL_TAG) {
+      return areUrlsEqual2(a, b, state);
+    }
+    if (tag === ERROR_TAG) {
+      return areErrorsEqual2(a, b, state);
+    }
+    if (tag === ARGUMENTS_TAG) {
+      return areObjectsEqual2(a, b, state);
+    }
+    if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
+      return arePrimitiveWrappersEqual2(a, b, state);
+    }
+    return false;
+  };
+}
+function createEqualityComparatorConfig(_a) {
+  var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;
+  var config = {
+    areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+    areDatesEqual,
+    areErrorsEqual,
+    areFunctionsEqual,
+    areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
+    areNumbersEqual,
+    areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
+    arePrimitiveWrappersEqual,
+    areRegExpsEqual,
+    areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
+    areTypedArraysEqual: strict ? areObjectsEqualStrict : areTypedArraysEqual,
+    areUrlsEqual
+  };
+  if (createCustomConfig) {
+    config = assign({}, config, createCustomConfig(config));
+  }
+  if (circular) {
+    var areArraysEqual$1 = createIsCircular(config.areArraysEqual);
+    var areMapsEqual$1 = createIsCircular(config.areMapsEqual);
+    var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);
+    var areSetsEqual$1 = createIsCircular(config.areSetsEqual);
+    config = assign({}, config, {
+      areArraysEqual: areArraysEqual$1,
+      areMapsEqual: areMapsEqual$1,
+      areObjectsEqual: areObjectsEqual$1,
+      areSetsEqual: areSetsEqual$1
+    });
+  }
+  return config;
+}
+function createInternalEqualityComparator(compare) {
+  return function(a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
+    return compare(a, b, state);
+  };
+}
+function createIsEqual(_a) {
+  var circular = _a.circular, comparator = _a.comparator, createState = _a.createState, equals = _a.equals, strict = _a.strict;
+  if (createState) {
+    return function isEqual(a, b) {
+      var _a2 = createState(), _b = _a2.cache, cache = _b === void 0 ? circular ? /* @__PURE__ */ new WeakMap() : void 0 : _b, meta = _a2.meta;
+      return comparator(a, b, {
+        cache,
+        equals,
+        meta,
+        strict
+      });
+    };
+  }
+  if (circular) {
+    return function isEqual(a, b) {
+      return comparator(a, b, {
+        cache: /* @__PURE__ */ new WeakMap(),
+        equals,
+        meta: void 0,
+        strict
+      });
+    };
+  }
+  var state = {
+    cache: void 0,
+    equals,
+    meta: void 0,
+    strict
+  };
+  return function isEqual(a, b) {
+    return comparator(a, b, state);
+  };
+}
+var deepEqual = createCustomEqual();
+createCustomEqual({ strict: true });
+createCustomEqual({ circular: true });
+createCustomEqual({
+  circular: true,
+  strict: true
+});
+createCustomEqual({
+  createInternalComparator: function() {
+    return sameValueZeroEqual;
+  }
+});
+createCustomEqual({
+  strict: true,
+  createInternalComparator: function() {
+    return sameValueZeroEqual;
+  }
+});
+createCustomEqual({
+  circular: true,
+  createInternalComparator: function() {
+    return sameValueZeroEqual;
+  }
+});
+createCustomEqual({
+  circular: true,
+  createInternalComparator: function() {
+    return sameValueZeroEqual;
+  },
+  strict: true
+});
+function createCustomEqual(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _a = options.circular, circular = _a === void 0 ? false : _a, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _b = options.strict, strict = _b === void 0 ? false : _b;
+  var config = createEqualityComparatorConfig(options);
+  var comparator = createEqualityComparator(config);
+  var equals = createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator);
+  return createIsEqual({ circular, comparator, createState, equals, strict });
+}
+const useMeasureHook = useMeasure.default ?? useMeasure;
+const DEFAULT_THROTTLE_TIME = 16;
+const useThrottledMeasure = (throttleDuration = DEFAULT_THROTTLE_TIME) => {
+  const hasInitialMeasure = useRef(false);
+  const [ref, measuredRect] = useMeasureHook();
+  const [rect, setRect] = useState(() => {
+    return { x: 0, y: 0, width: 0, height: 0, top: 0, left: 0, bottom: 0, right: 0 };
+  });
+  const throttledSetRect = useCallback(
+    _throttle(
+      (newRect) => {
+        setRect((current) => {
+          return deepEqual(current, newRect) ? current : newRect;
+        });
+      },
+      throttleDuration,
+      { leading: true, trailing: true }
+    ),
+    [throttleDuration]
+  );
+  useEffect(() => {
+    if (measuredRect.width > 0 && !hasInitialMeasure.current) {
+      hasInitialMeasure.current = true;
+      setRect((current) => {
+        return deepEqual(current, measuredRect) ? current : measuredRect;
+      });
+      return;
+    }
+    throttledSetRect(measuredRect);
+    return () => {
+      throttledSetRect.cancel();
+    };
+  }, [measuredRect, throttledSetRect]);
+  return [ref, rect];
+};
+const emptyUnsubscribe = () => {
+};
+const useMediaQuery = (query) => {
+  const isServer = typeof window === "undefined";
+  const subscribe = (callback) => {
+    if (isServer) return emptyUnsubscribe;
+    const mql = window.matchMedia(query);
+    if (mql.addEventListener) {
+      mql.addEventListener("change", callback);
+      return () => mql.removeEventListener("change", callback);
+    }
+    mql.addListener(callback);
+    return () => mql.removeListener(callback);
+  };
+  const getSnapshot = () => {
+    if (isServer) return false;
+    return window.matchMedia(query).matches;
+  };
+  return useSyncExternalStore(subscribe, getSnapshot, () => false);
+};
+export {
+  RootProvider,
+  apiClient,
+  getFeatureFlag,
+  initApiClient,
+  initWithRoutes,
+  useMediaQuery,
+  useThrottledMeasure
+};