@golocalinteractive/golocal-cloud-wrapper 1.0.53 → 1.0.56

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

@@ -0,0 +1,139 @@
+import { hkdf } from "./golocal-cloud-wrapper.es194.js";
+import { EncryptJWT } from "./golocal-cloud-wrapper.es195.js";
+import { jwtDecrypt } from "./golocal-cloud-wrapper.es196.js";
+import { encode } from "./golocal-cloud-wrapper.es197.js";
+import { flattenedVerify } from "./golocal-cloud-wrapper.es198.js";
+const ENC = "A256GCM";
+const ALG = "dir";
+const DIGEST = "sha256";
+const BYTE_LENGTH = 32;
+const ENCRYPTION_INFO = "JWE CEK";
+async function encrypt(payload, secret, expiration, additionalHeaders) {
+  const encryptionSecret = await hkdf(DIGEST, secret, "", ENCRYPTION_INFO, BYTE_LENGTH);
+  const encryptedCookie = await new EncryptJWT(payload).setProtectedHeader({ enc: ENC, alg: ALG, ...additionalHeaders }).setExpirationTime(expiration).encrypt(encryptionSecret);
+  return encryptedCookie.toString();
+}
+async function decrypt(cookieValue, secret, options) {
+  const encryptionSecret = await hkdf(DIGEST, secret, "", ENCRYPTION_INFO, BYTE_LENGTH);
+  const cookie = await jwtDecrypt(cookieValue, encryptionSecret, {
+    ...options,
+    ...{ clockTolerance: 15 }
+  });
+  return cookie;
+}
+const signingSecret = (secret) => hkdf("sha256", secret, "", "JWS Cookie Signing", BYTE_LENGTH);
+async function verifySigned(k, v, secret) {
+  if (!v) {
+    return void 0;
+  }
+  const [value, signature] = v.split(".");
+  const flattenedJWS = {
+    protected: encode(JSON.stringify({ alg: "HS256", b64: false, crit: ["b64"] })),
+    payload: `${k}=${value}`,
+    signature
+  };
+  const key = await signingSecret(secret);
+  try {
+    await flattenedVerify(flattenedJWS, key, {
+      algorithms: ["HS256"]
+    });
+    return value;
+  } catch (e) {
+    return void 0;
+  }
+}
+const MAX_CHUNK_SIZE = 3500;
+const CHUNK_PREFIX = "__";
+const CHUNK_INDEX_REGEX = new RegExp(`${CHUNK_PREFIX}(\\d+)$`);
+const LEGACY_CHUNK_INDEX_REGEX = /\.(\d+)$/;
+const getChunkedCookieIndex = (name, isLegacyCookie) => {
+  const match = isLegacyCookie ? LEGACY_CHUNK_INDEX_REGEX.exec(name) : CHUNK_INDEX_REGEX.exec(name);
+  if (!match) {
+    return void 0;
+  }
+  return parseInt(match[1], 10);
+};
+const getAllChunkedCookies = (reqCookies, name, isLegacyCookie) => {
+  const chunkedCookieRegex = new RegExp(isLegacyCookie ? `^${name}${LEGACY_CHUNK_INDEX_REGEX.source}$` : `^${name}${CHUNK_PREFIX}\\d+$`);
+  return reqCookies.getAll().filter((cookie) => chunkedCookieRegex.test(cookie.name));
+};
+function setChunkedCookie(name, value, options, reqCookies, resCookies) {
+  const { transient, ...restOptions } = options;
+  const finalOptions = { ...restOptions };
+  if (transient) {
+    delete finalOptions.maxAge;
+  }
+  const valueBytes = new TextEncoder().encode(value).length;
+  if (valueBytes <= MAX_CHUNK_SIZE) {
+    resCookies.set(name, value, finalOptions);
+    reqCookies.set(name, value);
+    getAllChunkedCookies(reqCookies, name).forEach((cookieChunk) => {
+      resCookies.delete(cookieChunk.name);
+      reqCookies.delete(cookieChunk.name);
+    });
+    return;
+  }
+  let position = 0;
+  let chunkIndex = 0;
+  while (position < value.length) {
+    const chunk = value.slice(position, position + MAX_CHUNK_SIZE);
+    const chunkName = `${name}${CHUNK_PREFIX}${chunkIndex}`;
+    resCookies.set(chunkName, chunk, finalOptions);
+    reqCookies.set(chunkName, chunk);
+    position += MAX_CHUNK_SIZE;
+    chunkIndex++;
+  }
+  const chunks = getAllChunkedCookies(reqCookies, name);
+  const chunksToRemove = chunks.length - chunkIndex;
+  if (chunksToRemove > 0) {
+    for (let i = 0; i < chunksToRemove; i++) {
+      const chunkIndexToRemove = chunkIndex + i;
+      const chunkName = `${name}${CHUNK_PREFIX}${chunkIndexToRemove}`;
+      resCookies.delete(chunkName);
+      reqCookies.delete(chunkName);
+    }
+  }
+  resCookies.delete(name);
+  reqCookies.delete(name);
+}
+function getChunkedCookie(name, reqCookies, isLegacyCookie) {
+  const cookie = reqCookies.get(name);
+  if (cookie == null ? void 0 : cookie.value) {
+    return cookie.value;
+  }
+  const chunks = getAllChunkedCookies(reqCookies, name, isLegacyCookie).sort(
+    // Extract index from cookie name and sort numerically
+    (first, second) => {
+      return getChunkedCookieIndex(first.name, isLegacyCookie) - getChunkedCookieIndex(second.name, isLegacyCookie);
+    }
+  );
+  if (chunks.length === 0) {
+    return void 0;
+  }
+  const highestIndex = getChunkedCookieIndex(chunks[chunks.length - 1].name, isLegacyCookie);
+  if (chunks.length !== highestIndex + 1) {
+    console.warn(`Incomplete chunked cookie '${name}': Found ${chunks.length} chunks, expected ${highestIndex + 1}`);
+    return void 0;
+  }
+  return chunks.map((c) => c.value).join("");
+}
+function deleteChunkedCookie(name, reqCookies, resCookies, isLegacyCookie) {
+  resCookies.delete(name);
+  getAllChunkedCookies(reqCookies, name, isLegacyCookie).forEach((cookie) => {
+    resCookies.delete(cookie.name);
+  });
+}
+function addCacheControlHeadersForSession(res) {
+  res.headers.set("Cache-Control", "private, no-cache, no-store, must-revalidate, max-age=0");
+  res.headers.set("Pragma", "no-cache");
+  res.headers.set("Expires", "0");
+}
+export {
+  addCacheControlHeadersForSession,
+  decrypt,
+  deleteChunkedCookie,
+  encrypt,
+  getChunkedCookie,
+  setChunkedCookie,
+  verifySigned
+};

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

@@ -0,0 +1,23 @@
+const DEFAULT_ID_TOKEN_CLAIMS = [
+  "sub",
+  "name",
+  "nickname",
+  "given_name",
+  "family_name",
+  "picture",
+  "email",
+  "email_verified",
+  "org_id"
+];
+function filterDefaultIdTokenClaims(claims) {
+  return Object.keys(claims).reduce((acc, key) => {
+    if (DEFAULT_ID_TOKEN_CLAIMS.includes(key)) {
+      acc[key] = claims[key];
+    }
+    return acc;
+  }, {});
+}
+export {
+  DEFAULT_ID_TOKEN_CLAIMS,
+  filterDefaultIdTokenClaims
+};

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

@@ -0,0 +1,132 @@
+var _a, _b;
+import fetchJwks from "./golocal-cloud-wrapper.es262.js";
+import { JWKSNoMatchingKey } from "./golocal-cloud-wrapper.es240.js";
+import { createLocalJWKSet } from "./golocal-cloud-wrapper.es261.js";
+import isObject from "./golocal-cloud-wrapper.es245.js";
+function isCloudflareWorkers() {
+  return typeof WebSocketPair !== "undefined" || typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers" || typeof EdgeRuntime !== "undefined" && EdgeRuntime === "vercel";
+}
+let USER_AGENT;
+if (typeof navigator === "undefined" || !((_b = (_a = navigator.userAgent) == null ? void 0 : _a.startsWith) == null ? void 0 : _b.call(_a, "Mozilla/5.0 "))) {
+  const NAME = "jose";
+  const VERSION = "v5.10.0";
+  USER_AGENT = `${NAME}/${VERSION}`;
+}
+const jwksCache = Symbol();
+function isFreshJwksCache(input, cacheMaxAge) {
+  if (typeof input !== "object" || input === null) {
+    return false;
+  }
+  if (!("uat" in input) || typeof input.uat !== "number" || Date.now() - input.uat >= cacheMaxAge) {
+    return false;
+  }
+  if (!("jwks" in input) || !isObject(input.jwks) || !Array.isArray(input.jwks.keys) || !Array.prototype.every.call(input.jwks.keys, isObject)) {
+    return false;
+  }
+  return true;
+}
+class RemoteJWKSet {
+  constructor(url, options) {
+    if (!(url instanceof URL)) {
+      throw new TypeError("url must be an instance of URL");
+    }
+    this._url = new URL(url.href);
+    this._options = { agent: options == null ? void 0 : options.agent, headers: options == null ? void 0 : options.headers };
+    this._timeoutDuration = typeof (options == null ? void 0 : options.timeoutDuration) === "number" ? options == null ? void 0 : options.timeoutDuration : 5e3;
+    this._cooldownDuration = typeof (options == null ? void 0 : options.cooldownDuration) === "number" ? options == null ? void 0 : options.cooldownDuration : 3e4;
+    this._cacheMaxAge = typeof (options == null ? void 0 : options.cacheMaxAge) === "number" ? options == null ? void 0 : options.cacheMaxAge : 6e5;
+    if ((options == null ? void 0 : options[jwksCache]) !== void 0) {
+      this._cache = options == null ? void 0 : options[jwksCache];
+      if (isFreshJwksCache(options == null ? void 0 : options[jwksCache], this._cacheMaxAge)) {
+        this._jwksTimestamp = this._cache.uat;
+        this._local = createLocalJWKSet(this._cache.jwks);
+      }
+    }
+  }
+  coolingDown() {
+    return typeof this._jwksTimestamp === "number" ? Date.now() < this._jwksTimestamp + this._cooldownDuration : false;
+  }
+  fresh() {
+    return typeof this._jwksTimestamp === "number" ? Date.now() < this._jwksTimestamp + this._cacheMaxAge : false;
+  }
+  async getKey(protectedHeader, token) {
+    if (!this._local || !this.fresh()) {
+      await this.reload();
+    }
+    try {
+      return await this._local(protectedHeader, token);
+    } catch (err) {
+      if (err instanceof JWKSNoMatchingKey) {
+        if (this.coolingDown() === false) {
+          await this.reload();
+          return this._local(protectedHeader, token);
+        }
+      }
+      throw err;
+    }
+  }
+  async reload() {
+    if (this._pendingFetch && isCloudflareWorkers()) {
+      this._pendingFetch = void 0;
+    }
+    const headers = new Headers(this._options.headers);
+    if (USER_AGENT && !headers.has("User-Agent")) {
+      headers.set("User-Agent", USER_AGENT);
+      this._options.headers = Object.fromEntries(headers.entries());
+    }
+    this._pendingFetch || (this._pendingFetch = fetchJwks(this._url, this._timeoutDuration, this._options).then((json) => {
+      this._local = createLocalJWKSet(json);
+      if (this._cache) {
+        this._cache.uat = Date.now();
+        this._cache.jwks = json;
+      }
+      this._jwksTimestamp = Date.now();
+      this._pendingFetch = void 0;
+    }).catch((err) => {
+      this._pendingFetch = void 0;
+      throw err;
+    }));
+    await this._pendingFetch;
+  }
+}
+function createRemoteJWKSet(url, options) {
+  const set = new RemoteJWKSet(url, options);
+  const remoteJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
+  Object.defineProperties(remoteJWKSet, {
+    coolingDown: {
+      get: () => set.coolingDown(),
+      enumerable: true,
+      configurable: false
+    },
+    fresh: {
+      get: () => set.fresh(),
+      enumerable: true,
+      configurable: false
+    },
+    reload: {
+      value: () => set.reload(),
+      enumerable: true,
+      configurable: false,
+      writable: false
+    },
+    reloading: {
+      get: () => !!set._pendingFetch,
+      enumerable: true,
+      configurable: false
+    },
+    jwks: {
+      value: () => {
+        var _a2;
+        return (_a2 = set._local) == null ? void 0 : _a2.jwks();
+      },
+      enumerable: true,
+      configurable: false,
+      writable: false
+    }
+  });
+  return remoteJWKSet;
+}
+export {
+  createRemoteJWKSet,
+  jwksCache
+};

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

@@ -0,0 +1,19 @@
+import { compactVerify } from "./golocal-cloud-wrapper.es250.js";
+import jwtPayload from "./golocal-cloud-wrapper.es254.js";
+import { JWTInvalid } from "./golocal-cloud-wrapper.es240.js";
+async function jwtVerify(jwt, key, options) {
+  var _a;
+  const verified = await compactVerify(jwt, key, options);
+  if (((_a = verified.protectedHeader.crit) == null ? void 0 : _a.includes("b64")) && verified.protectedHeader.b64 === false) {
+    throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
+  }
+  const payload = jwtPayload(verified.protectedHeader, verified.payload, options);
+  const result = { payload, protectedHeader: verified.protectedHeader };
+  if (typeof key === "function") {
+    return { ...result, key: verified.key };
+  }
+  return result;
+}
+export {
+  jwtVerify
+};

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

@@ -0,0 +1,37 @@
+import { decode } from "./golocal-cloud-wrapper.es242.js";
+import { fromPKCS8 } from "./golocal-cloud-wrapper.es265.js";
+import parse from "./golocal-cloud-wrapper.es266.js";
+import { JOSENotSupported } from "./golocal-cloud-wrapper.es240.js";
+import isObject from "./golocal-cloud-wrapper.es245.js";
+async function importPKCS8(pkcs8, alg, options) {
+  if (typeof pkcs8 !== "string" || pkcs8.indexOf("-----BEGIN PRIVATE KEY-----") !== 0) {
+    throw new TypeError('"pkcs8" must be PKCS#8 formatted string');
+  }
+  return fromPKCS8(pkcs8, alg);
+}
+async function importJWK(jwk, alg) {
+  if (!isObject(jwk)) {
+    throw new TypeError("JWK must be an object");
+  }
+  alg || (alg = jwk.alg);
+  switch (jwk.kty) {
+    case "oct":
+      if (typeof jwk.k !== "string" || !jwk.k) {
+        throw new TypeError('missing "k" (Key Value) Parameter value');
+      }
+      return decode(jwk.k);
+    case "RSA":
+      if ("oth" in jwk && jwk.oth !== void 0) {
+        throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
+      }
+    case "EC":
+    case "OKP":
+      return parse({ ...jwk, alg });
+    default:
+      throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
+  }
+}
+export {
+  importJWK,
+  importPKCS8
+};

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

@@ -0,0 +1,49 @@
+const SESSION_COOKIE_NAME = "__session";
+class AbstractSessionStore {
+  constructor({
+    secret,
+    rolling = true,
+    absoluteDuration = 60 * 60 * 24 * 3,
+    // 3 days in seconds
+    inactivityDuration = 60 * 60 * 24 * 1,
+    // 1 day in seconds
+    store,
+    cookieOptions
+  }) {
+    this.secret = secret;
+    this.rolling = rolling;
+    this.absoluteDuration = absoluteDuration;
+    this.inactivityDuration = inactivityDuration;
+    this.store = store;
+    this.sessionCookieName = (cookieOptions == null ? void 0 : cookieOptions.name) ?? SESSION_COOKIE_NAME;
+    this.cookieConfig = {
+      httpOnly: true,
+      sameSite: (cookieOptions == null ? void 0 : cookieOptions.sameSite) ?? "lax",
+      secure: (cookieOptions == null ? void 0 : cookieOptions.secure) ?? false,
+      path: (cookieOptions == null ? void 0 : cookieOptions.path) ?? "/",
+      domain: cookieOptions == null ? void 0 : cookieOptions.domain,
+      transient: cookieOptions == null ? void 0 : cookieOptions.transient
+    };
+  }
+  /**
+   * epoch returns the time since unix epoch in seconds.
+   */
+  epoch() {
+    return Date.now() / 1e3 | 0;
+  }
+  /**
+   * calculateMaxAge calculates the max age of the session based on createdAt and the rolling and absolute durations.
+   */
+  calculateMaxAge(createdAt) {
+    if (!this.rolling) {
+      return this.absoluteDuration;
+    }
+    const updatedAt = this.epoch();
+    const expiresAt = Math.min(updatedAt + this.inactivityDuration, createdAt + this.absoluteDuration);
+    const maxAge = expiresAt - this.epoch();
+    return maxAge > 0 ? maxAge : 0;
+  }
+}
+export {
+  AbstractSessionStore
+};

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

@@ -0,0 +1,10 @@
+var zeroRightClassName = "right-scroll-bar-position";
+var fullWidthClassName = "width-before-scroll-bar";
+var noScrollbarsClassName = "with-scroll-bars-hidden";
+var removedBarSizeVariable = "--removed-body-scroll-bar-size";
+export {
+  fullWidthClassName,
+  noScrollbarsClassName,
+  removedBarSizeVariable,
+  zeroRightClassName
+};

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

@@ -0,0 +1,5 @@
+import { createSidecarMedium } from "./golocal-cloud-wrapper.es205.js";
+var effectCar = createSidecarMedium();
+export {
+  effectCar
+};

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

@@ -0,0 +1,17 @@
+import { j as jsxRuntimeExports } from "./golocal-cloud-wrapper.es18.js";
+import { cn } from "./golocal-cloud-wrapper.es28.js";
+function Skeleton({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      className: cn("animate-pulse rounded-md bg-muted", className),
+      ...props
+    }
+  );
+}
+export {
+  Skeleton
+};

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

@@ -0,0 +1,35 @@
+import * as React from "react";
+import { assignRef } from "./golocal-cloud-wrapper.es277.js";
+import { useCallbackRef } from "./golocal-cloud-wrapper.es278.js";
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
+var currentValues = /* @__PURE__ */ new WeakMap();
+function useMergeRefs(refs, defaultValue) {
+  var callbackRef = useCallbackRef(null, function(newValue) {
+    return refs.forEach(function(ref) {
+      return assignRef(ref, newValue);
+    });
+  });
+  useIsomorphicLayoutEffect(function() {
+    var oldValue = currentValues.get(callbackRef);
+    if (oldValue) {
+      var prevRefs_1 = new Set(oldValue);
+      var nextRefs_1 = new Set(refs);
+      var current_1 = callbackRef.current;
+      prevRefs_1.forEach(function(ref) {
+        if (!nextRefs_1.has(ref)) {
+          assignRef(ref, null);
+        }
+      });
+      nextRefs_1.forEach(function(ref) {
+        if (!prevRefs_1.has(ref)) {
+          assignRef(ref, current_1);
+        }
+      });
+    }
+    currentValues.set(callbackRef, refs);
+  }, [refs]);
+  return callbackRef;
+}
+export {
+  useMergeRefs
+};

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

@@ -0,0 +1,174 @@
+import { __spreadArray } from "./golocal-cloud-wrapper.es114.js";
+import * as React from "react";
+import { RemoveScrollBar } from "./golocal-cloud-wrapper.es206.js";
+import { styleSingleton } from "./golocal-cloud-wrapper.es207.js";
+import { nonPassive } from "./golocal-cloud-wrapper.es208.js";
+import { locationCouldBeScrolled, handleScroll } from "./golocal-cloud-wrapper.es209.js";
+var getTouchXY = function(event) {
+  return "changedTouches" in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];
+};
+var getDeltaXY = function(event) {
+  return [event.deltaX, event.deltaY];
+};
+var extractRef = function(ref) {
+  return ref && "current" in ref ? ref.current : ref;
+};
+var deltaCompare = function(x, y) {
+  return x[0] === y[0] && x[1] === y[1];
+};
+var generateStyle = function(id) {
+  return "\n  .block-interactivity-".concat(id, " {pointer-events: none;}\n  .allow-interactivity-").concat(id, " {pointer-events: all;}\n");
+};
+var idCounter = 0;
+var lockStack = [];
+function RemoveScrollSideCar(props) {
+  var shouldPreventQueue = React.useRef([]);
+  var touchStartRef = React.useRef([0, 0]);
+  var activeAxis = React.useRef();
+  var id = React.useState(idCounter++)[0];
+  var Style = React.useState(styleSingleton)[0];
+  var lastProps = React.useRef(props);
+  React.useEffect(function() {
+    lastProps.current = props;
+  }, [props]);
+  React.useEffect(function() {
+    if (props.inert) {
+      document.body.classList.add("block-interactivity-".concat(id));
+      var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);
+      allow_1.forEach(function(el) {
+        return el.classList.add("allow-interactivity-".concat(id));
+      });
+      return function() {
+        document.body.classList.remove("block-interactivity-".concat(id));
+        allow_1.forEach(function(el) {
+          return el.classList.remove("allow-interactivity-".concat(id));
+        });
+      };
+    }
+    return;
+  }, [props.inert, props.lockRef.current, props.shards]);
+  var shouldCancelEvent = React.useCallback(function(event, parent) {
+    if ("touches" in event && event.touches.length === 2 || event.type === "wheel" && event.ctrlKey) {
+      return !lastProps.current.allowPinchZoom;
+    }
+    var touch = getTouchXY(event);
+    var touchStart = touchStartRef.current;
+    var deltaX = "deltaX" in event ? event.deltaX : touchStart[0] - touch[0];
+    var deltaY = "deltaY" in event ? event.deltaY : touchStart[1] - touch[1];
+    var currentAxis;
+    var target = event.target;
+    var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? "h" : "v";
+    if ("touches" in event && moveDirection === "h" && target.type === "range") {
+      return false;
+    }
+    var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
+    if (!canBeScrolledInMainDirection) {
+      return true;
+    }
+    if (canBeScrolledInMainDirection) {
+      currentAxis = moveDirection;
+    } else {
+      currentAxis = moveDirection === "v" ? "h" : "v";
+      canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
+    }
+    if (!canBeScrolledInMainDirection) {
+      return false;
+    }
+    if (!activeAxis.current && "changedTouches" in event && (deltaX || deltaY)) {
+      activeAxis.current = currentAxis;
+    }
+    if (!currentAxis) {
+      return true;
+    }
+    var cancelingAxis = activeAxis.current || currentAxis;
+    return handleScroll(cancelingAxis, parent, event, cancelingAxis === "h" ? deltaX : deltaY);
+  }, []);
+  var shouldPrevent = React.useCallback(function(_event) {
+    var event = _event;
+    if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {
+      return;
+    }
+    var delta = "deltaY" in event ? getDeltaXY(event) : getTouchXY(event);
+    var sourceEvent = shouldPreventQueue.current.filter(function(e) {
+      return e.name === event.type && (e.target === event.target || event.target === e.shadowParent) && deltaCompare(e.delta, delta);
+    })[0];
+    if (sourceEvent && sourceEvent.should) {
+      if (event.cancelable) {
+        event.preventDefault();
+      }
+      return;
+    }
+    if (!sourceEvent) {
+      var shardNodes = (lastProps.current.shards || []).map(extractRef).filter(Boolean).filter(function(node) {
+        return node.contains(event.target);
+      });
+      var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;
+      if (shouldStop) {
+        if (event.cancelable) {
+          event.preventDefault();
+        }
+      }
+    }
+  }, []);
+  var shouldCancel = React.useCallback(function(name, delta, target, should) {
+    var event = { name, delta, target, should, shadowParent: getOutermostShadowParent(target) };
+    shouldPreventQueue.current.push(event);
+    setTimeout(function() {
+      shouldPreventQueue.current = shouldPreventQueue.current.filter(function(e) {
+        return e !== event;
+      });
+    }, 1);
+  }, []);
+  var scrollTouchStart = React.useCallback(function(event) {
+    touchStartRef.current = getTouchXY(event);
+    activeAxis.current = void 0;
+  }, []);
+  var scrollWheel = React.useCallback(function(event) {
+    shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
+  }, []);
+  var scrollTouchMove = React.useCallback(function(event) {
+    shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
+  }, []);
+  React.useEffect(function() {
+    lockStack.push(Style);
+    props.setCallbacks({
+      onScrollCapture: scrollWheel,
+      onWheelCapture: scrollWheel,
+      onTouchMoveCapture: scrollTouchMove
+    });
+    document.addEventListener("wheel", shouldPrevent, nonPassive);
+    document.addEventListener("touchmove", shouldPrevent, nonPassive);
+    document.addEventListener("touchstart", scrollTouchStart, nonPassive);
+    return function() {
+      lockStack = lockStack.filter(function(inst) {
+        return inst !== Style;
+      });
+      document.removeEventListener("wheel", shouldPrevent, nonPassive);
+      document.removeEventListener("touchmove", shouldPrevent, nonPassive);
+      document.removeEventListener("touchstart", scrollTouchStart, nonPassive);
+    };
+  }, []);
+  var removeScrollBar = props.removeScrollBar, inert = props.inert;
+  return React.createElement(
+    React.Fragment,
+    null,
+    inert ? React.createElement(Style, { styles: generateStyle(id) }) : null,
+    removeScrollBar ? React.createElement(RemoveScrollBar, { noRelative: props.noRelative, gapMode: props.gapMode }) : null
+  );
+}
+function getOutermostShadowParent(node) {
+  var shadowParent = null;
+  while (node !== null) {
+    if (node instanceof ShadowRoot) {
+      shadowParent = node.host;
+      node = node.host;
+    }
+    node = node.parentNode;
+  }
+  return shadowParent;
+}
+export {
+  RemoveScrollSideCar,
+  getDeltaXY,
+  getTouchXY
+};

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

@@ -0,0 +1,21 @@
+import { __rest, __assign } from "./golocal-cloud-wrapper.es114.js";
+import * as React from "react";
+var SideCar = function(_a) {
+  var sideCar = _a.sideCar, rest = __rest(_a, ["sideCar"]);
+  if (!sideCar) {
+    throw new Error("Sidecar: please provide `sideCar` property to import the right car");
+  }
+  var Target = sideCar.read();
+  if (!Target) {
+    throw new Error("Sidecar medium not found");
+  }
+  return React.createElement(Target, __assign({}, rest));
+};
+SideCar.isSideCarExport = true;
+function exportSidecar(medium, exported) {
+  medium.useMedium(exported);
+  return SideCar;
+}
+export {
+  exportSidecar
+};

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

@@ -0,0 +1,4 @@
+var cookies = {};
+export {
+  cookies as __exports
+};