@bbl-digital/snorre 4.2.86 → 4.2.88

package/dist/snorre.es655.js

@@ -0,0 +1,228 @@
+import { time as g } from "./snorre.es656.js";
+import { featureDefinitions as d } from "./snorre.es642.js";
+import { createBox as M } from "./snorre.es657.js";
+import { isNumericalString as S } from "./snorre.es658.js";
+import { isZeroValueString as C } from "./snorre.es659.js";
+import { initPrefersReducedMotion as b } from "./snorre.es660.js";
+import { hasReducedMotionListener as T, prefersReducedMotion as P } from "./snorre.es661.js";
+import { SubscriptionManager as w } from "./snorre.es662.js";
+import { warnOnce as F } from "./snorre.es663.js";
+import { motionValue as R } from "./snorre.es664.js";
+import { complex as B } from "./snorre.es665.js";
+import { isMotionValue as h } from "./snorre.es603.js";
+import { getAnimatableNone as N } from "./snorre.es666.js";
+import { findValueType as E } from "./snorre.es667.js";
+import { transformProps as x } from "./snorre.es653.js";
+import { visualElementStore as A } from "./snorre.es654.js";
+import { isControllingVariants as U, isVariantNode as j } from "./snorre.es668.js";
+import { KeyframeResolver as y } from "./snorre.es623.js";
+import { updateMotionValuesFromProps as I } from "./snorre.es669.js";
+import { resolveVariantFromProps as _ } from "./snorre.es670.js";
+import { frame as f, cancelFrame as c } from "./snorre.es671.js";
+const m = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+class at {
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(t, e, s) {
+    return {};
+  }
+  constructor({ parent: t, props: e, presenceContext: s, reducedMotionConfig: i, blockInitialAnimation: r, visualState: n }, u = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = y, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
+      const o = g.now();
+      this.renderScheduledAt < o && (this.renderScheduledAt = o, f.render(this.render, !1, !0));
+    };
+    const { latestValues: a, renderState: V, onUpdate: v } = n;
+    this.onUpdate = v, this.latestValues = a, this.baseTarget = { ...a }, this.initialValues = e.initial ? { ...a } : {}, this.renderState = V, this.parent = t, this.props = e, this.presenceContext = s, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = i, this.options = u, this.blockInitialAnimation = !!r, this.isControllingVariants = U(e), this.isVariantNode = j(e), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(t && t.current);
+    const { willChange: L, ...l } = this.scrapeMotionValuesFromProps(e, {}, this);
+    for (const o in l) {
+      const p = l[o];
+      a[o] !== void 0 && h(p) && p.set(a[o], !1);
+    }
+  }
+  mount(t) {
+    this.current = t, A.set(t, this), this.projection && !this.projection.instance && this.projection.mount(t), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((e, s) => this.bindToMotionValue(s, e)), T.current || b(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : P.current, process.env.NODE_ENV !== "production" && F(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected."), this.parent && this.parent.children.add(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    this.projection && this.projection.unmount(), c(this.notifyUpdate), c(this.render), this.valueSubscriptions.forEach((t) => t()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), this.parent && this.parent.children.delete(this);
+    for (const t in this.events)
+      this.events[t].clear();
+    for (const t in this.features) {
+      const e = this.features[t];
+      e && (e.unmount(), e.isMounted = !1);
+    }
+    this.current = null;
+  }
+  bindToMotionValue(t, e) {
+    this.valueSubscriptions.has(t) && this.valueSubscriptions.get(t)();
+    const s = x.has(t);
+    s && this.onBindTransform && this.onBindTransform();
+    const i = e.on("change", (u) => {
+      this.latestValues[t] = u, this.props.onUpdate && f.preRender(this.notifyUpdate), s && this.projection && (this.projection.isTransformDirty = !0);
+    }), r = e.on("renderRequest", this.scheduleRender);
+    let n;
+    window.MotionCheckAppearSync && (n = window.MotionCheckAppearSync(this, t, e)), this.valueSubscriptions.set(t, () => {
+      i(), r(), n && n(), e.owner && e.stop();
+    });
+  }
+  sortNodePosition(t) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== t.type ? 0 : this.sortInstanceNodePosition(this.current, t.current);
+  }
+  updateFeatures() {
+    let t = "animation";
+    for (t in d) {
+      const e = d[t];
+      if (!e)
+        continue;
+      const { isEnabled: s, Feature: i } = e;
+      if (!this.features[t] && i && s(this.props) && (this.features[t] = new i(this)), this.features[t]) {
+        const r = this.features[t];
+        r.isMounted ? r.update() : (r.mount(), r.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : M();
+  }
+  getStaticValue(t) {
+    return this.latestValues[t];
+  }
+  setStaticValue(t, e) {
+    this.latestValues[t] = e;
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(t, e) {
+    (t.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = t, this.prevPresenceContext = this.presenceContext, this.presenceContext = e;
+    for (let s = 0; s < m.length; s++) {
+      const i = m[s];
+      this.propEventSubscriptions[i] && (this.propEventSubscriptions[i](), delete this.propEventSubscriptions[i]);
+      const r = "on" + i, n = t[r];
+      n && (this.propEventSubscriptions[i] = this.on(i, n));
+    }
+    this.prevMotionValues = I(this, this.scrapeMotionValuesFromProps(t, this.prevProps, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue(), this.onUpdate && this.onUpdate(this);
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(t) {
+    return this.props.variants ? this.props.variants[t] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(t) {
+    const e = this.getClosestVariantNode();
+    if (e)
+      return e.variantChildren && e.variantChildren.add(t), () => e.variantChildren.delete(t);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(t, e) {
+    const s = this.values.get(t);
+    e !== s && (s && this.removeValue(t), this.bindToMotionValue(t, e), this.values.set(t, e), this.latestValues[t] = e.get());
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(t) {
+    this.values.delete(t);
+    const e = this.valueSubscriptions.get(t);
+    e && (e(), this.valueSubscriptions.delete(t)), delete this.latestValues[t], this.removeValueFromRenderState(t, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(t) {
+    return this.values.has(t);
+  }
+  getValue(t, e) {
+    if (this.props.values && this.props.values[t])
+      return this.props.values[t];
+    let s = this.values.get(t);
+    return s === void 0 && e !== void 0 && (s = R(e === null ? void 0 : e, { owner: this }), this.addValue(t, s)), s;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(t, e) {
+    var s;
+    let i = this.latestValues[t] !== void 0 || !this.current ? this.latestValues[t] : (s = this.getBaseTargetFromProps(this.props, t)) !== null && s !== void 0 ? s : this.readValueFromInstance(this.current, t, this.options);
+    return i != null && (typeof i == "string" && (S(i) || C(i)) ? i = parseFloat(i) : !E(i) && B.test(e) && (i = N(t, e)), this.setBaseTarget(t, h(i) ? i.get() : i)), h(i) ? i.get() : i;
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(t, e) {
+    this.baseTarget[t] = e;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(t) {
+    var e;
+    const { initial: s } = this.props;
+    let i;
+    if (typeof s == "string" || typeof s == "object") {
+      const n = _(this.props, s, (e = this.presenceContext) === null || e === void 0 ? void 0 : e.custom);
+      n && (i = n[t]);
+    }
+    if (s && i !== void 0)
+      return i;
+    const r = this.getBaseTargetFromProps(this.props, t);
+    return r !== void 0 && !h(r) ? r : this.initialValues[t] !== void 0 && i === void 0 ? void 0 : this.baseTarget[t];
+  }
+  on(t, e) {
+    return this.events[t] || (this.events[t] = new w()), this.events[t].add(e);
+  }
+  notify(t, ...e) {
+    this.events[t] && this.events[t].notify(...e);
+  }
+}
+export {
+  at as VisualElement
+};

package/dist/snorre.es656.js

@@ -0,0 +1,15 @@
+import { MotionGlobalConfig as i } from "./snorre.es672.js";
+import { frameData as n } from "./snorre.es671.js";
+let e;
+function t() {
+  e = void 0;
+}
+const r = {
+  now: () => (e === void 0 && r.set(n.isProcessing || i.useManualTiming ? n.timestamp : performance.now()), e),
+  set: (o) => {
+    e = o, queueMicrotask(t);
+  }
+};
+export {
+  r as time
+};

package/dist/snorre.es657.js

@@ -0,0 +1,18 @@
+const t = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+}), a = () => ({
+  x: t(),
+  y: t()
+}), e = () => ({ min: 0, max: 0 }), c = () => ({
+  x: e(),
+  y: e()
+});
+export {
+  e as createAxis,
+  t as createAxisDelta,
+  c as createBox,
+  a as createDelta
+};

package/dist/snorre.es658.js

@@ -0,0 +1,4 @@
+const d = (t) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(t);
+export {
+  d as isNumericalString
+};

package/dist/snorre.es659.js

@@ -0,0 +1,4 @@
+const e = (t) => /^0[^.\s]+$/u.test(t);
+export {
+  e as isZeroValueString
+};

package/dist/snorre.es66.js

@@ -0,0 +1,6 @@
+import { j as o } from "./snorre.es329.js";
+import n from "./snorre.es360.js";
+const L = (t) => /* @__PURE__ */ o.jsx("svg", { viewBox: "0 0 24 24", ...t, children: /* @__PURE__ */ o.jsx("path", { d: "M5,20.5 L19,20.5 L19,18.5 L5,18.5 M19,9.5 L15,9.5 L15,3.5 L9,3.5 L9,9.5 L5,9.5 L12,16.5 L19,9.5 Z" }) }), a = n()(L);
+export {
+  a as default
+};

package/dist/snorre.es660.js

@@ -0,0 +1,13 @@
+import { isBrowser as o } from "./snorre.es641.js";
+import { hasReducedMotionListener as i, prefersReducedMotion as t } from "./snorre.es661.js";
+function c() {
+  if (i.current = !0, !!o)
+    if (window.matchMedia) {
+      const e = window.matchMedia("(prefers-reduced-motion)"), r = () => t.current = e.matches;
+      e.addListener(r), r();
+    } else
+      t.current = !1;
+}
+export {
+  c as initPrefersReducedMotion
+};

package/dist/snorre.es661.js

@@ -0,0 +1,5 @@
+const e = { current: null }, n = { current: !1 };
+export {
+  n as hasReducedMotionListener,
+  e as prefersReducedMotion
+};

package/dist/snorre.es662.js

@@ -0,0 +1,29 @@
+import { addUniqueItem as e, removeItem as u } from "./snorre.es689.js";
+class h {
+  constructor() {
+    this.subscriptions = [];
+  }
+  add(s) {
+    return e(this.subscriptions, s), () => u(this.subscriptions, s);
+  }
+  notify(s, r, n) {
+    const i = this.subscriptions.length;
+    if (i)
+      if (i === 1)
+        this.subscriptions[0](s, r, n);
+      else
+        for (let t = 0; t < i; t++) {
+          const o = this.subscriptions[t];
+          o && o(s, r, n);
+        }
+  }
+  getSize() {
+    return this.subscriptions.length;
+  }
+  clear() {
+    this.subscriptions.length = 0;
+  }
+}
+export {
+  h as SubscriptionManager
+};

package/dist/snorre.es663.js

@@ -0,0 +1,7 @@
+const e = /* @__PURE__ */ new Set();
+function o(r, n, t) {
+  r || e.has(n) || (console.warn(n), e.add(n));
+}
+export {
+  o as warnOnce
+};

package/dist/snorre.es664.js

@@ -0,0 +1,207 @@
+import { time as n } from "./snorre.es656.js";
+import { SubscriptionManager as o } from "./snorre.es662.js";
+import { velocityPerSecond as c } from "./snorre.es703.js";
+import { warnOnce as u } from "./snorre.es663.js";
+import { frame as p } from "./snorre.es671.js";
+const r = 30, f = (s) => !isNaN(parseFloat(s));
+class d {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   *
+   * @internal
+   */
+  constructor(t, e = {}) {
+    this.version = "12.4.13", this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (i, a = !0) => {
+      const h = n.now();
+      this.updatedAt !== h && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(i), this.current !== this.prev && this.events.change && this.events.change.notify(this.current), a && this.events.renderRequest && this.events.renderRequest.notify(this.current);
+    }, this.hasAnimated = !1, this.setCurrent(t), this.owner = e.owner;
+  }
+  setCurrent(t) {
+    this.current = t, this.updatedAt = n.now(), this.canTrackVelocity === null && t !== void 0 && (this.canTrackVelocity = f(this.current));
+  }
+  setPrevFrameValue(t = this.current) {
+    this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(t) {
+    return process.env.NODE_ENV !== "production" && u(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", t);
+  }
+  on(t, e) {
+    this.events[t] || (this.events[t] = new o());
+    const i = this.events[t].add(e);
+    return t === "change" ? () => {
+      i(), p.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : i;
+  }
+  clearListeners() {
+    for (const t in this.events)
+      this.events[t].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   *
+   * @internal
+   */
+  attach(t, e) {
+    this.passiveEffect = t, this.stopPassiveEffect = e;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(t, e = !0) {
+    !e || !this.passiveEffect ? this.updateAndNotify(t, e) : this.passiveEffect(t, this.updateAndNotify);
+  }
+  setWithVelocity(t, e, i) {
+    this.set(e), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - i;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(t, e = !0) {
+    this.updateAndNotify(t), this.prev = t, this.prevUpdatedAt = this.prevFrameValue = void 0, e && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const t = n.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || t - this.updatedAt > r)
+      return 0;
+    const e = Math.min(this.updatedAt - this.prevUpdatedAt, r);
+    return c(parseFloat(this.current) - parseFloat(this.prevFrameValue), e);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   *
+   * @internal
+   */
+  start(t) {
+    return this.stop(), new Promise((e) => {
+      this.hasAnimated = !0, this.animation = t(e), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy() {
+    this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function V(s, t) {
+  return new d(s, t);
+}
+export {
+  d as MotionValue,
+  V as motionValue
+};

package/dist/snorre.es665.js

@@ -0,0 +1,49 @@
+import { color as u } from "./snorre.es673.js";
+import { colorRegex as g } from "./snorre.es677.js";
+import { floatRegex as N } from "./snorre.es678.js";
+import { sanitize as b } from "./snorre.es679.js";
+function x(t) {
+  var e, o;
+  return isNaN(t) && typeof t == "string" && (((e = t.match(N)) === null || e === void 0 ? void 0 : e.length) || 0) + (((o = t.match(g)) === null || o === void 0 ? void 0 : o.length) || 0) > 0;
+}
+const p = "number", m = "color", T = "var", O = "var(", a = "${}", _ = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function f(t) {
+  const e = t.toString(), o = [], i = {
+    color: [],
+    number: [],
+    var: []
+  }, n = [];
+  let s = 0;
+  const l = e.replace(_, (c) => (u.test(c) ? (i.color.push(s), n.push(m), o.push(u.parse(c))) : c.startsWith(O) ? (i.var.push(s), n.push(T), o.push(c)) : (i.number.push(s), n.push(p), o.push(parseFloat(c))), ++s, a)).split(a);
+  return { values: o, split: l, indexes: i, types: n };
+}
+function h(t) {
+  return f(t).values;
+}
+function d(t) {
+  const { split: e, types: o } = f(t), i = e.length;
+  return (n) => {
+    let s = "";
+    for (let r = 0; r < i; r++)
+      if (s += e[r], n[r] !== void 0) {
+        const l = o[r];
+        l === p ? s += b(n[r]) : l === m ? s += u.transform(n[r]) : s += n[r];
+      }
+    return s;
+  };
+}
+const R = (t) => typeof t == "number" ? 0 : t;
+function y(t) {
+  const e = h(t);
+  return d(t)(e.map(R));
+}
+const A = {
+  test: x,
+  parse: h,
+  createTransformer: d,
+  getAnimatableNone: y
+};
+export {
+  f as analyseComplexValue,
+  A as complex
+};

package/dist/snorre.es666.js

@@ -0,0 +1,10 @@
+import { complex as n } from "./snorre.es665.js";
+import { filter as a } from "./snorre.es771.js";
+import { getDefaultValueType as i } from "./snorre.es772.js";
+function f(t, o) {
+  let e = i(t);
+  return e !== a && (e = n), e.getAnimatableNone ? e.getAnimatableNone(o) : void 0;
+}
+export {
+  f as getAnimatableNone
+};

package/dist/snorre.es667.js

@@ -0,0 +1,8 @@
+import { color as e } from "./snorre.es673.js";
+import { complex as m } from "./snorre.es665.js";
+import { dimensionValueTypes as p } from "./snorre.es753.js";
+import { testValueType as r } from "./snorre.es773.js";
+const t = [...p, e, m], s = (o) => t.find(r(o));
+export {
+  s as findValueType
+};

package/dist/snorre.es668.js

@@ -0,0 +1,13 @@
+import { isAnimationControls as o } from "./snorre.es723.js";
+import { isVariantLabel as r } from "./snorre.es774.js";
+import { variantProps as t } from "./snorre.es775.js";
+function a(i) {
+  return o(i.animate) || t.some((n) => r(i[n]));
+}
+function f(i) {
+  return !!(a(i) || i.variants);
+}
+export {
+  a as isControllingVariants,
+  f as isVariantNode
+};

package/dist/snorre.es669.js

@@ -0,0 +1,26 @@
+import { warnOnce as f } from "./snorre.es663.js";
+import { motionValue as n } from "./snorre.es664.js";
+import { isMotionValue as u } from "./snorre.es603.js";
+function c(i, t, s) {
+  for (const o in t) {
+    const e = t[o], r = s[o];
+    if (u(e))
+      i.addValue(o, e), process.env.NODE_ENV === "development" && f(e.version === "12.4.13", `Attempting to mix Motion versions ${e.version} with 12.4.13 may not work as expected.`);
+    else if (u(r))
+      i.addValue(o, n(e, { owner: i }));
+    else if (r !== e)
+      if (i.hasValue(o)) {
+        const a = i.getValue(o);
+        a.liveStyle === !0 ? a.jump(e) : a.hasAnimated || a.set(e);
+      } else {
+        const a = i.getStaticValue(o);
+        i.addValue(o, n(a !== void 0 ? a : e, { owner: i }));
+      }
+  }
+  for (const o in s)
+    t[o] === void 0 && i.removeValue(o);
+  return t;
+}
+export {
+  c as updateMotionValuesFromProps
+};

package/dist/snorre.es67.js

@@ -0,0 +1,6 @@
+import { j as t } from "./snorre.es329.js";
+import r from "./snorre.es360.js";
+const s = (o) => /* @__PURE__ */ t.jsx("svg", { viewBox: "0 0 24 24", ...o, children: /* @__PURE__ */ t.jsx("path", { d: "M21.99,6.86 L12,1 L2,6.86 L2,20 L22,20 L21.99,6.86 Z M12,13 L3.74,7.84 L12,3 L20.26,7.84 L12,13 Z" }) }), a = r()(s);
+export {
+  a as default
+};