motion-v 0.3.1-beta.1 → 0.4.1

package/dist/es/components/LayoutGroup.vue.mjs

@@ -0,0 +1,39 @@
+import { defineComponent, watch, renderSlot } from "vue";
+import { injectLayoutGroup, provideLayoutGroup, shouldInheritId, shouldInheritGroup } from "./context.mjs";
+import { nodeGroup } from "./group.mjs";
+import { useForceUpdate } from "./use-force-update.mjs";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "LayoutGroup",
+  props: {
+    id: {},
+    inherit: { type: [Boolean, String] }
+  },
+  setup(__props) {
+    const props = __props;
+    const layoutGroup = injectLayoutGroup(null);
+    const [forceRender, key] = useForceUpdate();
+    function generateId() {
+      const upstreamId = layoutGroup == null ? void 0 : layoutGroup.id;
+      return shouldInheritId(props.inherit) && upstreamId ? props.id ? `${upstreamId}-${props.id}` : upstreamId : props.id;
+    }
+    function generateGroup() {
+      return shouldInheritGroup(props.inherit) ? (layoutGroup == null ? void 0 : layoutGroup.group) || nodeGroup() : nodeGroup();
+    }
+    const memoizedContext = {
+      id: generateId(),
+      group: generateGroup(),
+      forceRender,
+      key
+    };
+    watch(key, () => {
+      memoizedContext.id = generateId();
+    });
+    provideLayoutGroup(memoizedContext);
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/es/components/LayoutGroup.vue2.mjs

@@ -0,0 +1,4 @@
+import _sfc_main from "./LayoutGroup.vue.mjs";
+export {
+  _sfc_main as default
+};

package/dist/es/components/Motion.vue.mjs

@@ -1,6 +1,6 @@
 import { defineComponent, mergeDefaults, ref, useAttrs, getCurrentInstance, onMounted, onUnmounted, onUpdated, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
-import { injectMotion, provideMotion } from "./context.mjs";
-import { createStyles, convertSvgStyleToAttributes } from "../state/style.mjs";
+import { injectMotion, injectLayoutGroup, provideMotion } from "./context.mjs";
+import { convertSvgStyleToAttributes, createStyles } from "../state/style.mjs";
 import { Primitive } from "./Primitive.mjs";
 import { MotionState } from "../state/motion-state.mjs";
 import { isSVGElement } from "../state/utils.mjs";
@@ -34,20 +34,30 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     onPressStart: { type: Function },
     onPressEnd: { type: Function },
     onViewEnter: { type: Function },
-    onViewLeave: { type: Function }
+    onViewLeave: { type: Function },
+    layout: { type: Boolean },
+    layoutId: {},
+    layoutScroll: { type: Boolean },
+    layoutRoot: { type: Boolean },
+    "data-framer-portal-id": {}
   }, {
     as: "div",
     asChild: false,
     initial: void 0,
     animate: void 0,
     hover: void 0,
-    inView: void 0
+    inView: void 0,
+    layout: false,
+    layoutId: void 0,
+    layoutScroll: false,
+    layoutRoot: false
   }),
   setup(__props) {
     const props = __props;
     const { initial: presenceInitial, safeUnmount } = injectAnimatePresence({ initial: ref(void 0), safeUnmount: () => true });
     const parentState = injectMotion(null);
     const attrs = useAttrs();
+    const layoutGroup = injectLayoutGroup({});
     const state = new MotionState(
       {
         ...attrs,
@@ -61,8 +71,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       state.mount(instance == null ? void 0 : instance.vnode.el);
       state.update({
         ...attrs,
-        ...props,
-        style: { ...createStyles(state.getTarget()), ...props.style }
+        ...props
       });
     });
     onUnmounted(() => {
@@ -91,23 +100,26 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           Object.assign(attrsProps, attributes);
           Object.assign(styleProps, style, props.style);
         } else {
-          Object.assign(styleProps, props.style, state.getTarget());
+          Object.assign(styleProps, state.getTarget(), props.style);
         }
       }
       styleProps = createStyles(styleProps);
-      attrsProps.style = createStyles(styleProps);
+      attrsProps.style = styleProps;
       return attrsProps;
     }
     return (_ctx, _cache) => {
+      var _a, _b;
       return openBlock(), createBlock(unref(Primitive), mergeProps({
         as: _ctx.as,
         "as-child": _ctx.asChild
-      }, getProps()), {
+      }, getProps(), {
+        "data-layout-group-key": (_b = (_a = unref(layoutGroup)) == null ? void 0 : _a.key) == null ? void 0 : _b.value
+      }), {
         default: withCtx(() => [
           renderSlot(_ctx.$slots, "default")
         ]),
         _: 3
-      }, 16, ["as", "as-child"]);
+      }, 16, ["as", "as-child", "data-layout-group-key"]);
     };
   }
 });

package/dist/es/components/context.mjs

@@ -1,6 +1,17 @@
 import { createContext } from "../utils/createContext.mjs";
 const [injectMotion, provideMotion] = createContext("Motion");
+const [injectLayoutGroup, provideLayoutGroup] = createContext("LayoutGroup");
+function shouldInheritGroup(inherit) {
+  return inherit === true;
+}
+function shouldInheritId(inherit) {
+  return shouldInheritGroup(inherit === true) || inherit === "id";
+}
 export {
+  injectLayoutGroup,
   injectMotion,
-  provideMotion
+  provideLayoutGroup,
+  provideMotion,
+  shouldInheritGroup,
+  shouldInheritId
 };

package/dist/es/components/group.mjs

@@ -0,0 +1,30 @@
+function notify(node) {
+  return !node.isLayoutDirty && node.willUpdate(false);
+}
+function nodeGroup() {
+  const nodes = /* @__PURE__ */ new Set();
+  const subscriptions = /* @__PURE__ */ new WeakMap();
+  const dirtyAll = () => nodes.forEach(notify);
+  return {
+    add: (node) => {
+      nodes.add(node);
+      subscriptions.set(
+        node,
+        node.addEventListener("willUpdate", dirtyAll)
+      );
+    },
+    remove: (node) => {
+      nodes.delete(node);
+      const unsubscribe = subscriptions.get(node);
+      if (unsubscribe) {
+        unsubscribe();
+        subscriptions.delete(node);
+      }
+      dirtyAll();
+    },
+    dirty: dirtyAll
+  };
+}
+export {
+  nodeGroup
+};

package/dist/es/components/use-force-update.mjs

@@ -0,0 +1,11 @@
+import { ref } from "vue";
+function useForceUpdate() {
+  const key = ref(0);
+  function forceUpdate() {
+    key.value++;
+  }
+  return [forceUpdate, key];
+}
+export {
+  useForceUpdate
+};

package/dist/es/constants/index.mjs

@@ -1,7 +1,8 @@
 const components = {
   motion: [
     "Motion",
-    "MotionPresence"
+    "MotionPresence",
+    "LayoutGroup"
   ]
 };
 const utilities = {
@@ -11,7 +12,12 @@ const utilities = {
     "useMotionTemplate",
     "useSpring",
     "useScroll",
-    "useMotionValue"
+    "useMotionValue",
+    "useVelocity",
+    "useAnimate",
+    "useInView",
+    "useAnimationFrame",
+    "useMotionValueEvent"
   ]
 };
 export {

package/dist/es/external/.pnpm/@vueuse_shared@12.0.0_typescript@5.5.4/external/@vueuse/shared/index.mjs

@@ -0,0 +1,6 @@
+import "vue";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const isDef = (val) => typeof val !== "undefined";
+export {
+  isDef
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/events/add-dom-event.mjs

@@ -0,0 +1,7 @@
+function addDomEvent(target, eventName, handler, options = { passive: true }) {
+  target.addEventListener(eventName, handler, options);
+  return () => target.removeEventListener(eventName, handler);
+}
+export {
+  addDomEvent
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/frameloop/microtask.mjs

@@ -0,0 +1,6 @@
+import { createRenderBatcher } from "./batcher.mjs";
+const { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);
+export {
+  cancelMicrotask,
+  microtask
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/animation/mix-values.mjs

@@ -0,0 +1,60 @@
+import { circOut } from "../../easing/circ.mjs";
+import { progress } from "../../utils/progress.mjs";
+import { mixNumber } from "../../utils/mix/number.mjs";
+import { noop } from "../../utils/noop.mjs";
+import { percent, px } from "../../value/types/numbers/units.mjs";
+const borders = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"];
+const numBorders = borders.length;
+const asNumber = (value) => typeof value === "string" ? parseFloat(value) : value;
+const isPx = (value) => typeof value === "number" || px.test(value);
+function mixValues(target, follow, lead, progress2, shouldCrossfadeOpacity, isOnlyMember) {
+  if (shouldCrossfadeOpacity) {
+    target.opacity = mixNumber(
+      0,
+      // TODO Reinstate this if only child
+      lead.opacity !== void 0 ? lead.opacity : 1,
+      easeCrossfadeIn(progress2)
+    );
+    target.opacityExit = mixNumber(follow.opacity !== void 0 ? follow.opacity : 1, 0, easeCrossfadeOut(progress2));
+  } else if (isOnlyMember) {
+    target.opacity = mixNumber(follow.opacity !== void 0 ? follow.opacity : 1, lead.opacity !== void 0 ? lead.opacity : 1, progress2);
+  }
+  for (let i = 0; i < numBorders; i++) {
+    const borderLabel = `border${borders[i]}Radius`;
+    let followRadius = getRadius(follow, borderLabel);
+    let leadRadius = getRadius(lead, borderLabel);
+    if (followRadius === void 0 && leadRadius === void 0)
+      continue;
+    followRadius || (followRadius = 0);
+    leadRadius || (leadRadius = 0);
+    const canMix = followRadius === 0 || leadRadius === 0 || isPx(followRadius) === isPx(leadRadius);
+    if (canMix) {
+      target[borderLabel] = Math.max(mixNumber(asNumber(followRadius), asNumber(leadRadius), progress2), 0);
+      if (percent.test(leadRadius) || percent.test(followRadius)) {
+        target[borderLabel] += "%";
+      }
+    } else {
+      target[borderLabel] = leadRadius;
+    }
+  }
+  if (follow.rotate || lead.rotate) {
+    target.rotate = mixNumber(follow.rotate || 0, lead.rotate || 0, progress2);
+  }
+}
+function getRadius(values, radiusName) {
+  return values[radiusName] !== void 0 ? values[radiusName] : values.borderRadius;
+}
+const easeCrossfadeIn = /* @__PURE__ */ compress(0, 0.5, circOut);
+const easeCrossfadeOut = /* @__PURE__ */ compress(0.5, 0.95, noop);
+function compress(min, max, easing) {
+  return (p) => {
+    if (p < min)
+      return 0;
+    if (p > max)
+      return 1;
+    return easing(progress(min, max, p));
+  };
+}
+export {
+  mixValues
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/copy.mjs

@@ -0,0 +1,19 @@
+function copyAxisInto(axis, originAxis) {
+  axis.min = originAxis.min;
+  axis.max = originAxis.max;
+}
+function copyBoxInto(box, originBox) {
+  copyAxisInto(box.x, originBox.x);
+  copyAxisInto(box.y, originBox.y);
+}
+function copyAxisDeltaInto(delta, originDelta) {
+  delta.translate = originDelta.translate;
+  delta.scale = originDelta.scale;
+  delta.originPoint = originDelta.originPoint;
+  delta.origin = originDelta.origin;
+}
+export {
+  copyAxisDeltaInto,
+  copyAxisInto,
+  copyBoxInto
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/delta-apply.mjs

@@ -0,0 +1,81 @@
+import { mixNumber } from "../../utils/mix/number.mjs";
+import { hasTransform } from "../utils/has-transform.mjs";
+function scalePoint(point, scale, originPoint) {
+  const distanceFromOrigin = point - originPoint;
+  const scaled = scale * distanceFromOrigin;
+  return originPoint + scaled;
+}
+function applyPointDelta(point, translate, scale, originPoint, boxScale) {
+  if (boxScale !== void 0) {
+    point = scalePoint(point, boxScale, originPoint);
+  }
+  return scalePoint(point, scale, originPoint) + translate;
+}
+function applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {
+  axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);
+  axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);
+}
+function applyBoxDelta(box, { x, y }) {
+  applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);
+  applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);
+}
+const TREE_SCALE_SNAP_MIN = 0.999999999999;
+const TREE_SCALE_SNAP_MAX = 1.0000000000001;
+function applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {
+  const treeLength = treePath.length;
+  if (!treeLength)
+    return;
+  treeScale.x = treeScale.y = 1;
+  let node;
+  let delta;
+  for (let i = 0; i < treeLength; i++) {
+    node = treePath[i];
+    delta = node.projectionDelta;
+    const { visualElement } = node.options;
+    if (visualElement && visualElement.props.style && visualElement.props.style.display === "contents") {
+      continue;
+    }
+    if (isSharedTransition && node.options.layoutScroll && node.scroll && node !== node.root) {
+      transformBox(box, {
+        x: -node.scroll.offset.x,
+        y: -node.scroll.offset.y
+      });
+    }
+    if (delta) {
+      treeScale.x *= delta.x.scale;
+      treeScale.y *= delta.y.scale;
+      applyBoxDelta(box, delta);
+    }
+    if (isSharedTransition && hasTransform(node.latestValues)) {
+      transformBox(box, node.latestValues);
+    }
+  }
+  if (treeScale.x < TREE_SCALE_SNAP_MAX && treeScale.x > TREE_SCALE_SNAP_MIN) {
+    treeScale.x = 1;
+  }
+  if (treeScale.y < TREE_SCALE_SNAP_MAX && treeScale.y > TREE_SCALE_SNAP_MIN) {
+    treeScale.y = 1;
+  }
+}
+function translateAxis(axis, distance) {
+  axis.min = axis.min + distance;
+  axis.max = axis.max + distance;
+}
+function transformAxis(axis, axisTranslate, axisScale, boxScale, axisOrigin = 0.5) {
+  const originPoint = mixNumber(axis.min, axis.max, axisOrigin);
+  applyAxisDelta(axis, axisTranslate, axisScale, originPoint, boxScale);
+}
+function transformBox(box, transform) {
+  transformAxis(box.x, transform.x, transform.scaleX, transform.scale, transform.originX);
+  transformAxis(box.y, transform.y, transform.scaleY, transform.scale, transform.originY);
+}
+export {
+  applyAxisDelta,
+  applyBoxDelta,
+  applyPointDelta,
+  applyTreeDeltas,
+  scalePoint,
+  transformAxis,
+  transformBox,
+  translateAxis
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/delta-calc.mjs

@@ -0,0 +1,55 @@
+import { mixNumber } from "../../utils/mix/number.mjs";
+const SCALE_PRECISION = 1e-4;
+const SCALE_MIN = 1 - SCALE_PRECISION;
+const SCALE_MAX = 1 + SCALE_PRECISION;
+const TRANSLATE_PRECISION = 0.01;
+const TRANSLATE_MIN = 0 - TRANSLATE_PRECISION;
+const TRANSLATE_MAX = 0 + TRANSLATE_PRECISION;
+function calcLength(axis) {
+  return axis.max - axis.min;
+}
+function isNear(value, target, maxDistance) {
+  return Math.abs(value - target) <= maxDistance;
+}
+function calcAxisDelta(delta, source, target, origin = 0.5) {
+  delta.origin = origin;
+  delta.originPoint = mixNumber(source.min, source.max, delta.origin);
+  delta.scale = calcLength(target) / calcLength(source);
+  delta.translate = mixNumber(target.min, target.max, delta.origin) - delta.originPoint;
+  if (delta.scale >= SCALE_MIN && delta.scale <= SCALE_MAX || isNaN(delta.scale)) {
+    delta.scale = 1;
+  }
+  if (delta.translate >= TRANSLATE_MIN && delta.translate <= TRANSLATE_MAX || isNaN(delta.translate)) {
+    delta.translate = 0;
+  }
+}
+function calcBoxDelta(delta, source, target, origin) {
+  calcAxisDelta(delta.x, source.x, target.x, origin ? origin.originX : void 0);
+  calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : void 0);
+}
+function calcRelativeAxis(target, relative, parent) {
+  target.min = parent.min + relative.min;
+  target.max = target.min + calcLength(relative);
+}
+function calcRelativeBox(target, relative, parent) {
+  calcRelativeAxis(target.x, relative.x, parent.x);
+  calcRelativeAxis(target.y, relative.y, parent.y);
+}
+function calcRelativeAxisPosition(target, layout, parent) {
+  target.min = layout.min - parent.min;
+  target.max = target.min + calcLength(layout);
+}
+function calcRelativePosition(target, layout, parent) {
+  calcRelativeAxisPosition(target.x, layout.x, parent.x);
+  calcRelativeAxisPosition(target.y, layout.y, parent.y);
+}
+export {
+  calcAxisDelta,
+  calcBoxDelta,
+  calcLength,
+  calcRelativeAxis,
+  calcRelativeAxisPosition,
+  calcRelativeBox,
+  calcRelativePosition,
+  isNear
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/delta-remove.mjs

@@ -0,0 +1,40 @@
+import { mixNumber } from "../../utils/mix/number.mjs";
+import { percent } from "../../value/types/numbers/units.mjs";
+import { scalePoint } from "./delta-apply.mjs";
+function removePointDelta(point, translate, scale, originPoint, boxScale) {
+  point -= translate;
+  point = scalePoint(point, 1 / scale, originPoint);
+  if (boxScale !== void 0) {
+    point = scalePoint(point, 1 / boxScale, originPoint);
+  }
+  return point;
+}
+function removeAxisDelta(axis, translate = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {
+  if (percent.test(translate)) {
+    translate = parseFloat(translate);
+    const relativeProgress = mixNumber(sourceAxis.min, sourceAxis.max, translate / 100);
+    translate = relativeProgress - sourceAxis.min;
+  }
+  if (typeof translate !== "number")
+    return;
+  let originPoint = mixNumber(originAxis.min, originAxis.max, origin);
+  if (axis === originAxis)
+    originPoint -= translate;
+  axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);
+  axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);
+}
+function removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {
+  removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);
+}
+const xKeys = ["x", "scaleX", "originX"];
+const yKeys = ["y", "scaleY", "originY"];
+function removeBoxTransforms(box, transforms, originBox, sourceBox) {
+  removeAxisTransforms(box.x, transforms, xKeys, originBox ? originBox.x : void 0, sourceBox ? sourceBox.x : void 0);
+  removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : void 0, sourceBox ? sourceBox.y : void 0);
+}
+export {
+  removeAxisDelta,
+  removeAxisTransforms,
+  removeBoxTransforms,
+  removePointDelta
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/models.mjs

@@ -1,3 +1,13 @@
+const createAxisDelta = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+});
+const createDelta = () => ({
+  x: createAxisDelta(),
+  y: createAxisDelta()
+});
 const createAxis = () => ({ min: 0, max: 0 });
 const createBox = () => ({
   x: createAxis(),
@@ -5,5 +15,7 @@ const createBox = () => ({
 });
 export {
   createAxis,
-  createBox
+  createAxisDelta,
+  createBox,
+  createDelta
 };

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/geometry/utils.mjs

@@ -0,0 +1,34 @@
+import { calcLength } from "./delta-calc.mjs";
+function isAxisDeltaZero(delta) {
+  return delta.translate === 0 && delta.scale === 1;
+}
+function isDeltaZero(delta) {
+  return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);
+}
+function axisEquals(a, b) {
+  return a.min === b.min && a.max === b.max;
+}
+function boxEquals(a, b) {
+  return axisEquals(a.x, b.x) && axisEquals(a.y, b.y);
+}
+function axisEqualsRounded(a, b) {
+  return Math.round(a.min) === Math.round(b.min) && Math.round(a.max) === Math.round(b.max);
+}
+function boxEqualsRounded(a, b) {
+  return axisEqualsRounded(a.x, b.x) && axisEqualsRounded(a.y, b.y);
+}
+function aspectRatio(box) {
+  return calcLength(box.x) / calcLength(box.y);
+}
+function axisDeltaEquals(a, b) {
+  return a.translate === b.translate && a.scale === b.scale && a.originPoint === b.originPoint;
+}
+export {
+  aspectRatio,
+  axisDeltaEquals,
+  axisEquals,
+  axisEqualsRounded,
+  boxEquals,
+  boxEqualsRounded,
+  isDeltaZero
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs

@@ -0,0 +1,13 @@
+import { createProjectionNode } from "./create-projection-node.mjs";
+import { addDomEvent } from "../../events/add-dom-event.mjs";
+const DocumentProjectionNode = createProjectionNode({
+  attachResizeListener: (ref, notify) => addDomEvent(ref, "resize", notify),
+  measureScroll: () => ({
+    x: document.documentElement.scrollLeft || document.body.scrollLeft,
+    y: document.documentElement.scrollTop || document.body.scrollTop
+  }),
+  checkIsScrollRoot: () => true
+});
+export {
+  DocumentProjectionNode
+};

package/dist/es/external/.pnpm/framer-motion@11.11.11/external/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs

@@ -0,0 +1,28 @@
+import { createProjectionNode } from "./create-projection-node.mjs";
+import { DocumentProjectionNode } from "./DocumentProjectionNode.mjs";
+const rootProjectionNode = {
+  current: void 0
+};
+const HTMLProjectionNode = createProjectionNode({
+  measureScroll: (instance) => ({
+    x: instance.scrollLeft,
+    y: instance.scrollTop
+  }),
+  defaultParent: () => {
+    if (!rootProjectionNode.current) {
+      const documentNode = new DocumentProjectionNode({});
+      documentNode.mount(window);
+      documentNode.setOptions({ layoutScroll: true });
+      rootProjectionNode.current = documentNode;
+    }
+    return rootProjectionNode.current;
+  },
+  resetTransform: (instance, value) => {
+    instance.style.transform = value !== void 0 ? value : "none";
+  },
+  checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === "fixed")
+});
+export {
+  HTMLProjectionNode,
+  rootProjectionNode
+};