@bbl-digital/snorre 4.2.86 → 4.2.88

package/dist/snorre.es629.js

@@ -0,0 +1,91 @@
+import { millisecondsToSeconds as b, secondsToMilliseconds as R } from "./snorre.es606.js";
+import { calcGeneratorDuration as A, maxGeneratorDuration as w } from "./snorre.es622.js";
+import { generateLinearEasing as B } from "./snorre.es681.js";
+import { clamp as K } from "./snorre.es624.js";
+import { calcGeneratorVelocity as V } from "./snorre.es682.js";
+import { springDefaults as a } from "./snorre.es683.js";
+import { findSpring as j, calcAngularFreq as E } from "./snorre.es684.js";
+const I = ["duration", "bounce"], L = ["stiffness", "damping", "mass"];
+function x(t, r) {
+  return r.some((s) => t[s] !== void 0);
+}
+function P(t) {
+  let r = {
+    velocity: a.velocity,
+    stiffness: a.stiffness,
+    damping: a.damping,
+    mass: a.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!x(t, L) && x(t, I))
+    if (t.visualDuration) {
+      const s = t.visualDuration, u = 2 * Math.PI / (s * 1.2), m = u * u, g = 2 * K(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(m);
+      r = {
+        ...r,
+        mass: a.mass,
+        stiffness: m,
+        damping: g
+      };
+    } else {
+      const s = j(t);
+      r = {
+        ...r,
+        ...s,
+        mass: a.mass
+      }, r.isResolvedFromDuration = !0;
+    }
+  return r;
+}
+function U(t = a.visualDuration, r = a.bounce) {
+  const s = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: r
+  } : t;
+  let { restSpeed: u, restDelta: m } = s;
+  const g = s.keyframes[0], f = s.keyframes[s.keyframes.length - 1], d = { done: !1, value: g }, { stiffness: M, damping: T, mass: D, duration: S, velocity: k, isResolvedFromDuration: q } = P({
+    ...s,
+    velocity: -b(s.velocity || 0)
+  }), h = k || 0, o = T / (2 * Math.sqrt(M * D)), c = f - g, i = b(Math.sqrt(M / D)), F = Math.abs(c) < 5;
+  u || (u = F ? a.restSpeed.granular : a.restSpeed.default), m || (m = F ? a.restDelta.granular : a.restDelta.default);
+  let p;
+  if (o < 1) {
+    const e = E(i, o);
+    p = (n) => {
+      const l = Math.exp(-o * i * n);
+      return f - l * ((h + o * i * c) / e * Math.sin(e * n) + c * Math.cos(e * n));
+    };
+  } else if (o === 1)
+    p = (e) => f - Math.exp(-i * e) * (c + (h + i * c) * e);
+  else {
+    const e = i * Math.sqrt(o * o - 1);
+    p = (n) => {
+      const l = Math.exp(-o * i * n), v = Math.min(e * n, 300);
+      return f - l * ((h + o * i * c) * Math.sinh(v) + e * c * Math.cosh(v)) / e;
+    };
+  }
+  const y = {
+    calculatedDuration: q && S || null,
+    next: (e) => {
+      const n = p(e);
+      if (q)
+        d.done = e >= S;
+      else {
+        let l = 0;
+        o < 1 && (l = e === 0 ? R(h) : V(p, e, n));
+        const v = Math.abs(l) <= u, G = Math.abs(f - n) <= m;
+        d.done = v && G;
+      }
+      return d.value = d.done ? f : n, d;
+    },
+    toString: () => {
+      const e = Math.min(A(y), w), n = B((l) => y.next(e * l).value, e, 30);
+      return e + "ms " + n;
+    }
+  };
+  return y;
+}
+export {
+  U as spring
+};

package/dist/snorre.es63.js

@@ -0,0 +1,6 @@
+import { j as o } from "./snorre.es329.js";
+import M from "./snorre.es360.js";
+const Z = (n) => /* @__PURE__ */ o.jsx("svg", { viewBox: "0 0 24 24", ...n, children: /* @__PURE__ */ o.jsx("path", { d: "M12 7 12 3 2 3 2 21 22 21 22 7 12 7ZM6 19 4 19 4 17 6 17 6 19ZM6 15 4 15 4 13 6 13 6 15ZM6 11 4 11 4 9 6 9 6 11ZM6 7 4 7 4 5 6 5 6 7ZM10 19 8 19 8 17 10 17 10 19ZM10 15 8 15 8 13 10 13 10 15ZM10 11 8 11 8 9 10 9 10 11ZM10 7 8 7 8 5 10 5 10 7ZM20 19 12 19 12 17 14 17 14 15 12 15 12 13 14 13 14 11 12 11 12 9 20 9 20 19ZM18 11 16 11 16 13 18 13 18 11ZM18 15 16 15 16 17 18 17 18 15Z" }) }), r = M()(Z);
+export {
+  r as default
+};

package/dist/snorre.es630.js

@@ -0,0 +1,17 @@
+import { time as o } from "./snorre.es656.js";
+import { frameData as t, cancelFrame as a, frame as s } from "./snorre.es671.js";
+const n = (e) => {
+  const r = ({ timestamp: m }) => e(m);
+  return {
+    start: () => s.update(r, !0),
+    stop: () => a(r),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => t.isProcessing ? t.timestamp : o.now()
+  };
+};
+export {
+  n as frameloopDriver
+};

package/dist/snorre.es631.js

@@ -0,0 +1,22 @@
+import { resolveVariant as c } from "./snorre.es632.js";
+import { animateTarget as p } from "./snorre.es633.js";
+import { animateVariant as e } from "./snorre.es634.js";
+function n(a, r, t = {}) {
+  a.notify("AnimationStart", r);
+  let m;
+  if (Array.isArray(r)) {
+    const o = r.map((y) => e(a, y, t));
+    m = Promise.all(o);
+  } else if (typeof r == "string")
+    m = e(a, r, t);
+  else {
+    const o = typeof r == "function" ? c(a, r, t.custom) : r;
+    m = Promise.all(p(a, o, t));
+  }
+  return m.then(() => {
+    a.notify("AnimationComplete", r);
+  });
+}
+export {
+  n as animateVisualElement
+};

package/dist/snorre.es632.js

@@ -0,0 +1,8 @@
+import { resolveVariantFromProps as t } from "./snorre.es670.js";
+function s(r, n, o) {
+  const e = r.getProps();
+  return t(e, n, o !== void 0 ? o : e.custom, r);
+}
+export {
+  s as resolveVariant
+};

package/dist/snorre.es633.js

@@ -0,0 +1,45 @@
+import { getValueTransition as M } from "./snorre.es756.js";
+import { positionalKeys as S } from "./snorre.es749.js";
+import { setTarget as A } from "./snorre.es745.js";
+import { addValueToWillChange as H } from "./snorre.es757.js";
+import { getOptimisedAppearId as y } from "./snorre.es758.js";
+import { animateMotionValue as B } from "./snorre.es759.js";
+import { frame as V } from "./snorre.es671.js";
+function I({ protectedKeys: t, needsAnimating: a }, n) {
+  const i = t.hasOwnProperty(n) && a[n] !== !0;
+  return a[n] = !1, i;
+}
+function R(t, a, { delay: n = 0, transitionOverride: i, type: m } = {}) {
+  var r;
+  let { transition: p = t.getDefaultTransition(), transitionEnd: e, ...d } = a;
+  i && (p = i);
+  const f = [], u = m && t.animationState && t.animationState.getState()[m];
+  for (const o in d) {
+    const s = t.getValue(o, (r = t.latestValues[o]) !== null && r !== void 0 ? r : null), c = d[o];
+    if (c === void 0 || u && I(u, o))
+      continue;
+    const l = {
+      delay: n,
+      ...M(p || {}, o)
+    };
+    let T = !1;
+    if (window.MotionHandoffAnimation) {
+      const h = y(t);
+      if (h) {
+        const w = window.MotionHandoffAnimation(h, o, V);
+        w !== null && (l.startTime = w, T = !0);
+      }
+    }
+    H(t, o), s.start(B(o, s, c, t.shouldReduceMotion && S.has(o) ? { type: !1 } : l, t, T));
+    const g = s.animation;
+    g && f.push(g);
+  }
+  return e && Promise.all(f).then(() => {
+    V.update(() => {
+      e && A(t, e);
+    });
+  }), f;
+}
+export {
+  R as animateTarget
+};

package/dist/snorre.es634.js

@@ -0,0 +1,33 @@
+import { resolveVariant as h } from "./snorre.es632.js";
+import { animateTarget as g } from "./snorre.es633.js";
+function C(r, t, n = {}) {
+  var i;
+  const a = h(r, t, n.type === "exit" ? (i = r.presenceContext) === null || i === void 0 ? void 0 : i.custom : void 0);
+  let { transition: s = r.getDefaultTransition() || {} } = a || {};
+  n.transitionOverride && (s = n.transitionOverride);
+  const o = a ? () => Promise.all(g(r, a, n)) : () => Promise.resolve(), d = r.variantChildren && r.variantChildren.size ? (e = 0) => {
+    const { delayChildren: f = 0, staggerChildren: m, staggerDirection: l } = s;
+    return u(r, t, f + e, m, l, n);
+  } : () => Promise.resolve(), { when: c } = s;
+  if (c) {
+    const [e, f] = c === "beforeChildren" ? [o, d] : [d, o];
+    return e().then(() => f());
+  } else
+    return Promise.all([o(), d(n.delay)]);
+}
+function u(r, t, n = 0, i = 0, a = 1, s) {
+  const o = [], d = (r.variantChildren.size - 1) * i, c = a === 1 ? (e = 0) => e * i : (e = 0) => d - e * i;
+  return Array.from(r.variantChildren).sort(y).forEach((e, f) => {
+    e.notify("AnimationStart", t), o.push(C(e, t, {
+      ...s,
+      delay: n + c(f)
+    }).then(() => e.notify("AnimationComplete", t)));
+  }), Promise.all(o);
+}
+function y(r, t) {
+  return r.sortNodePosition(t);
+}
+export {
+  C as animateVariant,
+  y as sortByTreeOrder
+};

package/dist/snorre.es635.js

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+const o = /* @__PURE__ */ e(null);
+export {
+  o as PresenceContext
+};

package/dist/snorre.es636.js

@@ -0,0 +1,59 @@
+import { j as M } from "./snorre.es329.js";
+import { warning as E, invariant as g } from "./snorre.es621.js";
+import { forwardRef as j, useContext as d } from "react";
+import { LayoutGroupContext as L } from "./snorre.es593.js";
+import { LazyContext as N } from "./snorre.es637.js";
+import { MotionConfigContext as P } from "./snorre.es638.js";
+import { MotionContext as b } from "./snorre.es639.js";
+import { useCreateMotionContext as w } from "./snorre.es640.js";
+import { isBrowser as C } from "./snorre.es641.js";
+import { featureDefinitions as S } from "./snorre.es642.js";
+import { loadFeatures as h } from "./snorre.es643.js";
+import { motionComponentSymbol as R } from "./snorre.es644.js";
+import { useMotionRef as _ } from "./snorre.es645.js";
+import { useVisualElement as k } from "./snorre.es646.js";
+function U({ preloadedFeatures: o, createVisualElement: t, useRender: e, useVisualState: n, Component: i }) {
+  var u, m;
+  o && h(o);
+  function v(a, x) {
+    let c;
+    const s = {
+      ...d(P),
+      ...a,
+      layoutId: z(a)
+    }, { isStatic: l } = s, r = w(a), f = n(a, l);
+    if (!l && C) {
+      D(s, o);
+      const p = G(s);
+      c = p.MeasureLayout, r.visualElement = k(i, f, s, t, p.ProjectionNode);
+    }
+    return M.jsxs(b.Provider, { value: r, children: [c && r.visualElement ? M.jsx(c, { visualElement: r.visualElement, ...s }) : null, e(i, a, _(f, r.visualElement, x), f, l, r.visualElement)] });
+  }
+  v.displayName = `motion.${typeof i == "string" ? i : `create(${(m = (u = i.displayName) !== null && u !== void 0 ? u : i.name) !== null && m !== void 0 ? m : ""})`}`;
+  const y = j(v);
+  return y[R] = i, y;
+}
+function z({ layoutId: o }) {
+  const t = d(L).id;
+  return t && o !== void 0 ? t + "-" + o : o;
+}
+function D(o, t) {
+  const e = d(N).strict;
+  if (process.env.NODE_ENV !== "production" && t && e) {
+    const n = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    o.ignoreStrict ? E(!1, n) : g(!1, n);
+  }
+}
+function G(o) {
+  const { drag: t, layout: e } = S;
+  if (!t && !e)
+    return {};
+  const n = { ...t, ...e };
+  return {
+    MeasureLayout: t != null && t.isEnabled(o) || e != null && e.isEnabled(o) ? n.MeasureLayout : void 0,
+    ProjectionNode: n.ProjectionNode
+  };
+}
+export {
+  U as createRendererMotionComponent
+};

package/dist/snorre.es637.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const o = t({ strict: !1 });
+export {
+  o as LazyContext
+};

package/dist/snorre.es638.js

@@ -0,0 +1,9 @@
+import { createContext as o } from "react";
+const n = o({
+  transformPagePoint: (t) => t,
+  isStatic: !1,
+  reducedMotion: "never"
+});
+export {
+  n as MotionConfigContext
+};

package/dist/snorre.es639.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = /* @__PURE__ */ t({});
+export {
+  e as MotionContext
+};

package/dist/snorre.es64.js

@@ -0,0 +1,6 @@
+import { j as o } from "./snorre.es329.js";
+import r from "./snorre.es360.js";
+const c = (t) => /* @__PURE__ */ o.jsx("svg", { viewBox: "0 0 24 24", ...t, children: /* @__PURE__ */ o.jsx("circle", { cx: "12", cy: "12", r: "4" }) }), s = r()(c);
+export {
+  s as default
+};

package/dist/snorre.es640.js

@@ -0,0 +1,13 @@
+import { useContext as o, useMemo as i } from "react";
+import { MotionContext as a } from "./snorre.es639.js";
+import { getCurrentTreeVariants as m } from "./snorre.es760.js";
+function C(t) {
+  const { initial: e, animate: n } = m(t, o(a));
+  return i(() => ({ initial: e, animate: n }), [r(e), r(n)]);
+}
+function r(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+export {
+  C as useCreateMotionContext
+};

package/dist/snorre.es641.js

@@ -0,0 +1,4 @@
+const e = typeof window < "u";
+export {
+  e as isBrowser
+};

package/dist/snorre.es642.js

@@ -0,0 +1,27 @@
+const n = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, t = {};
+for (const e in n)
+  t[e] = {
+    isEnabled: (o) => n[e].some((a) => !!o[a])
+  };
+export {
+  t as featureDefinitions
+};

package/dist/snorre.es643.js

@@ -0,0 +1,11 @@
+import { featureDefinitions as n } from "./snorre.es642.js";
+function e(i) {
+  for (const o in i)
+    n[o] = {
+      ...n[o],
+      ...i[o]
+    };
+}
+export {
+  e as loadFeatures
+};

package/dist/snorre.es644.js

@@ -0,0 +1,4 @@
+const o = Symbol.for("motionComponentSymbol");
+export {
+  o as motionComponentSymbol
+};

package/dist/snorre.es645.js

@@ -0,0 +1,18 @@
+import { useCallback as p } from "react";
+import { isRefObject as i } from "./snorre.es761.js";
+function b(r, u, f) {
+  return p(
+    (o) => {
+      o && r.onMount && r.onMount(o), u && (o ? u.mount(o) : u.unmount()), f && (typeof f == "function" ? f(o) : i(f) && (f.current = o));
+    },
+    /**
+     * Only pass a new ref callback to React if we've received a visual element
+     * factory. Otherwise we'll be mounting/remounting every time externalRef
+     * or other dependencies change.
+     */
+    [u]
+  );
+}
+export {
+  b as useMotionRef
+};

package/dist/snorre.es646.js

@@ -0,0 +1,64 @@
+import { useContext as f, useRef as C, useInsertionEffect as j, useEffect as I } from "react";
+import { PresenceContext as h } from "./snorre.es635.js";
+import { MotionContext as A } from "./snorre.es639.js";
+import { useIsomorphicLayoutEffect as S } from "./snorre.es598.js";
+import { LazyContext as b } from "./snorre.es637.js";
+import { MotionConfigContext as v } from "./snorre.es638.js";
+import { optimizedAppearDataAttribute as L } from "./snorre.es685.js";
+import { microtask as k } from "./snorre.es762.js";
+import { isRefObject as H } from "./snorre.es761.js";
+import { SwitchLayoutGroupContext as R } from "./snorre.es687.js";
+function J(o, u, e, i, c) {
+  var n, a;
+  const { visualElement: s } = f(A), l = f(b), r = f(h), g = f(v).reducedMotion, d = C(null);
+  i = i || l.renderer, !d.current && i && (d.current = i(o, {
+    visualState: u,
+    parent: s,
+    props: e,
+    presenceContext: r,
+    blockInitialAnimation: r ? r.initial === !1 : !1,
+    reducedMotionConfig: g
+  }));
+  const t = d.current, x = f(R);
+  t && !t.projection && c && (t.type === "html" || t.type === "svg") && z(d.current, e, c, x);
+  const y = C(!1);
+  j(() => {
+    t && y.current && t.update(e, r);
+  });
+  const m = e[L], p = C(!!m && !(!((n = window.MotionHandoffIsComplete) === null || n === void 0) && n.call(window, m)) && ((a = window.MotionHasOptimisedAnimation) === null || a === void 0 ? void 0 : a.call(window, m)));
+  return S(() => {
+    t && (y.current = !0, window.MotionIsMounted = !0, t.updateFeatures(), k.render(t.render), p.current && t.animationState && t.animationState.animateChanges());
+  }), I(() => {
+    t && (!p.current && t.animationState && t.animationState.animateChanges(), p.current && (queueMicrotask(() => {
+      var w;
+      (w = window.MotionHandoffMarkAsComplete) === null || w === void 0 || w.call(window, m);
+    }), p.current = !1));
+  }), t;
+}
+function z(o, u, e, i) {
+  const { layoutId: c, layout: n, drag: a, dragConstraints: s, layoutScroll: l, layoutRoot: r } = u;
+  o.projection = new e(o.latestValues, u["data-framer-portal-id"] ? void 0 : M(o.parent)), o.projection.setOptions({
+    layoutId: c,
+    layout: n,
+    alwaysMeasureLayout: !!a || s && H(s),
+    visualElement: o,
+    /**
+     * TODO: Update options in an effect. This could be tricky as it'll be too late
+     * to update by the time layout animations run.
+     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
+     * ensuring it gets called if there's no potential layout animations.
+     *
+     */
+    animationType: typeof n == "string" ? n : "both",
+    initialPromotionConfig: i,
+    layoutScroll: l,
+    layoutRoot: r
+  });
+}
+function M(o) {
+  if (o)
+    return o.options.allowProjection !== !1 ? o.projection : M(o.parent);
+}
+export {
+  J as useVisualElement
+};

package/dist/snorre.es647.js

@@ -0,0 +1,38 @@
+const a = /* @__PURE__ */ new Set([
+  "animate",
+  "exit",
+  "variants",
+  "initial",
+  "style",
+  "values",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "custom",
+  "inherit",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "_dragX",
+  "_dragY",
+  "onHoverStart",
+  "onHoverEnd",
+  "onViewportEnter",
+  "onViewportLeave",
+  "globalTapTarget",
+  "ignoreStrict",
+  "viewport"
+]);
+function n(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || a.has(t);
+}
+export {
+  n as isValidMotionProp
+};

package/dist/snorre.es648.js

@@ -0,0 +1,10 @@
+import { isCSSVariableName as a } from "./snorre.es649.js";
+const o = {};
+function t(e) {
+  for (const r in e)
+    o[r] = e[r], a(r) && (o[r].isCSSVariable = !0);
+}
+export {
+  t as addScaleCorrector,
+  o as scaleCorrectors
+};

package/dist/snorre.es649.js

@@ -0,0 +1,5 @@
+const r = (s) => (t) => typeof t == "string" && t.startsWith(s), a = /* @__PURE__ */ r("--"), e = /* @__PURE__ */ r("var(--"), n = (s) => e(s) ? i.test(s.split("/*")[0].trim()) : !1, i = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+export {
+  a as isCSSVariableName,
+  n as isCSSVariableToken
+};

package/dist/snorre.es65.js

@@ -0,0 +1,6 @@
+import { j as t } from "./snorre.es329.js";
+import n from "./snorre.es360.js";
+const r = (o) => /* @__PURE__ */ t.jsx("svg", { viewBox: "0 0 24 24", ...o, children: /* @__PURE__ */ t.jsx("path", { d: "M12,8 C14.209139,8 16,9.790861 16,12 C16,14.209139 14.209139,16 12,16 C9.790861,16 8,14.209139 8,12 C8,9.790861 9.790861,8 12,8 Z M12,9 C10.3431458,9 9,10.3431458 9,12 C9,13.6568542 10.3431458,15 12,15 C13.6568542,15 15,13.6568542 15,12 C15,10.3431458 13.6568542,9 12,9 Z" }) }), i = n()(r);
+export {
+  i as default
+};

package/dist/snorre.es650.js

@@ -0,0 +1,31 @@
+import { getValueAsType as m } from "./snorre.es651.js";
+import { numberValueTypes as p } from "./snorre.es652.js";
+import { transformPropOrder as l } from "./snorre.es653.js";
+const y = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, v = l.length;
+function A(u, i, s) {
+  let e = "", o = !0;
+  for (let a = 0; a < v; a++) {
+    const t = l[a], r = u[t];
+    if (r === void 0)
+      continue;
+    let n = !0;
+    if (typeof r == "number" ? n = r === (t.startsWith("scale") ? 1 : 0) : n = parseFloat(r) === 0, !n || s) {
+      const f = m(r, p[t]);
+      if (!n) {
+        o = !1;
+        const c = y[t] || t;
+        e += `${c}(${f}) `;
+      }
+      s && (i[t] = f);
+    }
+  }
+  return e = e.trim(), s ? e = s(i, o ? "" : e) : o && (e = "none"), e;
+}
+export {
+  A as buildTransform
+};

package/dist/snorre.es651.js

@@ -0,0 +1,4 @@
+const e = (r, t) => t && typeof r == "number" ? t.transform(r) : r;
+export {
+  e as getValueAsType
+};

package/dist/snorre.es652.js

@@ -0,0 +1,18 @@
+import { alpha as r } from "./snorre.es766.js";
+import { px as e } from "./snorre.es680.js";
+import { browserNumberValueTypes as m } from "./snorre.es767.js";
+import { transformValueTypes as p } from "./snorre.es768.js";
+import { int as o } from "./snorre.es769.js";
+const l = {
+  ...m,
+  ...p,
+  zIndex: o,
+  size: e,
+  // SVG
+  fillOpacity: r,
+  strokeOpacity: r,
+  numOctaves: o
+};
+export {
+  l as numberValueTypes
+};

package/dist/snorre.es653.js

@@ -0,0 +1,23 @@
+const t = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], e = new Set(t);
+export {
+  t as transformPropOrder,
+  e as transformProps
+};

package/dist/snorre.es654.js

@@ -0,0 +1,4 @@
+const e = /* @__PURE__ */ new WeakMap();
+export {
+  e as visualElementStore
+};