@golocalinteractive/golocal-cloud-wrapper 1.0.53 → 1.0.56

package/dist/golocal-cloud-wrapper.es87.js

@@ -0,0 +1,468 @@
+import React__default, { useContext, createContext, useMemo, useRef, useEffect, useLayoutEffect, createElement } from "react";
+import { FOCUS_EVENT, RECONNECT_EVENT, MUTATE_EVENT } from "./golocal-cloud-wrapper.es88.js";
+import { dequal } from "./golocal-cloud-wrapper.es142.js";
+const SWRGlobalState = /* @__PURE__ */ new WeakMap();
+const noop = () => {
+};
+const UNDEFINED = (
+  /*#__NOINLINE__*/
+  noop()
+);
+const OBJECT = Object;
+const isUndefined = (v) => v === UNDEFINED;
+const isFunction = (v) => typeof v == "function";
+const mergeObjects = (a, b) => ({
+  ...a,
+  ...b
+});
+const isPromiseLike = (x) => isFunction(x.then);
+const EMPTY_CACHE = {};
+const INITIAL_CACHE = {};
+const STR_UNDEFINED = "undefined";
+const isWindowDefined = typeof window != STR_UNDEFINED;
+const isDocumentDefined = typeof document != STR_UNDEFINED;
+const isLegacyDeno = isWindowDefined && "Deno" in window;
+const hasRequestAnimationFrame = () => isWindowDefined && typeof window["requestAnimationFrame"] != STR_UNDEFINED;
+const createCacheHelper = (cache2, key) => {
+  const state = SWRGlobalState.get(cache2);
+  return [
+    // Getter
+    () => !isUndefined(key) && cache2.get(key) || EMPTY_CACHE,
+    // Setter
+    (info) => {
+      if (!isUndefined(key)) {
+        const prev = cache2.get(key);
+        if (!(key in INITIAL_CACHE)) {
+          INITIAL_CACHE[key] = prev;
+        }
+        state[5](key, mergeObjects(prev, info), prev || EMPTY_CACHE);
+      }
+    },
+    // Subscriber
+    state[6],
+    // Get server cache snapshot
+    () => {
+      if (!isUndefined(key)) {
+        if (key in INITIAL_CACHE) return INITIAL_CACHE[key];
+      }
+      return !isUndefined(key) && cache2.get(key) || EMPTY_CACHE;
+    }
+  ];
+};
+let online = true;
+const isOnline = () => online;
+const [onWindowEvent, offWindowEvent] = isWindowDefined && window.addEventListener ? [
+  window.addEventListener.bind(window),
+  window.removeEventListener.bind(window)
+] : [
+  noop,
+  noop
+];
+const isVisible = () => {
+  const visibilityState = isDocumentDefined && document.visibilityState;
+  return isUndefined(visibilityState) || visibilityState !== "hidden";
+};
+const initFocus = (callback) => {
+  if (isDocumentDefined) {
+    document.addEventListener("visibilitychange", callback);
+  }
+  onWindowEvent("focus", callback);
+  return () => {
+    if (isDocumentDefined) {
+      document.removeEventListener("visibilitychange", callback);
+    }
+    offWindowEvent("focus", callback);
+  };
+};
+const initReconnect = (callback) => {
+  const onOnline = () => {
+    online = true;
+    callback();
+  };
+  const onOffline = () => {
+    online = false;
+  };
+  onWindowEvent("online", onOnline);
+  onWindowEvent("offline", onOffline);
+  return () => {
+    offWindowEvent("online", onOnline);
+    offWindowEvent("offline", onOffline);
+  };
+};
+const preset = {
+  isOnline,
+  isVisible
+};
+const defaultConfigOptions = {
+  initFocus,
+  initReconnect
+};
+const IS_REACT_LEGACY = !React__default.useId;
+const IS_SERVER = !isWindowDefined || isLegacyDeno;
+const rAF = (f) => hasRequestAnimationFrame() ? window["requestAnimationFrame"](f) : setTimeout(f, 1);
+const useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;
+const navigatorConnection = typeof navigator !== "undefined" && navigator.connection;
+const slowConnection = !IS_SERVER && navigatorConnection && ([
+  "slow-2g",
+  "2g"
+].includes(navigatorConnection.effectiveType) || navigatorConnection.saveData);
+const table = /* @__PURE__ */ new WeakMap();
+const isObjectType = (value, type) => OBJECT.prototype.toString.call(value) === `[object ${type}]`;
+let counter = 0;
+const stableHash = (arg) => {
+  const type = typeof arg;
+  const isDate = isObjectType(arg, "Date");
+  const isRegex = isObjectType(arg, "RegExp");
+  const isPlainObject = isObjectType(arg, "Object");
+  let result;
+  let index;
+  if (OBJECT(arg) === arg && !isDate && !isRegex) {
+    result = table.get(arg);
+    if (result) return result;
+    result = ++counter + "~";
+    table.set(arg, result);
+    if (Array.isArray(arg)) {
+      result = "@";
+      for (index = 0; index < arg.length; index++) {
+        result += stableHash(arg[index]) + ",";
+      }
+      table.set(arg, result);
+    }
+    if (isPlainObject) {
+      result = "#";
+      const keys = OBJECT.keys(arg).sort();
+      while (!isUndefined(index = keys.pop())) {
+        if (!isUndefined(arg[index])) {
+          result += index + ":" + stableHash(arg[index]) + ",";
+        }
+      }
+      table.set(arg, result);
+    }
+  } else {
+    result = isDate ? arg.toJSON() : type == "symbol" ? arg.toString() : type == "string" ? JSON.stringify(arg) : "" + arg;
+  }
+  return result;
+};
+const serialize = (key) => {
+  if (isFunction(key)) {
+    try {
+      key = key();
+    } catch (err) {
+      key = "";
+    }
+  }
+  const args = key;
+  key = typeof key == "string" ? key : (Array.isArray(key) ? key.length : key) ? stableHash(key) : "";
+  return [
+    key,
+    args
+  ];
+};
+let __timestamp = 0;
+const getTimestamp = () => ++__timestamp;
+async function internalMutate(...args) {
+  const [cache2, _key, _data, _opts] = args;
+  const options = mergeObjects({
+    populateCache: true,
+    throwOnError: true
+  }, typeof _opts === "boolean" ? {
+    revalidate: _opts
+  } : _opts || {});
+  let populateCache = options.populateCache;
+  const rollbackOnErrorOption = options.rollbackOnError;
+  let optimisticData = options.optimisticData;
+  const rollbackOnError = (error) => {
+    return typeof rollbackOnErrorOption === "function" ? rollbackOnErrorOption(error) : rollbackOnErrorOption !== false;
+  };
+  const throwOnError = options.throwOnError;
+  if (isFunction(_key)) {
+    const keyFilter = _key;
+    const matchedKeys = [];
+    const it = cache2.keys();
+    for (const key of it) {
+      if (
+        // Skip the special useSWRInfinite and useSWRSubscription keys.
+        !/^\$(inf|sub)\$/.test(key) && keyFilter(cache2.get(key)._k)
+      ) {
+        matchedKeys.push(key);
+      }
+    }
+    return Promise.all(matchedKeys.map(mutateByKey));
+  }
+  return mutateByKey(_key);
+  async function mutateByKey(_k) {
+    const [key] = serialize(_k);
+    if (!key) return;
+    const [get, set] = createCacheHelper(cache2, key);
+    const [EVENT_REVALIDATORS, MUTATION, FETCH, PRELOAD] = SWRGlobalState.get(cache2);
+    const startRevalidate = () => {
+      const revalidators = EVENT_REVALIDATORS[key];
+      const revalidate = isFunction(options.revalidate) ? options.revalidate(get().data, _k) : options.revalidate !== false;
+      if (revalidate) {
+        delete FETCH[key];
+        delete PRELOAD[key];
+        if (revalidators && revalidators[0]) {
+          return revalidators[0](MUTATE_EVENT).then(() => get().data);
+        }
+      }
+      return get().data;
+    };
+    if (args.length < 3) {
+      return startRevalidate();
+    }
+    let data = _data;
+    let error;
+    const beforeMutationTs = getTimestamp();
+    MUTATION[key] = [
+      beforeMutationTs,
+      0
+    ];
+    const hasOptimisticData = !isUndefined(optimisticData);
+    const state = get();
+    const displayedData = state.data;
+    const currentData = state._c;
+    const committedData = isUndefined(currentData) ? displayedData : currentData;
+    if (hasOptimisticData) {
+      optimisticData = isFunction(optimisticData) ? optimisticData(committedData, displayedData) : optimisticData;
+      set({
+        data: optimisticData,
+        _c: committedData
+      });
+    }
+    if (isFunction(data)) {
+      try {
+        data = data(committedData);
+      } catch (err) {
+        error = err;
+      }
+    }
+    if (data && isPromiseLike(data)) {
+      data = await data.catch((err) => {
+        error = err;
+      });
+      if (beforeMutationTs !== MUTATION[key][0]) {
+        if (error) throw error;
+        return data;
+      } else if (error && hasOptimisticData && rollbackOnError(error)) {
+        populateCache = true;
+        set({
+          data: committedData,
+          _c: UNDEFINED
+        });
+      }
+    }
+    if (populateCache) {
+      if (!error) {
+        if (isFunction(populateCache)) {
+          const populateCachedData = populateCache(data, committedData);
+          set({
+            data: populateCachedData,
+            error: UNDEFINED,
+            _c: UNDEFINED
+          });
+        } else {
+          set({
+            data,
+            error: UNDEFINED,
+            _c: UNDEFINED
+          });
+        }
+      }
+    }
+    MUTATION[key][1] = getTimestamp();
+    Promise.resolve(startRevalidate()).then(() => {
+      set({
+        _c: UNDEFINED
+      });
+    });
+    if (error) {
+      if (throwOnError) throw error;
+      return;
+    }
+    return data;
+  }
+}
+const revalidateAllKeys = (revalidators, type) => {
+  for (const key in revalidators) {
+    if (revalidators[key][0]) revalidators[key][0](type);
+  }
+};
+const initCache = (provider, options) => {
+  if (!SWRGlobalState.has(provider)) {
+    const opts = mergeObjects(defaultConfigOptions, options);
+    const EVENT_REVALIDATORS = /* @__PURE__ */ Object.create(null);
+    const mutate2 = internalMutate.bind(UNDEFINED, provider);
+    let unmount = noop;
+    const subscriptions = /* @__PURE__ */ Object.create(null);
+    const subscribe = (key, callback) => {
+      const subs = subscriptions[key] || [];
+      subscriptions[key] = subs;
+      subs.push(callback);
+      return () => subs.splice(subs.indexOf(callback), 1);
+    };
+    const setter = (key, value, prev) => {
+      provider.set(key, value);
+      const subs = subscriptions[key];
+      if (subs) {
+        for (const fn of subs) {
+          fn(value, prev);
+        }
+      }
+    };
+    const initProvider = () => {
+      if (!SWRGlobalState.has(provider)) {
+        SWRGlobalState.set(provider, [
+          EVENT_REVALIDATORS,
+          /* @__PURE__ */ Object.create(null),
+          /* @__PURE__ */ Object.create(null),
+          /* @__PURE__ */ Object.create(null),
+          mutate2,
+          setter,
+          subscribe
+        ]);
+        if (!IS_SERVER) {
+          const releaseFocus = opts.initFocus(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, FOCUS_EVENT)));
+          const releaseReconnect = opts.initReconnect(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, RECONNECT_EVENT)));
+          unmount = () => {
+            releaseFocus && releaseFocus();
+            releaseReconnect && releaseReconnect();
+            SWRGlobalState.delete(provider);
+          };
+        }
+      }
+    };
+    initProvider();
+    return [
+      provider,
+      mutate2,
+      initProvider,
+      unmount
+    ];
+  }
+  return [
+    provider,
+    SWRGlobalState.get(provider)[4]
+  ];
+};
+const onErrorRetry = (_, __, config, revalidate, opts) => {
+  const maxRetryCount = config.errorRetryCount;
+  const currentRetryCount = opts.retryCount;
+  const timeout = ~~((Math.random() + 0.5) * (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;
+  if (!isUndefined(maxRetryCount) && currentRetryCount > maxRetryCount) {
+    return;
+  }
+  setTimeout(revalidate, timeout, opts);
+};
+const compare = dequal;
+const [cache, mutate] = initCache(/* @__PURE__ */ new Map());
+const defaultConfig = mergeObjects(
+  {
+    // events
+    onLoadingSlow: noop,
+    onSuccess: noop,
+    onError: noop,
+    onErrorRetry,
+    onDiscarded: noop,
+    // switches
+    revalidateOnFocus: true,
+    revalidateOnReconnect: true,
+    revalidateIfStale: true,
+    shouldRetryOnError: true,
+    // timeouts
+    errorRetryInterval: slowConnection ? 1e4 : 5e3,
+    focusThrottleInterval: 5 * 1e3,
+    dedupingInterval: 2 * 1e3,
+    loadingTimeout: slowConnection ? 5e3 : 3e3,
+    // providers
+    compare,
+    isPaused: () => false,
+    cache,
+    mutate,
+    fallback: {}
+  },
+  // use web preset by default
+  preset
+);
+const mergeConfigs = (a, b) => {
+  const v = mergeObjects(a, b);
+  if (b) {
+    const { use: u1, fallback: f1 } = a;
+    const { use: u2, fallback: f2 } = b;
+    if (u1 && u2) {
+      v.use = u1.concat(u2);
+    }
+    if (f1 && f2) {
+      v.fallback = mergeObjects(f1, f2);
+    }
+  }
+  return v;
+};
+const SWRConfigContext = createContext({});
+const SWRConfig = (props) => {
+  const { value } = props;
+  const parentConfig = useContext(SWRConfigContext);
+  const isFunctionalConfig = isFunction(value);
+  const config = useMemo(() => isFunctionalConfig ? value(parentConfig) : value, [
+    isFunctionalConfig,
+    parentConfig,
+    value
+  ]);
+  const extendedConfig = useMemo(() => isFunctionalConfig ? config : mergeConfigs(parentConfig, config), [
+    isFunctionalConfig,
+    parentConfig,
+    config
+  ]);
+  const provider = config && config.provider;
+  const cacheContextRef = useRef(UNDEFINED);
+  if (provider && !cacheContextRef.current) {
+    cacheContextRef.current = initCache(provider(extendedConfig.cache || cache), config);
+  }
+  const cacheContext = cacheContextRef.current;
+  if (cacheContext) {
+    extendedConfig.cache = cacheContext[0];
+    extendedConfig.mutate = cacheContext[1];
+  }
+  useIsomorphicLayoutEffect(() => {
+    if (cacheContext) {
+      cacheContext[2] && cacheContext[2]();
+      return cacheContext[3];
+    }
+  }, []);
+  return createElement(SWRConfigContext.Provider, mergeObjects(props, {
+    value: extendedConfig
+  }));
+};
+export {
+  noop as A,
+  isPromiseLike as B,
+  IS_REACT_LEGACY as I,
+  OBJECT as O,
+  SWRConfigContext as S,
+  UNDEFINED as U,
+  isFunction as a,
+  SWRGlobalState as b,
+  cache as c,
+  defaultConfig as d,
+  isUndefined as e,
+  mergeConfigs as f,
+  SWRConfig as g,
+  initCache as h,
+  isWindowDefined as i,
+  mutate as j,
+  compare as k,
+  stableHash as l,
+  mergeObjects as m,
+  internalMutate as n,
+  getTimestamp as o,
+  preset as p,
+  defaultConfigOptions as q,
+  IS_SERVER as r,
+  serialize as s,
+  rAF as t,
+  useIsomorphicLayoutEffect as u,
+  slowConnection as v,
+  isDocumentDefined as w,
+  isLegacyDeno as x,
+  hasRequestAnimationFrame as y,
+  createCacheHelper as z
+};

package/dist/golocal-cloud-wrapper.es88.js

@@ -0,0 +1,10 @@
+const FOCUS_EVENT = 0;
+const RECONNECT_EVENT = 1;
+const MUTATE_EVENT = 2;
+const ERROR_REVALIDATE_EVENT = 3;
+export {
+  ERROR_REVALIDATE_EVENT,
+  FOCUS_EVENT,
+  MUTATE_EVENT,
+  RECONNECT_EVENT
+};

package/dist/golocal-cloud-wrapper.es89.js

@@ -0,0 +1,6 @@
+import * as React from "react";
+var useLayoutEffect2 = (globalThis == null ? void 0 : globalThis.document) ? React.useLayoutEffect : () => {
+};
+export {
+  useLayoutEffect2 as useLayoutEffect
+};

package/dist/golocal-cloud-wrapper.es9.js

@@ -0,0 +1,90 @@
+import { j as jsxRuntimeExports } from "./golocal-cloud-wrapper.es18.js";
+import { cn } from "./golocal-cloud-wrapper.es28.js";
+function Card({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      "data-slot": "card",
+      className: cn(
+        "bg-card text-card-foreground flex flex-col gap-4 rounded-xl py-6 shadow-sm",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function CardHeader({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      "data-slot": "card-header",
+      className: cn(
+        "@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-1 px-6 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function CardTitle({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      "data-slot": "card-title",
+      className: cn("leading-none font-semibold", className),
+      ...props
+    }
+  );
+}
+function CardDescription({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      "data-slot": "card-description",
+      className: cn("text-muted-foreground text-sm", className),
+      ...props
+    }
+  );
+}
+function CardAction({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      "data-slot": "card-action",
+      className: cn(
+        "col-start-2 row-span-2 row-start-1 self-start justify-self-end",
+        className
+      ),
+      ...props
+    }
+  );
+}
+function CardContent({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      "data-slot": "card-content",
+      className: cn("px-6", className),
+      ...props
+    }
+  );
+}
+function CardFooter({ className, ...props }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      "data-slot": "card-footer",
+      className: cn("flex items-center px-6 [.border-t]:pt-6", className),
+      ...props
+    }
+  );
+}
+export {
+  Card,
+  CardAction,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle
+};

package/dist/golocal-cloud-wrapper.es90.js

@@ -0,0 +1,14 @@
+import * as React from "react";
+function useCallbackRef(callback) {
+  const callbackRef = React.useRef(callback);
+  React.useEffect(() => {
+    callbackRef.current = callback;
+  });
+  return React.useMemo(() => (...args) => {
+    var _a;
+    return (_a = callbackRef.current) == null ? void 0 : _a.call(callbackRef, ...args);
+  }, []);
+}
+export {
+  useCallbackRef
+};

package/dist/golocal-cloud-wrapper.es91.js

@@ -0,0 +1,17 @@
+import * as React from "react";
+import { useCallbackRef } from "./golocal-cloud-wrapper.es90.js";
+function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis == null ? void 0 : globalThis.document) {
+  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);
+  React.useEffect(() => {
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        onEscapeKeyDown(event);
+      }
+    };
+    ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
+    return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
+  }, [onEscapeKeyDown, ownerDocument]);
+}
+export {
+  useEscapeKeydown
+};

package/dist/golocal-cloud-wrapper.es92.js

@@ -0,0 +1,70 @@
+import React__default from "react";
+import { createContextScope } from "./golocal-cloud-wrapper.es66.js";
+import { useComposedRefs } from "./golocal-cloud-wrapper.es56.js";
+import { createSlot } from "./golocal-cloud-wrapper.es26.js";
+import { j as jsxRuntimeExports } from "./golocal-cloud-wrapper.es18.js";
+function createCollection(name) {
+  const PROVIDER_NAME = name + "CollectionProvider";
+  const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);
+  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext(
+    PROVIDER_NAME,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  );
+  const CollectionProvider = (props) => {
+    const { scope, children } = props;
+    const ref = React__default.useRef(null);
+    const itemMap = React__default.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children });
+  };
+  CollectionProvider.displayName = PROVIDER_NAME;
+  const COLLECTION_SLOT_NAME = name + "CollectionSlot";
+  const CollectionSlotImpl = createSlot(COLLECTION_SLOT_NAME);
+  const CollectionSlot = React__default.forwardRef(
+    (props, forwardedRef) => {
+      const { scope, children } = props;
+      const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);
+      const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(CollectionSlotImpl, { ref: composedRefs, children });
+    }
+  );
+  CollectionSlot.displayName = COLLECTION_SLOT_NAME;
+  const ITEM_SLOT_NAME = name + "CollectionItemSlot";
+  const ITEM_DATA_ATTR = "data-radix-collection-item";
+  const CollectionItemSlotImpl = createSlot(ITEM_SLOT_NAME);
+  const CollectionItemSlot = React__default.forwardRef(
+    (props, forwardedRef) => {
+      const { scope, children, ...itemData } = props;
+      const ref = React__default.useRef(null);
+      const composedRefs = useComposedRefs(forwardedRef, ref);
+      const context = useCollectionContext(ITEM_SLOT_NAME, scope);
+      React__default.useEffect(() => {
+        context.itemMap.set(ref, { ref, ...itemData });
+        return () => void context.itemMap.delete(ref);
+      });
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children });
+    }
+  );
+  CollectionItemSlot.displayName = ITEM_SLOT_NAME;
+  function useCollection(scope) {
+    const context = useCollectionContext(name + "CollectionConsumer", scope);
+    const getItems = React__default.useCallback(() => {
+      const collectionNode = context.collectionRef.current;
+      if (!collectionNode) return [];
+      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));
+      const items = Array.from(context.itemMap.values());
+      const orderedItems = items.sort(
+        (a, b) => orderedNodes.indexOf(a.ref.current) - orderedNodes.indexOf(b.ref.current)
+      );
+      return orderedItems;
+    }, [context.collectionRef, context.itemMap]);
+    return getItems;
+  }
+  return [
+    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },
+    useCollection,
+    createCollectionScope
+  ];
+}
+export {
+  createCollection
+};

package/dist/golocal-cloud-wrapper.es93.js

@@ -0,0 +1,10 @@
+import * as React from "react";
+import "./golocal-cloud-wrapper.es18.js";
+var DirectionContext = React.createContext(void 0);
+function useDirection(localDir) {
+  const globalDir = React.useContext(DirectionContext);
+  return localDir || globalDir || "ltr";
+}
+export {
+  useDirection
+};