@gardenfi/garden-book 0.3.1 → 0.3.2

package/dist/BottomSheet/BottomSheet.d.ts

@@ -4,6 +4,10 @@ type BottomSheetProps = {
     children: ReactNode;
     open: boolean;
     onOpenChange?: (open: boolean) => void;
+    overlayClassName?: string;
+    dismissible?: boolean;
+    /** When `false`, the page behind stays interactive */
+    modal?: boolean;
 };
 export declare const BottomSheet: FC<BottomSheetProps>;
 export {};

package/dist/BottomSheet/index.js

@@ -1,17 +1,39 @@
 import { jsx as f, jsxs as e } from "react/jsx-runtime";
 import { Drawer as g } from "../node_modules/vaul/dist/index.js";
-import { ClientOnly as l } from "../ClientOnly/index.js";
-const s = ({
+import { ClientOnly as a } from "../ClientOnly/index.js";
+import { cn as s } from "../utils/index.js";
+const h = ({
   children: o,
   open: r,
-  onOpenChange: t
-}) => /* @__PURE__ */ f(l, { children: /* @__PURE__ */ f(g.Root, { open: r, onOpenChange: t, repositionInputs: !1, children: /* @__PURE__ */ e(g.Portal, { children: [
-  /* @__PURE__ */ f(g.Overlay, { className: "gf-fixed gf-inset-0 gf-z-50 gf-h-screen gf-w-screen gf-bg-dark-grey gf-bg-opacity-40 gf-transition-colors gf-duration-500 gf-ease-cubic-in-out" }),
-  /* @__PURE__ */ e(g.Content, { className: "gf-fixed gf-bottom-0 gf-left-0 gf-right-0 gf-z-50 gf-mt-24 gf-flex gf-max-h-[85vh] gf-flex-col gf-rounded-t-xl gf-bg-white/50 gf-px-4 gf-py-4 gf-outline-none gf-backdrop-blur-[20px]", children: [
-    /* @__PURE__ */ f("div", { className: "gf-mx-auto gf-mb-3 gf-h-1 gf-w-[60px] gf-flex-shrink-0 gf-rounded-full gf-bg-white/30" }),
-    /* @__PURE__ */ f("div", { className: "gf-scrollbar-hide gf-flex gf-flex-1 gf-flex-col gf-gap-5 gf-overflow-y-auto", children: o })
-  ] })
-] }) }) });
+  onOpenChange: t,
+  overlayClassName: l,
+  dismissible: i,
+  modal: n
+}) => /* @__PURE__ */ f(a, { children: /* @__PURE__ */ f(
+  g.Root,
+  {
+    open: r,
+    onOpenChange: t,
+    repositionInputs: !1,
+    dismissible: i,
+    modal: n,
+    children: /* @__PURE__ */ e(g.Portal, { children: [
+      /* @__PURE__ */ f(
+        g.Overlay,
+        {
+          className: s(
+            "gf-fixed gf-inset-0 gf-z-50 gf-h-screen gf-w-screen gf-bg-dark-grey gf-bg-opacity-40 gf-transition-colors gf-duration-500 gf-ease-cubic-in-out",
+            l
+          )
+        }
+      ),
+      /* @__PURE__ */ e(g.Content, { className: "gf-fixed gf-bottom-0 gf-left-0 gf-right-0 gf-z-50 gf-mt-24 gf-flex gf-max-h-[85vh] gf-flex-col gf-rounded-t-xl gf-bg-white/50 gf-px-4 gf-py-4 gf-outline-none gf-backdrop-blur-[20px]", children: [
+        /* @__PURE__ */ f("div", { className: "gf-mx-auto gf-mb-3 gf-h-1 gf-w-[60px] gf-flex-shrink-0 gf-rounded-full gf-bg-white/30" }),
+        /* @__PURE__ */ f("div", { className: "gf-scrollbar-hide gf-flex gf-flex-1 gf-flex-col gf-gap-5 gf-overflow-y-auto", children: o })
+      ] })
+    ] })
+  }
+) });
 export {
-  s as BottomSheet
+  h as BottomSheet
 };

package/dist/Checkbox/Checkbox.d.ts

@@ -3,6 +3,7 @@ import { FC } from 'react';
 type CheckBoxProps = React.HTMLAttributes<HTMLDivElement> & {
     checked: boolean;
     color?: string;
+    disabled?: boolean;
 };
 export declare const CheckBox: FC<CheckBoxProps>;
 export {};

package/dist/Checkbox/Checkbox.js

@@ -1,7 +1,35 @@
-import { jsx as r } from "react/jsx-runtime";
-import { Checked as m } from "../Icons/Checked.js";
-import { Unchecked as s } from "../Icons/Unchecked.js";
-const p = ({ checked: o, color: e, ...c }) => /* @__PURE__ */ r("div", { ...c, children: o ? /* @__PURE__ */ r(m, { className: "gf-cursor-pointer", color: e }) : /* @__PURE__ */ r(s, { className: "gf-cursor-pointer" }) });
+import { jsx as t } from "react/jsx-runtime";
+import { Checked as n } from "../Icons/Checked.js";
+import { Unchecked as f } from "../Icons/Unchecked.js";
+import { cn as a } from "../utils/index.js";
+const s = ({
+  checked: e,
+  color: o,
+  disabled: r,
+  className: c,
+  onClick: m,
+  ...i
+}) => /* @__PURE__ */ t(
+  "div",
+  {
+    role: "checkbox",
+    "aria-checked": e,
+    "aria-disabled": r,
+    onClick: r ? void 0 : m,
+    className: a(
+      r ? "gf-cursor-not-allowed" : "gf-cursor-pointer",
+      c
+    ),
+    ...i,
+    children: e ? /* @__PURE__ */ t(
+      n,
+      {
+        color: !r && o ? o : "currentColor",
+        className: r ? "gf-text-midGrey" : o ? void 0 : "gf-text-button-primary"
+      }
+    ) : /* @__PURE__ */ t(f, {})
+  }
+);
 export {
-  p as CheckBox
+  s as CheckBox
 };

package/dist/CookieConsent/CookieConsent.d.ts

@@ -0,0 +1,18 @@
+import { FC } from 'react';
+import { ConsentChoice, CookieCategory, UseCookieConsentOptions } from './utils';
+
+export type CookieConsentProps = {
+    /** Privacy Policy link shown on the notice screen. */
+    privacyPolicyUrl: string;
+    /** Categories rendered on the preferences screen (defaults to the three Garden categories). */
+    categories?: CookieCategory[];
+    /** Initial tick state for the two non-essential categories. */
+    defaultChecked?: boolean;
+    /** Called after a choice is persisted. */
+    onChange?: (choice: ConsentChoice) => void;
+    /** Override cookie domain / version / expiry. */
+    config?: UseCookieConsentOptions;
+};
+/** Orchestrator: owns the consent store + responsive modal, and switches between
+ * the two presentational screens. */
+export declare const CookieConsent: FC<CookieConsentProps>;

package/dist/CookieConsent/CookieConsent.js

@@ -0,0 +1,52 @@
+import { jsx as t } from "react/jsx-runtime";
+import { ResponsiveModal as A } from "../ResponsiveModal/index.js";
+import { useCookieConsent as v } from "./useCookieConsent.js";
+import { CookieConsentNotice as g } from "./CookieConsentNotice.js";
+import { CookieConsentPreferences as k } from "./CookieConsentPreferences.js";
+import { DEFAULT_COOKIE_CATEGORIES as S } from "./utils.js";
+const I = ({
+  privacyPolicyUrl: n,
+  categories: s = S,
+  defaultChecked: l = !0,
+  onChange: e,
+  config: i
+}) => {
+  const { isOpen: c, view: f, ready: p, setView: a, close: m, acceptAll: u, save: d } = v(i);
+  if (!p) return null;
+  const o = () => {
+    u(), e == null || e({ analytics: !0, functional: !0 });
+  };
+  return /* @__PURE__ */ t(
+    A,
+    {
+      open: c,
+      onClose: m,
+      hideCloseBtn: !0,
+      bottomSheetAllowBackgroundInteraction: !0,
+      disableScrollLock: !0,
+      overlayClassName: "!gf-items-end !gf-justify-start gf-pl-[40px] !gf-bg-transparent !gf-pointer-events-none",
+      className: "!gf-pointer-events-auto gf-w-[420px] gf-gap-0 gf-px-3 gf-py-4 gf-rounded-t-4 gf-rounded-b-none",
+      children: f === "notice" ? /* @__PURE__ */ t(
+        g,
+        {
+          privacyPolicyUrl: n,
+          onChangePreferences: () => a("preferences"),
+          onAcceptAll: o
+        }
+      ) : /* @__PURE__ */ t(
+        k,
+        {
+          categories: s,
+          defaultChecked: l,
+          onAcceptAll: o,
+          onSave: (r) => {
+            d(r), e == null || e(r);
+          }
+        }
+      )
+    }
+  );
+};
+export {
+  I as CookieConsent
+};

package/dist/CookieConsent/CookieConsentNotice.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+
+export type CookieConsentNoticeProps = {
+    privacyPolicyUrl: string;
+    onChangePreferences: () => void;
+    onAcceptAll: () => void;
+};
+export declare const CookieConsentNotice: FC<CookieConsentNoticeProps>;

package/dist/CookieConsent/CookieConsentNotice.js

@@ -0,0 +1,55 @@
+import { jsxs as a, jsx as e } from "react/jsx-runtime";
+import { Typography as r } from "../Typography/index.js";
+import { Button as l } from "../Button/index.js";
+const g = ({
+  privacyPolicyUrl: i,
+  onChangePreferences: s,
+  onAcceptAll: o
+}) => /* @__PURE__ */ a("div", { className: "gf-flex gf-flex-col gf-gap-9", children: [
+  /* @__PURE__ */ a("div", { className: "gf-flex gf-flex-col gf-gap-3 gf-px-1", children: [
+    /* @__PURE__ */ e(r, { as: "p", size: "h5", weight: "medium", className: "!gf-leading-5", children: "Manage cookies" }),
+    /* @__PURE__ */ a(r, { as: "p", size: "h4", children: [
+      "We use cookies and analytics to improve Garden. ",
+      /* @__PURE__ */ e("br", {}),
+      "Learn more in our",
+      " ",
+      /* @__PURE__ */ e(
+        "a",
+        {
+          href: i,
+          target: "_blank",
+          rel: "noreferrer",
+          className: "gf-font-medium",
+          children: "Privacy Policy"
+        }
+      ),
+      "."
+    ] })
+  ] }),
+  /* @__PURE__ */ a("div", { className: "gf-flex gf-flex-col gf-gap-3", children: [
+    /* @__PURE__ */ e(
+      l,
+      {
+        variant: "ternary",
+        size: "sm",
+        colors: { ternary: "rgba(255,255,255,0.5)" },
+        className: "gf-w-full",
+        onClick: s,
+        children: "Change preferences"
+      }
+    ),
+    /* @__PURE__ */ e(
+      l,
+      {
+        variant: "primary",
+        size: "sm",
+        className: "gf-w-full",
+        onClick: o,
+        children: "Accept all"
+      }
+    )
+  ] })
+] });
+export {
+  g as CookieConsentNotice
+};

package/dist/CookieConsent/CookieConsentPreferences.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+import { ConsentChoice, CookieCategory } from './utils';
+
+export type CookieConsentPreferencesProps = {
+    categories: CookieCategory[];
+    defaultChecked: boolean;
+    onAcceptAll: () => void;
+    onSave: (choice: ConsentChoice) => void;
+};
+export declare const CookieConsentPreferences: FC<CookieConsentPreferencesProps>;

package/dist/CookieConsent/CookieConsentPreferences.js

@@ -0,0 +1,75 @@
+import { jsxs as a, jsx as l } from "react/jsx-runtime";
+import { useState as p } from "react";
+import { Typography as s } from "../Typography/index.js";
+import { Button as c } from "../Button/index.js";
+import { CheckBox as h } from "../Checkbox/Checkbox.js";
+const v = ({
+  categories: n,
+  defaultChecked: r,
+  onAcceptAll: t,
+  onSave: o
+}) => {
+  const [f, m] = p({
+    analytics: r,
+    functional: r
+  });
+  return /* @__PURE__ */ a("div", { className: "gf-flex gf-flex-col gf-gap-9", children: [
+    /* @__PURE__ */ a("div", { className: "gf-flex gf-flex-col gf-gap-3 gf-px-1", children: [
+      /* @__PURE__ */ l(s, { as: "p", size: "h5", weight: "medium", className: "!gf-leading-5", children: "Manage cookies" }),
+      /* @__PURE__ */ l("div", { className: "gf-flex gf-flex-col gf-gap-4", children: n.map((e) => {
+        const i = e.id, d = e.locked ? !0 : f[i];
+        return /* @__PURE__ */ a("div", { className: "gf-flex gf-flex-col gf-gap-1", children: [
+          /* @__PURE__ */ a("div", { className: "gf-flex gf-items-center gf-justify-between gf-gap-4", children: [
+            /* @__PURE__ */ l(s, { as: "p", size: "h4", weight: "medium", children: e.title }),
+            /* @__PURE__ */ l(
+              h,
+              {
+                checked: d,
+                disabled: e.locked,
+                "aria-label": e.title,
+                className: "gf-shrink-0 gf-text-dark-grey",
+                onClick: () => m((g) => ({ ...g, [i]: !g[i] }))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ l(
+            s,
+            {
+              as: "p",
+              size: "h4",
+              weight: "regular",
+              className: "gf-max-w-[340px]",
+              children: e.description
+            }
+          )
+        ] }, e.id);
+      }) })
+    ] }),
+    /* @__PURE__ */ a("div", { className: "gf-flex gf-flex-col gf-gap-3", children: [
+      /* @__PURE__ */ l(
+        c,
+        {
+          variant: "ternary",
+          size: "sm",
+          colors: { ternary: "rgba(255,255,255,0.5)" },
+          className: "gf-w-full",
+          onClick: t,
+          children: "Accept all"
+        }
+      ),
+      /* @__PURE__ */ l(
+        c,
+        {
+          variant: "primary",
+          size: "sm",
+          className: "gf-w-full",
+          onClick: () => o(f),
+          children: "Save"
+        }
+      )
+    ] })
+  ] });
+};
+export {
+  v as CookieConsentPreferences
+};

package/dist/CookieConsent/index.d.ts

@@ -0,0 +1,5 @@
+export * from './CookieConsent';
+export { useCookieConsent } from './useCookieConsent';
+export type { UseCookieConsentReturn } from './useCookieConsent';
+export { CONSENT_EVENT } from './utils';
+export type { ConsentChoice, StoredConsent, ConsentView, UseCookieConsentOptions, } from './utils';

package/dist/CookieConsent/index.js

@@ -0,0 +1,8 @@
+import { CookieConsent as r } from "./CookieConsent.js";
+import { useCookieConsent as C } from "./useCookieConsent.js";
+import { CONSENT_EVENT as f } from "./utils.js";
+export {
+  f as CONSENT_EVENT,
+  r as CookieConsent,
+  C as useCookieConsent
+};

package/dist/CookieConsent/store.d.ts

@@ -0,0 +1,19 @@
+import { ConsentView, StoredConsent } from './utils';
+
+/**
+ * Module-level store shared across all `useCookieConsent` instances,
+ * so the modal control one source of truth even though they call the
+ * hook independently. Subscribed via `useSyncExternalStore`.
+ */
+type State = {
+    isOpen: boolean;
+    view: ConsentView;
+    consent: StoredConsent | null;
+    ready: boolean;
+};
+export declare const setState: (patch: Partial<State>) => void;
+export declare const subscribe: (l: () => void) => () => boolean;
+export declare const getSnapshot: () => State;
+export declare const getServerSnapshot: () => State;
+export declare function boot(): void;
+export {};

package/dist/CookieConsent/store.js

@@ -0,0 +1,42 @@
+import { readRaw as c, isValidConsent as l, applyConsent as t, hasTrackingCookies as u, isWithinAutoConsentWindow as f, writeConsent as d } from "./utils.js";
+let s = {
+  isOpen: !1,
+  view: "notice",
+  consent: null,
+  ready: !1
+};
+const p = {
+  isOpen: !1,
+  view: "notice",
+  consent: null,
+  ready: !1
+}, o = /* @__PURE__ */ new Set(), w = () => o.forEach((e) => e()), n = (e) => {
+  s = { ...s, ...e }, w();
+}, S = (e) => (o.add(e), () => o.delete(e)), O = () => s, h = () => p, a = { analytics: !1, functional: !1 };
+let i = !1;
+function v() {
+  if (i) return;
+  i = !0;
+  const e = c();
+  if (l(e)) {
+    t(e), n({ consent: e, ready: !0, isOpen: !1 });
+    return;
+  }
+  if (e) {
+    t(a), n({ consent: null, ready: !0, isOpen: !0, view: "notice" });
+    return;
+  }
+  if (u() && f()) {
+    const r = d({ analytics: !0, functional: !0 });
+    t(r), n({ consent: r, ready: !0, isOpen: !1 });
+    return;
+  }
+  t(a), n({ consent: null, ready: !0, isOpen: !0, view: "notice" });
+}
+export {
+  v as boot,
+  h as getServerSnapshot,
+  O as getSnapshot,
+  n as setState,
+  S as subscribe
+};

package/dist/CookieConsent/useCookieConsent.d.ts

@@ -0,0 +1,23 @@
+import { ConsentChoice, ConsentView, StoredConsent, UseCookieConsentOptions } from './utils';
+
+export type UseCookieConsentReturn = {
+    /** The stored choice, or null if none/expired. */
+    consent: StoredConsent | null;
+    /** Whether the banner/modal is open. */
+    isOpen: boolean;
+    /** Which screen to show when open. */
+    view: ConsentView;
+    /** True once boot has run on the client (avoids SSR flash). */
+    ready: boolean;
+    /** Open the banner at a given screen (default the notice; pass "preferences" for a footer link). */
+    open: (view?: ConsentView) => void;
+    /** Switch screen without closing (e.g. notice → preferences). */
+    setView: (view: ConsentView) => void;
+    /** Close without recording a choice (banner reappears next load). */
+    close: () => void;
+    /** Grant everything and persist. */
+    acceptAll: () => void;
+    /** Persist a specific choice. */
+    save: (choice: ConsentChoice) => void;
+};
+export declare function useCookieConsent(options?: UseCookieConsentOptions): UseCookieConsentReturn;

package/dist/CookieConsent/useCookieConsent.js

@@ -0,0 +1,31 @@
+import { useSyncExternalStore as a, useEffect as i, useCallback as c } from "react";
+import { subscribe as p, getSnapshot as l, getServerSnapshot as u, boot as f, setState as n } from "./store.js";
+import { configure as m, writeConsent as C, applyConsent as S, clearDeniedCookies as y } from "./utils.js";
+function v(o) {
+  const t = a(
+    p,
+    l,
+    u
+  );
+  i(() => {
+    m(o), f();
+  }, []);
+  const s = c((e) => {
+    const r = C(e);
+    S(e), y(e), n({ consent: r, isOpen: !1 });
+  }, []);
+  return {
+    consent: t.consent,
+    isOpen: t.isOpen,
+    view: t.view,
+    ready: t.ready,
+    open: (e = "notice") => n({ isOpen: !0, view: e }),
+    setView: (e) => n({ view: e }),
+    close: () => n({ isOpen: !1 }),
+    acceptAll: () => s({ analytics: !0, functional: !0 }),
+    save: (e) => s(e)
+  };
+}
+export {
+  v as useCookieConsent
+};

package/dist/CookieConsent/utils.d.ts

@@ -0,0 +1,58 @@
+export type CookieCategory = {
+    id: "essential" | "analytics" | "functional";
+    title: string;
+    description: string;
+    /** Always on, no toggle (Essential). */
+    locked?: boolean;
+};
+/** Default Garden categories for the preferences UI. */
+export declare const DEFAULT_COOKIE_CATEGORIES: CookieCategory[];
+export type ConsentView = "notice" | "preferences";
+export type ConsentChoice = {
+    analytics: boolean;
+    functional: boolean;
+};
+export type StoredConsent = ConsentChoice & {
+    /** Always true — Essential is locked on. Stored explicitly so external readers
+     * (proof-of-consent record, audits) see the full picture, even though we never mutate it. */
+    essential: true;
+    timestamp: number;
+    version: number;
+};
+/** Window event the telemetry scripts (loaded separately) listen on to react without a reload. */
+export declare const CONSENT_EVENT = "garden:consentchange";
+type Config = {
+    /** Cookie domain — `.garden.finance` shares the choice across www + app. */
+    cookieDomain: string;
+    /** Bump to force re-consent after a policy/category change. */
+    storageVersion: number;
+    /** Consent *validity* — re-prompt after this many months (checked via timestamp). */
+    expiryMonths: number;
+    /** Cookie *lifetime* in days — kept longer than validity (and refreshed each visit)
+     * so a stale-but-present cookie can be told apart from an absent one. Browser caps at 400. */
+    cookieMaxAgeDays: number;
+};
+export type UseCookieConsentOptions = Partial<Config>;
+export declare const config: Config;
+/**
+ * Patch the module config in place. Callers can't reassign the imported `config`
+ * binding (ES module imports are read-only), so mutate its properties instead.
+ */
+export declare function configure(options?: UseCookieConsentOptions): void;
+export declare function isWithinAutoConsentWindow(): boolean;
+/** Parse the cookie. Returns the record if present and parseable, else null. */
+export declare function readRaw(): StoredConsent | null;
+/** A record is valid if it matches the current policy version and is within the
+ * 13-month validity window. */
+export declare function isValidConsent(data: StoredConsent | null): data is StoredConsent;
+/** Record a new choice (stamps a fresh timestamp + current version). */
+export declare function writeConsent(choice: ConsentChoice): StoredConsent;
+/** True if any pre-existing analytics/functional cookie is present. Used to
+ * detect a pre-deploy "existing user" (Essential cookies are excluded). */
+export declare function hasTrackingCookies(): boolean;
+/** Delete the cookies of any category the choice denies. Idempotent (deleting an
+ * absent cookie is a no-op), so safe to call on every consent update. Tool-native
+ * clears (posthog.reset / Clarity consentv2) happen in the GTM tags. */
+export declare function clearDeniedCookies(choice: ConsentChoice): void;
+export declare function applyConsent(choice: ConsentChoice): void;
+export {};

package/dist/CookieConsent/utils.js

@@ -0,0 +1,134 @@
+const p = [
+  {
+    id: "essential",
+    title: "Essential",
+    description: "Blocks DDoS attacks and prevents abuse.",
+    locked: !0
+  },
+  {
+    id: "analytics",
+    title: "Analytics & Customization",
+    description: "Session behaviour and product analytics to help us improve the app."
+  },
+  {
+    id: "functional",
+    title: "Performance & Functional",
+    description: "Traffic sources to help us understand how people discover Garden."
+  }
+], d = "garden:consentchange", i = "garden_consent", a = {
+  cookieDomain: ".garden.finance",
+  storageVersion: 1,
+  expiryMonths: 13,
+  cookieMaxAgeDays: 400
+};
+function g(n) {
+  n && Object.assign(a, n);
+}
+const u = "2026-06-12", l = 60;
+function _() {
+  const n = new Date(u).getTime();
+  return Number.isNaN(n) ? !1 : Date.now() < n + l * 24 * 60 * 60 * 1e3;
+}
+function y() {
+  try {
+    const n = document.cookie.match(
+      new RegExp("(?:^|; )" + i + "=([^;]*)")
+    );
+    return n ? JSON.parse(decodeURIComponent(n[1])) : null;
+  } catch {
+    return null;
+  }
+}
+function h(n) {
+  return !n || n.version !== a.storageVersion ? !1 : Date.now() - (n.timestamp || 0) <= a.expiryMonths * 30 * 24 * 60 * 60 * 1e3;
+}
+function f(n) {
+  const t = encodeURIComponent(JSON.stringify(n)), e = a.cookieMaxAgeDays * 24 * 60 * 60;
+  document.cookie = i + "=" + t + "; domain=" + a.cookieDomain + "; path=/; max-age=" + e + "; SameSite=Lax; Secure";
+}
+function C(n) {
+  const t = {
+    essential: !0,
+    analytics: !!n.analytics,
+    functional: !!n.functional,
+    timestamp: Date.now(),
+    version: a.storageVersion
+  };
+  return f(t), t;
+}
+const s = [
+  /^_ga(_.*)?$/,
+  // GA4: _ga and _ga_<measurementId>
+  /^original_referrer$/,
+  // Garden telemetry
+  /^original_landing_url$/
+  // Garden telemetry
+], c = [
+  /^ph_.*$/,
+  // PostHog
+  /^_clck$/,
+  // MS Clarity
+  /^_clsk$/
+  // MS Clarity
+];
+function r() {
+  return typeof document > "u" || !document.cookie ? [] : document.cookie.split(";").map((n) => n.split("=")[0].trim());
+}
+function E() {
+  const n = [
+    ...s,
+    ...c
+  ];
+  return r().some((t) => n.some((e) => e.test(t)));
+}
+function m(n) {
+  [
+    "",
+    "; domain=" + a.cookieDomain,
+    typeof location < "u" ? "; domain=" + location.hostname : ""
+  ].forEach((e) => {
+    document.cookie = n + "=; path=/; max-age=0" + e;
+  });
+}
+function k(n) {
+  const t = [];
+  n.analytics || t.push(...s), n.functional || t.push(...c), t.length && r().forEach((e) => {
+    t.some((o) => o.test(e)) && m(e);
+  });
+}
+function O(n) {
+  const t = n.analytics ? "granted" : "denied", e = n.functional ? "granted" : "denied", o = window;
+  typeof o.gtag == "function" && o.gtag("consent", "update", {
+    analytics_storage: t,
+    personalization_storage: t,
+    functionality_storage: e,
+    ad_storage: "denied",
+    ad_user_data: "denied",
+    ad_personalization: "denied"
+  }), o.dataLayer = o.dataLayer || [], o.dataLayer.push({
+    event: "consent_update",
+    analytics_consent: t,
+    functional_consent: e
+  });
+  try {
+    window.dispatchEvent(
+      new CustomEvent(d, {
+        detail: { analytics: n.analytics, functional: n.functional }
+      })
+    );
+  } catch {
+  }
+}
+export {
+  d as CONSENT_EVENT,
+  p as DEFAULT_COOKIE_CATEGORIES,
+  O as applyConsent,
+  k as clearDeniedCookies,
+  a as config,
+  g as configure,
+  E as hasTrackingCookies,
+  h as isValidConsent,
+  _ as isWithinAutoConsentWindow,
+  y as readRaw,
+  C as writeConsent
+};