@vkzstudio/muza-ui 1.0.0 → 1.0.1

package/dist/node_modules/framer-motion/dist/es/projection/shared/stack.js

@@ -0,0 +1,58 @@
+import { addUniqueItem as a, removeItem as o } from "../../../../../motion-utils/dist/es/array.js";
+class n {
+  constructor() {
+    this.members = [];
+  }
+  add(e) {
+    a(this.members, e), e.scheduleRender();
+  }
+  remove(e) {
+    if (o(this.members, e), e === this.prevLead && (this.prevLead = void 0), e === this.lead) {
+      const t = this.members[this.members.length - 1];
+      t && this.promote(t);
+    }
+  }
+  relegate(e) {
+    const t = this.members.findIndex((i) => e === i);
+    if (t === 0)
+      return !1;
+    let s;
+    for (let i = t; i >= 0; i--) {
+      const r = this.members[i];
+      if (r.isPresent !== !1) {
+        s = r;
+        break;
+      }
+    }
+    return s ? (this.promote(s), !0) : !1;
+  }
+  promote(e, t) {
+    const s = this.lead;
+    if (e !== s && (this.prevLead = s, this.lead = e, e.show(), s)) {
+      s.instance && s.scheduleRender(), e.scheduleRender(), e.resumeFrom = s, t && (e.resumeFrom.preserveOpacity = !0), s.snapshot && (e.snapshot = s.snapshot, e.snapshot.latestValues = s.animationValues || s.latestValues), e.root && e.root.isUpdating && (e.isLayoutDirty = !0);
+      const { crossfade: i } = e.options;
+      i === !1 && s.hide();
+    }
+  }
+  exitAnimationComplete() {
+    this.members.forEach((e) => {
+      const { options: t, resumingFrom: s } = e;
+      t.onExitComplete && t.onExitComplete(), s && s.options.onExitComplete && s.options.onExitComplete();
+    });
+  }
+  scheduleRender() {
+    this.members.forEach((e) => {
+      e.instance && e.scheduleRender(!1);
+    });
+  }
+  /**
+   * Clear any leads that have been removed this render to prevent them from being
+   * used in future animations and to prevent memory leaks
+   */
+  removeLeadSnapshot() {
+    this.lead && this.lead.snapshot && (this.lead.snapshot = void 0);
+  }
+}
+export {
+  n as NodeStack
+};

package/dist/node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.js

@@ -0,0 +1,21 @@
+import { px as c } from "../../../../../motion-dom/dist/es/value/types/numbers/units.js";
+function e(r, n) {
+  return n.max === n.min ? 0 : r / (n.max - n.min) * 100;
+}
+const f = {
+  correct: (r, n) => {
+    if (!n.target)
+      return r;
+    if (typeof r == "string")
+      if (c.test(r))
+        r = parseFloat(r);
+      else
+        return r;
+    const o = e(r, n.target.x), t = e(r, n.target.y);
+    return `${o}% ${t}%`;
+  }
+};
+export {
+  f as correctBorderRadius,
+  e as pixelsToPercent
+};

package/dist/node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.js

@@ -0,0 +1,16 @@
+import { complex as f } from "../../../../../motion-dom/dist/es/value/types/complex/index.js";
+import { mixNumber as i } from "../../../../../motion-dom/dist/es/utils/mix/number.js";
+const y = {
+  correct: (e, { treeScale: c, projectionDelta: t }) => {
+    const a = e, o = f.parse(e);
+    if (o.length > 5)
+      return a;
+    const p = f.createTransformer(e), r = typeof o[0] != "number" ? 1 : 0, n = t.x.scale * c.x, m = t.y.scale * c.y;
+    o[0 + r] /= n, o[1 + r] /= m;
+    const s = i(n, m, 0.5);
+    return typeof o[2 + r] == "number" && (o[2 + r] /= s), typeof o[3 + r] == "number" && (o[3 + r] /= s), p(o);
+  }
+};
+export {
+  y as correctBoxShadow
+};

package/dist/node_modules/framer-motion/dist/es/projection/styles/scale-correction.js

@@ -0,0 +1,10 @@
+import { isCSSVariableName as a } from "../../../../../motion-dom/dist/es/animation/utils/is-css-variable.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/node_modules/framer-motion/dist/es/projection/styles/transform.js

@@ -0,0 +1,13 @@
+function X(e, t, i) {
+  let n = "";
+  const o = e.x.translate / t.x, $ = e.y.translate / t.y, s = (i == null ? void 0 : i.z) || 0;
+  if ((o || $ || s) && (n = `translate3d(${o}px, ${$}px, ${s}px) `), (t.x !== 1 || t.y !== 1) && (n += `scale(${1 / t.x}, ${1 / t.y}) `), i) {
+    const { transformPerspective: f, rotate: p, rotateX: y, rotateY: a, skewX: g, skewY: r } = i;
+    f && (n = `perspective(${f}px) ${n}`), p && (n += `rotate(${p}deg) `), y && (n += `rotateX(${y}deg) `), a && (n += `rotateY(${a}deg) `), g && (n += `skewX(${g}deg) `), r && (n += `skewY(${r}deg) `);
+  }
+  const x = e.x.scale * t.x, c = e.y.scale * t.y;
+  return (x !== 1 || c !== 1) && (n += `scale(${x}, ${c})`), n || "none";
+}
+export {
+  X as buildProjectionTransform
+};

package/dist/node_modules/framer-motion/dist/es/projection/utils/each-axis.js

@@ -0,0 +1,6 @@
+function n(e) {
+  return [e("x"), e("y")];
+}
+export {
+  n as eachAxis
+};

package/dist/node_modules/framer-motion/dist/es/projection/utils/has-transform.js

@@ -0,0 +1,20 @@
+function t(n) {
+  return n === void 0 || n === 1;
+}
+function e({ scale: n, scaleX: o, scaleY: i }) {
+  return !t(n) || !t(o) || !t(i);
+}
+function c(n) {
+  return e(n) || f(n) || n.z || n.rotate || n.rotateX || n.rotateY || n.skewX || n.skewY;
+}
+function f(n) {
+  return r(n.x) || r(n.y);
+}
+function r(n) {
+  return n && n !== "0%";
+}
+export {
+  f as has2DTranslate,
+  e as hasScale,
+  c as hasTransform
+};

package/dist/node_modules/framer-motion/dist/es/projection/utils/measure.js

@@ -0,0 +1,13 @@
+import { convertBoundingBoxToBox as s, transformBoxPoints as f } from "../geometry/conversion.js";
+import { translateAxis as n } from "../geometry/delta-apply.js";
+function x(o, t) {
+  return s(f(o.getBoundingClientRect(), t));
+}
+function c(o, t, i) {
+  const r = x(o, i), { scroll: e } = t;
+  return e && (n(r.x, e.offset.x), n(r.y, e.offset.y)), r;
+}
+export {
+  c as measurePageBox,
+  x as measureViewportBox
+};

package/dist/node_modules/framer-motion/dist/es/render/VisualElement.js

@@ -0,0 +1,239 @@
+import { featureDefinitions as d } from "../motion/features/definitions.js";
+import { createBox as v } from "../projection/geometry/models.js";
+import { initPrefersReducedMotion as g } from "../utils/reduced-motion/index.js";
+import { hasReducedMotionListener as C, prefersReducedMotion as M } from "../utils/reduced-motion/state.js";
+import { visualElementStore as S } from "./store.js";
+import { isControllingVariants as b, isVariantNode as T } from "./utils/is-controlling-variants.js";
+import { updateMotionValuesFromProps as P } from "./utils/motion-values.js";
+import { resolveVariantFromProps as w } from "./utils/resolve-variants.js";
+import { KeyframeResolver as F } from "../../../../motion-dom/dist/es/animation/keyframes/KeyframesResolver.js";
+import { time as B } from "../../../../motion-dom/dist/es/frameloop/sync-time.js";
+import { frame as p, cancelFrame as c } from "../../../../motion-dom/dist/es/frameloop/frame.js";
+import { isMotionValue as h } from "../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+import { warnOnce as N } from "../../../../motion-utils/dist/es/warn-once.js";
+import { transformProps as R } from "../../../../motion-dom/dist/es/render/utils/keys-transform.js";
+import { motionValue as E } from "../../../../motion-dom/dist/es/value/index.js";
+import { isNumericalString as x } from "../../../../motion-utils/dist/es/is-numerical-string.js";
+import { isZeroValueString as A } from "../../../../motion-utils/dist/es/is-zero-value-string.js";
+import { findValueType as j } from "../../../../motion-dom/dist/es/value/types/utils/find.js";
+import { complex as y } from "../../../../motion-dom/dist/es/value/types/complex/index.js";
+import { getAnimatableNone as I } from "../../../../motion-dom/dist/es/value/types/utils/animatable-none.js";
+import { SubscriptionManager as U } from "../../../../motion-utils/dist/es/subscription-manager.js";
+import { microtask as D } from "../../../../motion-dom/dist/es/frameloop/microtask.js";
+const f = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+class ht {
+  /**
+   * 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, i) {
+    return {};
+  }
+  constructor({ parent: t, props: e, presenceContext: i, reducedMotionConfig: s, blockInitialAnimation: r, visualState: n }, m = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = F, 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 = B.now();
+      this.renderScheduledAt < o && (this.renderScheduledAt = o, p.render(this.render, !1, !0));
+    };
+    const { latestValues: a, renderState: V } = n;
+    this.latestValues = a, this.baseTarget = { ...a }, this.initialValues = e.initial ? { ...a } : {}, this.renderState = V, this.parent = t, this.props = e, this.presenceContext = i, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = s, this.options = m, this.blockInitialAnimation = !!r, this.isControllingVariants = b(e), this.isVariantNode = T(e), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(t && t.current);
+    const { willChange: O, ...u } = this.scrapeMotionValuesFromProps(e, {}, this);
+    for (const o in u) {
+      const l = u[o];
+      a[o] !== void 0 && h(l) && l.set(a[o]);
+    }
+  }
+  mount(t) {
+    var e;
+    this.current = t, S.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((i, s) => this.bindToMotionValue(s, i)), C.current || g(), this.shouldReduceMotion = this.reducedMotionConfig === "never" ? !1 : this.reducedMotionConfig === "always" ? !0 : M.current, process.env.NODE_ENV !== "production" && N(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled"), (e = this.parent) == null || e.addChild(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    var t;
+    this.projection && this.projection.unmount(), c(this.notifyUpdate), c(this.render), this.valueSubscriptions.forEach((e) => e()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), (t = this.parent) == null || t.removeChild(this);
+    for (const e in this.events)
+      this.events[e].clear();
+    for (const e in this.features) {
+      const i = this.features[e];
+      i && (i.unmount(), i.isMounted = !1);
+    }
+    this.current = null;
+  }
+  addChild(t) {
+    this.children.add(t), this.enteringChildren ?? (this.enteringChildren = /* @__PURE__ */ new Set()), this.enteringChildren.add(t);
+  }
+  removeChild(t) {
+    this.children.delete(t), this.enteringChildren && this.enteringChildren.delete(t);
+  }
+  bindToMotionValue(t, e) {
+    this.valueSubscriptions.has(t) && this.valueSubscriptions.get(t)();
+    const i = R.has(t);
+    i && this.onBindTransform && this.onBindTransform();
+    const s = e.on("change", (n) => {
+      this.latestValues[t] = n, this.props.onUpdate && p.preRender(this.notifyUpdate), i && this.projection && (this.projection.isTransformDirty = !0), this.scheduleRender();
+    });
+    let r;
+    window.MotionCheckAppearSync && (r = window.MotionCheckAppearSync(this, t, e)), this.valueSubscriptions.set(t, () => {
+      s(), r && r(), 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: i, Feature: s } = e;
+      if (!this.features[t] && s && i(this.props) && (this.features[t] = new s(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) : v();
+  }
+  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 i = 0; i < f.length; i++) {
+      const s = f[i];
+      this.propEventSubscriptions[s] && (this.propEventSubscriptions[s](), delete this.propEventSubscriptions[s]);
+      const r = "on" + s, n = t[r];
+      n && (this.propEventSubscriptions[s] = this.on(s, n));
+    }
+    this.prevMotionValues = P(this, this.scrapeMotionValuesFromProps(t, this.prevProps, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  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 i = this.values.get(t);
+    e !== i && (i && 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 i = this.values.get(t);
+    return i === void 0 && e !== void 0 && (i = E(e === null ? void 0 : e, { owner: this }), this.addValue(t, i)), i;
+  }
+  /**
+   * 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) {
+    let i = this.latestValues[t] !== void 0 || !this.current ? this.latestValues[t] : this.getBaseTargetFromProps(this.props, t) ?? this.readValueFromInstance(this.current, t, this.options);
+    return i != null && (typeof i == "string" && (x(i) || A(i)) ? i = parseFloat(i) : !j(i) && y.test(e) && (i = I(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 r;
+    const { initial: e } = this.props;
+    let i;
+    if (typeof e == "string" || typeof e == "object") {
+      const n = w(this.props, e, (r = this.presenceContext) == null ? void 0 : r.custom);
+      n && (i = n[t]);
+    }
+    if (e && i !== void 0)
+      return i;
+    const s = this.getBaseTargetFromProps(this.props, t);
+    return s !== void 0 && !h(s) ? s : this.initialValues[t] !== void 0 && i === void 0 ? void 0 : this.baseTarget[t];
+  }
+  on(t, e) {
+    return this.events[t] || (this.events[t] = new U()), this.events[t].add(e);
+  }
+  notify(t, ...e) {
+    this.events[t] && this.events[t].notify(...e);
+  }
+  scheduleRenderMicrotask() {
+    D.render(this.render);
+  }
+}
+export {
+  ht as VisualElement
+};

package/dist/node_modules/framer-motion/dist/es/render/components/create-proxy.js

@@ -0,0 +1,18 @@
+import { createMotionComponent as e } from "../../motion/index.js";
+import { warnOnce as a } from "../../../../../motion-utils/dist/es/warn-once.js";
+function u(r, c) {
+  if (typeof Proxy > "u")
+    return e;
+  const o = /* @__PURE__ */ new Map(), i = (n, t) => e(n, t, r, c), f = (n, t) => (process.env.NODE_ENV !== "production" && a(!1, "motion() is deprecated. Use motion.create() instead."), i(n, t));
+  return new Proxy(f, {
+    /**
+     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+     * The prop name is passed through as `key` and we can use that to generate a `motion`
+     * DOM component with that name.
+     */
+    get: (n, t) => t === "create" ? i : (o.has(t) || o.set(t, e(t, void 0, r, c)), o.get(t))
+  });
+}
+export {
+  u as createMotionProxy
+};

package/dist/node_modules/framer-motion/dist/es/render/components/motion/feature-bundle.js

@@ -0,0 +1,13 @@
+import { animations as o } from "../../../motion/features/animations.js";
+import { drag as r } from "../../../motion/features/drag.js";
+import { gestureAnimations as t } from "../../../motion/features/gestures.js";
+import { layout as m } from "../../../motion/features/layout.js";
+const f = {
+  ...o,
+  ...t,
+  ...r,
+  ...m
+};
+export {
+  f as featureBundle
+};

package/dist/node_modules/framer-motion/dist/es/render/components/motion/proxy.js

@@ -0,0 +1,7 @@
+import { createDomVisualElement as o } from "../../dom/create-visual-element.js";
+import { createMotionProxy as r } from "../create-proxy.js";
+import { featureBundle as t } from "./feature-bundle.js";
+const n = /* @__PURE__ */ r(t, o);
+export {
+  n as motion
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.js

@@ -0,0 +1,27 @@
+import { VisualElement as r } from "../VisualElement.js";
+import { DOMKeyframesResolver as o } from "../../../../../motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.js";
+import { isMotionValue as s } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+class a extends r {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = o;
+  }
+  sortInstanceNodePosition(e, t) {
+    return e.compareDocumentPosition(t) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(e, t) {
+    return e.style ? e.style[t] : void 0;
+  }
+  removeValueFromRenderState(e, { vars: t, style: i }) {
+    delete t[e], delete i[e];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: e } = this.props;
+    s(e) && (this.childSubscription = e.on("change", (t) => {
+      this.current && (this.current.textContent = `${t}`);
+    }));
+  }
+}
+export {
+  a as DOMVisualElement
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/create-visual-element.js

@@ -0,0 +1,10 @@
+import { Fragment as m } from "react";
+import { HTMLVisualElement as o } from "../html/HTMLVisualElement.js";
+import { SVGVisualElement as t } from "../svg/SVGVisualElement.js";
+import { isSVGComponent as i } from "./utils/is-svg-component.js";
+const f = (e, r) => i(e) ? new t(r) : new o(r, {
+  allowProjection: e !== m
+});
+export {
+  f as createDomVisualElement
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/use-render.js

@@ -0,0 +1,16 @@
+import { Fragment as c, useMemo as p, createElement as P } from "react";
+import { useHTMLProps as a } from "../html/use-props.js";
+import { useSVGProps as d } from "../svg/use-props.js";
+import { filterProps as V } from "./utils/filter-props.js";
+import { isSVGComponent as g } from "./utils/is-svg-component.js";
+import { isMotionValue as h } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+function F(r, s, o, { latestValues: t }, i, m = !1) {
+  const n = (g(r) ? d : a)(s, t, i, r), l = V(s, typeof r == "string", m), u = r !== c ? { ...l, ...n, ref: o } : {}, { children: e } = s, f = p(() => h(e) ? e.get() : e, [e]);
+  return P(r, {
+    ...u,
+    children: f
+  });
+}
+export {
+  F as useRender
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.js

@@ -0,0 +1,4 @@
+const a = (e) => e.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase();
+export {
+  a as camelToDash
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/utils/filter-props.js

@@ -0,0 +1,20 @@
+import { isValidMotionProp as e } from "../../../motion/utils/valid-prop.js";
+let i = (t) => !e(t);
+function f(t) {
+  typeof t == "function" && (i = (o) => o.startsWith("on") ? !e(o) : t(o));
+}
+try {
+  f(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function l(t, o, a) {
+  const n = {};
+  for (const r in t)
+    r === "values" && typeof t.values == "object" || (i(r) || a === !0 && e(r) || !o && !e(r) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && r.startsWith("onDrag")) && (n[r] = t[r]);
+  return n;
+}
+export {
+  l as filterProps,
+  f as loadExternalIsValidProp
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.js

@@ -0,0 +1,24 @@
+import { lowercaseSVGElements as r } from "../../svg/lowercase-elements.js";
+function s(e) {
+  return (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof e != "string" || /**
+     * If it contains a dash, the element is a custom HTML webcomponent.
+     */
+    e.includes("-") ? !1 : (
+      /**
+       * If it's in our list of lowercase SVG tags, it's an SVG component
+       */
+      !!(r.indexOf(e) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/u.test(e))
+    )
+  );
+}
+export {
+  s as isSVGComponent
+};

package/dist/node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.js

@@ -0,0 +1,38 @@
+import { measureViewportBox as n } from "../../projection/utils/measure.js";
+import { DOMVisualElement as a } from "../dom/DOMVisualElement.js";
+import { buildHTMLStyles as i } from "./utils/build-styles.js";
+import { renderHTML as u } from "./utils/render.js";
+import { scrapeMotionValuesFromProps as p } from "./utils/scrape-motion-values.js";
+import { transformProps as l } from "../../../../../motion-dom/dist/es/render/utils/keys-transform.js";
+import { defaultTransformValue as f, readTransformValue as c } from "../../../../../motion-dom/dist/es/render/dom/parse-transform.js";
+import { isCSSVariableName as d } from "../../../../../motion-dom/dist/es/animation/utils/is-css-variable.js";
+function V(m) {
+  return window.getComputedStyle(m);
+}
+class b extends a {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = u;
+  }
+  readValueFromInstance(e, r) {
+    var t;
+    if (l.has(r))
+      return (t = this.projection) != null && t.isProjecting ? f(r) : c(e, r);
+    {
+      const s = V(e), o = (d(r) ? s.getPropertyValue(r) : s[r]) || 0;
+      return typeof o == "string" ? o.trim() : o;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: r }) {
+    return n(e, r);
+  }
+  build(e, r, t) {
+    i(e, r, t.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, r, t) {
+    return p(e, r, t);
+  }
+}
+export {
+  b as HTMLVisualElement,
+  V as getComputedStyle
+};

package/dist/node_modules/framer-motion/dist/es/render/html/use-html-visual-state.js

@@ -0,0 +1,10 @@
+import { makeUseVisualState as e } from "../../motion/utils/use-visual-state.js";
+import { createHtmlRenderState as t } from "./utils/create-render-state.js";
+import { scrapeMotionValuesFromProps as r } from "./utils/scrape-motion-values.js";
+const s = /* @__PURE__ */ e({
+  scrapeMotionValuesFromProps: r,
+  createRenderState: t
+});
+export {
+  s as useHTMLVisualState
+};

package/dist/node_modules/framer-motion/dist/es/render/html/use-props.js

@@ -0,0 +1,27 @@
+import { useMemo as i } from "react";
+import { isForcedMotionValue as a } from "../../motion/utils/is-forced-motion-value.js";
+import { buildHTMLStyles as r } from "./utils/build-styles.js";
+import { createHtmlRenderState as l } from "./utils/create-render-state.js";
+import { isMotionValue as s } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+function u(t, o, n) {
+  for (const e in o)
+    !s(o[e]) && !a(e, n) && (t[e] = o[e]);
+}
+function c({ transformTemplate: t }, o) {
+  return i(() => {
+    const n = l();
+    return r(n, o, t), Object.assign({}, n.vars, n.style);
+  }, [o]);
+}
+function f(t, o) {
+  const n = t.style || {}, e = {};
+  return u(e, n, t), Object.assign(e, c(t, o)), e;
+}
+function M(t, o) {
+  const n = {}, e = f(t, o);
+  return t.drag && t.dragListener !== !1 && (n.draggable = !1, e.userSelect = e.WebkitUserSelect = e.WebkitTouchCallout = "none", e.touchAction = t.drag === !0 ? "none" : `pan-${t.drag === "x" ? "y" : "x"}`), t.tabIndex === void 0 && (t.onTap || t.onTapStart || t.whileTap) && (n.tabIndex = 0), n.style = e, n;
+}
+export {
+  u as copyRawValuesOnly,
+  M as useHTMLProps
+};