@code0-tech/pictor 0.9.2 → 0.10.0

package/dist/node_modules/framer-motion/dist/es/motion/features/animation/index.js

@@ -0,0 +1,33 @@
+import { Feature as o } from "../../../../../../motion-dom/dist/es/render/Feature.js";
+import { createAnimationState as i } from "../../../../../../motion-dom/dist/es/render/utils/animation-state.js";
+import { isAnimationControls as s } from "../../../../../../motion-dom/dist/es/render/utils/is-animation-controls.js";
+class u extends o {
+  /**
+   * We dynamically generate the AnimationState manager as it contains a reference
+   * to the underlying animation library. We only want to load that if we load this,
+   * so people can optionally code split it out using the `m` component.
+   */
+  constructor(t) {
+    super(t), t.animationState || (t.animationState = i(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    s(t) && (this.unmountControls = t.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    t !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    this.node.animationState.reset(), this.unmountControls?.();
+  }
+}
+export {
+  u as AnimationFeature
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/animations.js

@@ -0,0 +1,13 @@
+import { AnimationFeature as t } from "./animation/index.js";
+import { ExitAnimationFeature as i } from "./animation/exit.js";
+const o = {
+  animation: {
+    Feature: t
+  },
+  exit: {
+    Feature: i
+  }
+};
+export {
+  o as animations
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/definitions.js

@@ -0,0 +1,39 @@
+import { getFeatureDefinitions as r, setFeatureDefinitions as s } from "../../../../../motion-dom/dist/es/render/VisualElement.js";
+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"]
+};
+let t = !1;
+function l() {
+  if (t)
+    return;
+  const e = {};
+  for (const i in n)
+    e[i] = {
+      isEnabled: (o) => n[i].some((a) => !!o[a])
+    };
+  s(e), t = !0;
+}
+function w() {
+  return l(), r();
+}
+export {
+  w as getInitializedFeatureDefinitions,
+  l as initFeatureDefinitions
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/drag.js

@@ -0,0 +1,17 @@
+import { DragGesture as r } from "../../gestures/drag/index.js";
+import { PanGesture as o } from "../../gestures/pan/index.js";
+import { MeasureLayout as e } from "./layout/MeasureLayout.js";
+import { HTMLProjectionNode as t } from "../../../../../motion-dom/dist/es/projection/node/HTMLProjectionNode.js";
+const u = {
+  pan: {
+    Feature: o
+  },
+  drag: {
+    Feature: r,
+    ProjectionNode: t,
+    MeasureLayout: e
+  }
+};
+export {
+  u as drag
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/gestures.js

@@ -0,0 +1,21 @@
+import { HoverGesture as e } from "../../gestures/hover.js";
+import { FocusGesture as r } from "../../gestures/focus.js";
+import { PressGesture as t } from "../../gestures/press.js";
+import { InViewFeature as o } from "./viewport/index.js";
+const a = {
+  inView: {
+    Feature: o
+  },
+  tap: {
+    Feature: t
+  },
+  focus: {
+    Feature: r
+  },
+  hover: {
+    Feature: e
+  }
+};
+export {
+  a as gestureAnimations
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.js

@@ -0,0 +1,60 @@
+import { jsx as m } from "react/jsx-runtime";
+import { useContext as u, Component as l } from "react";
+import { usePresence as c } from "../../../components/AnimatePresence/use-presence.js";
+import { LayoutGroupContext as f } from "../../../context/LayoutGroupContext.js";
+import { SwitchLayoutGroupContext as d } from "../../../context/SwitchLayoutGroupContext.js";
+import { frame as h } from "../../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { microtask as y } from "../../../../../../motion-dom/dist/es/frameloop/microtask.js";
+import { globalProjectionState as g } from "../../../../../../motion-dom/dist/es/projection/node/state.js";
+let i = !1;
+class v extends l {
+  /**
+   * This only mounts projection nodes for components that
+   * need measuring, we might want to do it for all components
+   * in order to incorporate transforms
+   */
+  componentDidMount() {
+    const { visualElement: t, layoutGroup: o, switchLayoutGroup: e, layoutId: s } = this.props, { projection: n } = t;
+    n && (o.group && o.group.add(n), e && e.register && s && e.register(n), i && n.root.didUpdate(), n.addEventListener("animationComplete", () => {
+      this.safeToRemove();
+    }), n.setOptions({
+      ...n.options,
+      layoutDependency: this.props.layoutDependency,
+      onExitComplete: () => this.safeToRemove()
+    })), g.hasEverUpdated = !0;
+  }
+  getSnapshotBeforeUpdate(t) {
+    const { layoutDependency: o, visualElement: e, drag: s, isPresent: n } = this.props, { projection: r } = e;
+    return r && (r.isPresent = n, t.layoutDependency !== o && r.setOptions({
+      ...r.options,
+      layoutDependency: o
+    }), i = !0, s || t.layoutDependency !== o || o === void 0 || t.isPresent !== n ? r.willUpdate() : this.safeToRemove(), t.isPresent !== n && (n ? r.promote() : r.relegate() || h.postRender(() => {
+      const p = r.getStack();
+      (!p || !p.members.length) && this.safeToRemove();
+    }))), null;
+  }
+  componentDidUpdate() {
+    const { visualElement: t, layoutAnchor: o } = this.props, { projection: e } = t;
+    e && (e.options.layoutAnchor = o, e.root.didUpdate(), y.postRender(() => {
+      !e.currentAnimation && e.isLead() && this.safeToRemove();
+    }));
+  }
+  componentWillUnmount() {
+    const { visualElement: t, layoutGroup: o, switchLayoutGroup: e } = this.props, { projection: s } = t;
+    i = !0, s && (s.scheduleCheckAfterUnmount(), o && o.group && o.group.remove(s), e && e.deregister && e.deregister(s));
+  }
+  safeToRemove() {
+    const { safeToRemove: t } = this.props;
+    t && t();
+  }
+  render() {
+    return null;
+  }
+}
+function E(a) {
+  const [t, o] = c(), e = u(f);
+  return m(v, { ...a, layoutGroup: e, switchLayoutGroup: u(d), isPresent: t, safeToRemove: o });
+}
+export {
+  E as MeasureLayout
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/layout.js

@@ -0,0 +1,11 @@
+import { MeasureLayout as o } from "./layout/MeasureLayout.js";
+import { HTMLProjectionNode as t } from "../../../../../motion-dom/dist/es/projection/node/HTMLProjectionNode.js";
+const a = {
+  layout: {
+    ProjectionNode: t,
+    MeasureLayout: o
+  }
+};
+export {
+  a as layout
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/load-features.js

@@ -0,0 +1,14 @@
+import { getInitializedFeatureDefinitions as o } from "./definitions.js";
+import { setFeatureDefinitions as n } from "../../../../../motion-dom/dist/es/render/VisualElement.js";
+function s(e) {
+  const i = o();
+  for (const t in e)
+    i[t] = {
+      ...i[t],
+      ...e[t]
+    };
+  n(i);
+}
+export {
+  s as loadFeatures
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/viewport/index.js

@@ -0,0 +1,45 @@
+import { observeIntersection as f } from "./observers.js";
+import { Feature as m } from "../../../../../../motion-dom/dist/es/render/Feature.js";
+const w = {
+  some: 0,
+  all: 1
+};
+class b extends m {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.stopObserver?.();
+    const { viewport: s = {} } = this.node.getProps(), { root: e, margin: r, amount: n = "some", once: h } = s, p = {
+      root: e ? e.current : void 0,
+      rootMargin: r,
+      threshold: typeof n == "number" ? n : w[n]
+    }, c = (i) => {
+      const { isIntersecting: t } = i;
+      if (this.isInView === t || (this.isInView = t, h && !t && this.hasEnteredView))
+        return;
+      t && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", t);
+      const { onViewportEnter: d, onViewportLeave: u } = this.node.getProps(), a = t ? d : u;
+      a && a(i);
+    };
+    this.stopObserver = f(this.node.current, p, c);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: s, prevProps: e } = this.node;
+    ["amount", "margin", "root"].some(l(s, e)) && this.startObserver();
+  }
+  unmount() {
+    this.stopObserver?.(), this.hasEnteredView = !1, this.isInView = !1;
+  }
+}
+function l({ viewport: o = {} }, { viewport: s = {} } = {}) {
+  return (e) => o[e] !== s[e];
+}
+export {
+  b as InViewFeature
+};

package/dist/node_modules/framer-motion/dist/es/motion/features/viewport/observers.js

@@ -0,0 +1,21 @@
+const c = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap(), a = (e) => {
+  const r = c.get(e.target);
+  r && r(e);
+}, b = (e) => {
+  e.forEach(a);
+};
+function i({ root: e, ...r }) {
+  const t = e || document;
+  n.has(t) || n.set(t, {});
+  const s = n.get(t), o = JSON.stringify(r);
+  return s[o] || (s[o] = new IntersectionObserver(b, { root: e, ...r })), s[o];
+}
+function v(e, r, t) {
+  const s = i(r);
+  return c.set(e, t), s.observe(e), () => {
+    c.delete(e), s.unobserve(e);
+  };
+}
+export {
+  v as observeIntersection
+};

package/dist/node_modules/framer-motion/dist/es/motion/index.js

@@ -0,0 +1,62 @@
+import { jsxs as S, jsx as g } from "react/jsx-runtime";
+import { forwardRef as x, useContext as l } from "react";
+import { LayoutGroupContext as E } from "../context/LayoutGroupContext.js";
+import { LazyContext as L } from "../context/LazyContext.js";
+import { MotionConfigContext as V } from "../context/MotionConfigContext.js";
+import { MotionContext as j } from "../context/MotionContext/index.js";
+import { useCreateMotionContext as w } from "../context/MotionContext/create.js";
+import { useRender as N } from "../render/dom/use-render.js";
+import { isSVGComponent as P } from "../render/dom/utils/is-svg-component.js";
+import { useHTMLVisualState as C } from "../render/html/use-html-visual-state.js";
+import { useSVGVisualState as b } from "../render/svg/use-svg-visual-state.js";
+import { getInitializedFeatureDefinitions as h } from "./features/definitions.js";
+import { loadFeatures as z } from "./features/load-features.js";
+import { motionComponentSymbol as G } from "./utils/symbol.js";
+import { useMotionRef as D } from "./utils/use-motion-ref.js";
+import { useVisualElement as R } from "./utils/use-visual-element.js";
+import { warning as I, invariant as k } from "../../../../motion-utils/dist/es/errors.js";
+function it(t, { forwardMotionProps: e = !1, type: i } = {}, o, s) {
+  o && z(o);
+  const m = i ? i === "svg" : P(t), M = m ? b : C;
+  function d(n, v) {
+    let u;
+    const r = {
+      ...l(V),
+      ...n,
+      layoutId: F(n)
+    }, { isStatic: c } = r, a = w(n), f = M(n, c);
+    if (!c && typeof window < "u") {
+      O(r, o);
+      const p = T(r);
+      u = p.MeasureLayout, a.visualElement = R(t, f, r, s, p.ProjectionNode, m);
+    }
+    return S(j.Provider, { value: a, children: [u && a.visualElement ? g(u, { visualElement: a.visualElement, ...r }) : null, N(t, n, D(f, a.visualElement, v), f, c, e, m)] });
+  }
+  d.displayName = `motion.${typeof t == "string" ? t : `create(${t.displayName ?? t.name ?? ""})`}`;
+  const y = x(d);
+  return y[G] = t, y;
+}
+function F({ layoutId: t }) {
+  const e = l(E).id;
+  return e && t !== void 0 ? e + "-" + t : t;
+}
+function O(t, e) {
+  const i = l(L).strict;
+  if (process.env.NODE_ENV !== "production" && e && i) {
+    const o = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    t.ignoreStrict ? I(!1, o, "lazy-strict-mode") : k(!1, o, "lazy-strict-mode");
+  }
+}
+function T(t) {
+  const e = h(), { drag: i, layout: o } = e;
+  if (!i && !o)
+    return {};
+  const s = { ...i, ...o };
+  return {
+    MeasureLayout: i?.isEnabled(t) || o?.isEnabled(t) ? s.MeasureLayout : void 0,
+    ProjectionNode: s.ProjectionNode
+  };
+}
+export {
+  it as createMotionComponent
+};

package/dist/node_modules/framer-motion/dist/es/motion/utils/symbol.js

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

package/dist/node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.js

@@ -0,0 +1,21 @@
+import { useRef as c, useInsertionEffect as l, useCallback as i } from "react";
+function s(p, u, e) {
+  const t = c(e);
+  l(() => {
+    t.current = e;
+  });
+  const f = c(null);
+  return i((r) => {
+    r && p.onMount?.(r), u && (r ? u.mount(r) : u.unmount());
+    const o = t.current;
+    if (typeof o == "function")
+      if (r) {
+        const n = o(r);
+        typeof n == "function" && (f.current = n);
+      } else f.current ? (f.current(), f.current = null) : o(r);
+    else o && (o.current = r);
+  }, [u]);
+}
+export {
+  s as useMotionRef
+};

package/dist/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.js

@@ -0,0 +1,65 @@
+import { useContext as u, useRef as l, useInsertionEffect as x, useEffect as j } from "react";
+import { LazyContext as I } from "../../context/LazyContext.js";
+import { MotionConfigContext as k } from "../../context/MotionConfigContext.js";
+import { MotionContext as S } from "../../context/MotionContext/index.js";
+import { PresenceContext as L } from "../../context/PresenceContext.js";
+import { SwitchLayoutGroupContext as O } from "../../context/SwitchLayoutGroupContext.js";
+import { isRefObject as R } from "../../utils/is-ref-object.js";
+import { useIsomorphicLayoutEffect as b } from "../../utils/use-isomorphic-effect.js";
+import { optimizedAppearDataAttribute as H } from "../../../../../motion-dom/dist/es/animation/optimized-appear/data-id.js";
+function K(o, f, n, e, s, a) {
+  const { visualElement: y } = u(S), c = u(I), i = u(L), d = u(k), C = d.reducedMotion, M = d.skipAnimations, r = l(null), w = l(!1);
+  e = e || c.renderer, !r.current && e && (r.current = e(o, {
+    visualState: f,
+    parent: y,
+    props: n,
+    presenceContext: i,
+    blockInitialAnimation: i ? i.initial === !1 : !1,
+    reducedMotionConfig: C,
+    skipAnimations: M,
+    isSVG: a
+  }), w.current && r.current && (r.current.manuallyAnimateOnMount = !0));
+  const t = r.current, A = u(O);
+  t && !t.projection && s && (t.type === "html" || t.type === "svg") && z(r.current, n, s, A);
+  const g = l(!1);
+  x(() => {
+    t && g.current && t.update(n, i);
+  });
+  const m = n[H], p = l(!!m && typeof window < "u" && !window.MotionHandoffIsComplete?.(m) && window.MotionHasOptimisedAnimation?.(m));
+  return b(() => {
+    w.current = !0, t && (g.current = !0, window.MotionIsMounted = !0, t.updateFeatures(), t.scheduleRenderMicrotask(), p.current && t.animationState && t.animationState.animateChanges());
+  }), j(() => {
+    t && (!p.current && t.animationState && t.animationState.animateChanges(), p.current && (queueMicrotask(() => {
+      window.MotionHandoffMarkAsComplete?.(m);
+    }), p.current = !1), t.enteringChildren = void 0);
+  }), t;
+}
+function z(o, f, n, e) {
+  const { layoutId: s, layout: a, drag: y, dragConstraints: c, layoutScroll: i, layoutRoot: d, layoutAnchor: C, layoutCrossfade: M } = f;
+  o.projection = new n(o.latestValues, f["data-framer-portal-id"] ? void 0 : h(o.parent)), o.projection.setOptions({
+    layoutId: s,
+    layout: a,
+    alwaysMeasureLayout: !!y || c && R(c),
+    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 a == "string" ? a : "both",
+    initialPromotionConfig: e,
+    crossfade: M,
+    layoutScroll: i,
+    layoutRoot: d,
+    layoutAnchor: C
+  });
+}
+function h(o) {
+  if (o)
+    return o.options.allowProjection !== !1 ? o.projection : h(o.parent);
+}
+export {
+  K as useVisualElement
+};

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

@@ -0,0 +1,52 @@
+import { useContext as C } from "react";
+import { MotionContext as x } from "../../context/MotionContext/index.js";
+import { PresenceContext as S } from "../../context/PresenceContext.js";
+import { useConstant as h } from "../../utils/use-constant.js";
+import { resolveMotionValue as M } from "../../../../../motion-dom/dist/es/value/utils/resolve-motion-value.js";
+import { isControllingVariants as N, isVariantNode as P } from "../../../../../motion-dom/dist/es/render/utils/is-controlling-variants.js";
+import { isAnimationControls as T } from "../../../../../motion-dom/dist/es/render/utils/is-animation-controls.js";
+import { resolveVariantFromProps as $ } from "../../../../../motion-dom/dist/es/render/utils/resolve-variants.js";
+function b({ scrapeMotionValuesFromProps: t, createRenderState: i }, e, s, n) {
+  return {
+    latestValues: p(e, s, n, t),
+    renderState: i()
+  };
+}
+function p(t, i, e, s) {
+  const n = {}, o = s(t, {});
+  for (const l in o)
+    n[l] = M(o[l]);
+  let { initial: m, animate: u } = t;
+  const g = N(t), v = P(t);
+  i && v && !g && t.inherit !== !1 && (m === void 0 && (m = i.initial), u === void 0 && (u = i.animate));
+  let c = e ? e.initial === !1 : !1;
+  c = c || m === !1;
+  const a = c ? u : m;
+  if (a && typeof a != "boolean" && !T(a)) {
+    const l = Array.isArray(a) ? a : [a];
+    for (let d = 0; d < l.length; d++) {
+      const V = $(t, l[d]);
+      if (V) {
+        const { transitionEnd: k, transition: B, ...y } = V;
+        for (const f in y) {
+          let r = y[f];
+          if (Array.isArray(r)) {
+            const A = c ? r.length - 1 : 0;
+            r = r[A];
+          }
+          r !== null && (n[f] = r);
+        }
+        for (const f in k)
+          n[f] = k[f];
+      }
+    }
+  }
+  return n;
+}
+const z = (t) => (i, e) => {
+  const s = C(x), n = C(S), o = () => b(t, i, s, n);
+  return e ? o() : h(o);
+};
+export {
+  z as makeUseVisualState
+};

package/dist/node_modules/framer-motion/dist/es/motion/utils/valid-prop.js

@@ -0,0 +1,39 @@
+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",
+  "propagate",
+  "ignoreStrict",
+  "viewport"
+]);
+function o(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 {
+  o as isValidMotionProp
+};

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/create-visual-element.js

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

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

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

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

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