npm - @123usmanhaider321/ui - Versions diffs - 0.1.0 → 0.1.8 - Mend

@123usmanhaider321/ui 0.1.0 → 0.1.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1322) hide show

package/dist/node_modules/motion-dom/dist/es/projection/node/create-projection-node.js DELETED Viewed

@@ -1,1123 +0,0 @@
-import { animateSingleValue } from "../../animation/animate/single-value.js";
-import { getOptimisedAppearId } from "../../animation/optimized-appear/get-appear-id.js";
-import { getValueTransition } from "../../animation/utils/get-value-transition.js";
-import { microtask } from "../../frameloop/microtask.js";
-import { time } from "../../frameloop/sync-time.js";
-import { scaleCorrectors } from "../styles/scale-correction.js";
-import { delay } from "../../utils/delay.js";
-import { isSVGElement } from "../../utils/is-svg-element.js";
-import { isSVGSVGElement } from "../../utils/is-svg-svg-element.js";
-import { mixNumber } from "../../utils/mix/number.js";
-import { motionValue } from "../../value/index.js";
-import { resolveMotionValue } from "../../value/utils/resolve-motion-value.js";
-import { mixValues } from "../animation/mix-values.js";
-import { copyBoxInto, copyAxisDeltaInto, copyAxisInto } from "../geometry/copy.js";
-import { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from "../geometry/delta-apply.js";
-import { calcLength, calcRelativeBox, calcRelativePosition, calcBoxDelta, isNear } from "../geometry/delta-calc.js";
-import { removeBoxTransforms } from "../geometry/delta-remove.js";
-import { createBox, createDelta } from "../geometry/models.js";
-import { boxEqualsRounded, isDeltaZero, axisDeltaEquals, boxEquals, aspectRatio } from "../geometry/utils.js";
-import { NodeStack } from "../shared/stack.js";
-import { buildProjectionTransform } from "../styles/transform.js";
-import { eachAxis } from "../utils/each-axis.js";
-import { FlatTree } from "../utils/flat-tree.js";
-import { hasTransform, hasScale, has2DTranslate } from "../utils/has-transform.js";
-import { globalProjectionState } from "./state.js";
-import { frame, cancelFrame, frameSteps, frameData } from "../../frameloop/frame.js";
-import { SubscriptionManager } from "../../../../../motion-utils/dist/es/subscription-manager.js";
-import { clamp } from "../../../../../motion-utils/dist/es/clamp.js";
-import { noop } from "../../../../../motion-utils/dist/es/noop.js";
-const transformAxes = ["", "X", "Y", "Z"];
-const animationTarget = 1e3;
-let id = 0;
-function resetDistortingTransform(key, visualElement, values, sharedAnimationValues) {
-  const { latestValues } = visualElement;
-  if (latestValues[key]) {
-    values[key] = latestValues[key];
-    visualElement.setStaticValue(key, 0);
-    if (sharedAnimationValues) {
-      sharedAnimationValues[key] = 0;
-    }
-  }
-}
-function cancelTreeOptimisedTransformAnimations(projectionNode) {
-  projectionNode.hasCheckedOptimisedAppear = true;
-  if (projectionNode.root === projectionNode)
-    return;
-  const { visualElement } = projectionNode.options;
-  if (!visualElement)
-    return;
-  const appearId = getOptimisedAppearId(visualElement);
-  if (window.MotionHasOptimisedAnimation(appearId, "transform")) {
-    const { layout, layoutId } = projectionNode.options;
-    window.MotionCancelOptimisedAnimation(appearId, "transform", frame, !(layout || layoutId));
-  }
-  const { parent } = projectionNode;
-  if (parent && !parent.hasCheckedOptimisedAppear) {
-    cancelTreeOptimisedTransformAnimations(parent);
-  }
-}
-function createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform }) {
-  return class ProjectionNode {
-    constructor(latestValues = {}, parent = defaultParent == null ? void 0 : defaultParent()) {
-      this.id = id++;
-      this.animationId = 0;
-      this.animationCommitId = 0;
-      this.children = /* @__PURE__ */ new Set();
-      this.options = {};
-      this.isTreeAnimating = false;
-      this.isAnimationBlocked = false;
-      this.isLayoutDirty = false;
-      this.isProjectionDirty = false;
-      this.isSharedProjectionDirty = false;
-      this.isTransformDirty = false;
-      this.updateManuallyBlocked = false;
-      this.updateBlockedByResize = false;
-      this.isUpdating = false;
-      this.isSVG = false;
-      this.needsReset = false;
-      this.shouldResetTransform = false;
-      this.hasCheckedOptimisedAppear = false;
-      this.treeScale = { x: 1, y: 1 };
-      this.eventHandlers = /* @__PURE__ */ new Map();
-      this.hasTreeAnimated = false;
-      this.layoutVersion = 0;
-      this.updateScheduled = false;
-      this.scheduleUpdate = () => this.update();
-      this.projectionUpdateScheduled = false;
-      this.checkUpdateFailed = () => {
-        if (this.isUpdating) {
-          this.isUpdating = false;
-          this.clearAllSnapshots();
-        }
-      };
-      this.updateProjection = () => {
-        this.projectionUpdateScheduled = false;
-        this.nodes.forEach(propagateDirtyNodes);
-        this.nodes.forEach(resolveTargetDelta);
-        this.nodes.forEach(calcProjection);
-        this.nodes.forEach(cleanDirtyNodes);
-      };
-      this.resolvedRelativeTargetAt = 0;
-      this.linkedParentVersion = 0;
-      this.hasProjected = false;
-      this.isVisible = true;
-      this.animationProgress = 0;
-      this.sharedNodes = /* @__PURE__ */ new Map();
-      this.latestValues = latestValues;
-      this.root = parent ? parent.root || parent : this;
-      this.path = parent ? [...parent.path, parent] : [];
-      this.parent = parent;
-      this.depth = parent ? parent.depth + 1 : 0;
-      for (let i = 0; i < this.path.length; i++) {
-        this.path[i].shouldResetTransform = true;
-      }
-      if (this.root === this)
-        this.nodes = new FlatTree();
-    }
-    addEventListener(name, handler) {
-      if (!this.eventHandlers.has(name)) {
-        this.eventHandlers.set(name, new SubscriptionManager());
-      }
-      return this.eventHandlers.get(name).add(handler);
-    }
-    notifyListeners(name, ...args) {
-      const subscriptionManager = this.eventHandlers.get(name);
-      subscriptionManager && subscriptionManager.notify(...args);
-    }
-    hasListeners(name) {
-      return this.eventHandlers.has(name);
-    }
-    /**
-     * Lifecycles
-     */
-    mount(instance) {
-      if (this.instance)
-        return;
-      this.isSVG = isSVGElement(instance) && !isSVGSVGElement(instance);
-      this.instance = instance;
-      const { layoutId, layout, visualElement } = this.options;
-      if (visualElement && !visualElement.current) {
-        visualElement.mount(instance);
-      }
-      this.root.nodes.add(this);
-      this.parent && this.parent.children.add(this);
-      if (this.root.hasTreeAnimated && (layout || layoutId)) {
-        this.isLayoutDirty = true;
-      }
-      if (attachResizeListener) {
-        let cancelDelay;
-        let innerWidth = 0;
-        const resizeUnblockUpdate = () => this.root.updateBlockedByResize = false;
-        frame.read(() => {
-          innerWidth = window.innerWidth;
-        });
-        attachResizeListener(instance, () => {
-          const newInnerWidth = window.innerWidth;
-          if (newInnerWidth === innerWidth)
-            return;
-          innerWidth = newInnerWidth;
-          this.root.updateBlockedByResize = true;
-          cancelDelay && cancelDelay();
-          cancelDelay = delay(resizeUnblockUpdate, 250);
-          if (globalProjectionState.hasAnimatedSinceResize) {
-            globalProjectionState.hasAnimatedSinceResize = false;
-            this.nodes.forEach(finishAnimation);
-          }
-        });
-      }
-      if (layoutId) {
-        this.root.registerSharedNode(layoutId, this);
-      }
-      if (this.options.animate !== false && visualElement && (layoutId || layout)) {
-        this.addEventListener("didUpdate", ({ delta, hasLayoutChanged, hasRelativeLayoutChanged, layout: newLayout }) => {
-          if (this.isTreeAnimationBlocked()) {
-            this.target = void 0;
-            this.relativeTarget = void 0;
-            return;
-          }
-          const layoutTransition = this.options.transition || visualElement.getDefaultTransition() || defaultLayoutTransition;
-          const { onLayoutAnimationStart, onLayoutAnimationComplete } = visualElement.getProps();
-          const hasTargetChanged = !this.targetLayout || !boxEqualsRounded(this.targetLayout, newLayout);
-          const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeLayoutChanged;
-          if (this.options.layoutRoot || this.resumeFrom || hasOnlyRelativeTargetChanged || hasLayoutChanged && (hasTargetChanged || !this.currentAnimation)) {
-            if (this.resumeFrom) {
-              this.resumingFrom = this.resumeFrom;
-              this.resumingFrom.resumingFrom = void 0;
-            }
-            const animationOptions = {
-              ...getValueTransition(layoutTransition, "layout"),
-              onPlay: onLayoutAnimationStart,
-              onComplete: onLayoutAnimationComplete
-            };
-            if (visualElement.shouldReduceMotion || this.options.layoutRoot) {
-              animationOptions.delay = 0;
-              animationOptions.type = false;
-            }
-            this.startAnimation(animationOptions);
-            this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);
-          } else {
-            if (!hasLayoutChanged) {
-              finishAnimation(this);
-            }
-            if (this.isLead() && this.options.onExitComplete) {
-              this.options.onExitComplete();
-            }
-          }
-          this.targetLayout = newLayout;
-        });
-      }
-    }
-    unmount() {
-      this.options.layoutId && this.willUpdate();
-      this.root.nodes.remove(this);
-      const stack = this.getStack();
-      stack && stack.remove(this);
-      this.parent && this.parent.children.delete(this);
-      this.instance = void 0;
-      this.eventHandlers.clear();
-      cancelFrame(this.updateProjection);
-    }
-    // only on the root
-    blockUpdate() {
-      this.updateManuallyBlocked = true;
-    }
-    unblockUpdate() {
-      this.updateManuallyBlocked = false;
-    }
-    isUpdateBlocked() {
-      return this.updateManuallyBlocked || this.updateBlockedByResize;
-    }
-    isTreeAnimationBlocked() {
-      return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || false;
-    }
-    // Note: currently only running on root node
-    startUpdate() {
-      if (this.isUpdateBlocked())
-        return;
-      this.isUpdating = true;
-      this.nodes && this.nodes.forEach(resetSkewAndRotation);
-      this.animationId++;
-    }
-    getTransformTemplate() {
-      const { visualElement } = this.options;
-      return visualElement && visualElement.getProps().transformTemplate;
-    }
-    willUpdate(shouldNotifyListeners = true) {
-      this.root.hasTreeAnimated = true;
-      if (this.root.isUpdateBlocked()) {
-        this.options.onExitComplete && this.options.onExitComplete();
-        return;
-      }
-      if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear) {
-        cancelTreeOptimisedTransformAnimations(this);
-      }
-      !this.root.isUpdating && this.root.startUpdate();
-      if (this.isLayoutDirty)
-        return;
-      this.isLayoutDirty = true;
-      for (let i = 0; i < this.path.length; i++) {
-        const node = this.path[i];
-        node.shouldResetTransform = true;
-        if (typeof node.latestValues.x === "string" || typeof node.latestValues.y === "string") {
-          node.isLayoutDirty = true;
-        }
-        node.updateScroll("snapshot");
-        if (node.options.layoutRoot) {
-          node.willUpdate(false);
-        }
-      }
-      const { layoutId, layout } = this.options;
-      if (layoutId === void 0 && !layout)
-        return;
-      const transformTemplate = this.getTransformTemplate();
-      this.prevTransformTemplateValue = transformTemplate ? transformTemplate(this.latestValues, "") : void 0;
-      this.updateSnapshot();
-      shouldNotifyListeners && this.notifyListeners("willUpdate");
-    }
-    update() {
-      this.updateScheduled = false;
-      const updateWasBlocked = this.isUpdateBlocked();
-      if (updateWasBlocked) {
-        const wasBlockedByResize = this.updateBlockedByResize;
-        this.unblockUpdate();
-        this.updateBlockedByResize = false;
-        this.clearAllSnapshots();
-        if (wasBlockedByResize) {
-          this.nodes.forEach(forceLayoutMeasure);
-        }
-        this.nodes.forEach(clearMeasurements);
-        return;
-      }
-      if (this.animationId <= this.animationCommitId) {
-        this.nodes.forEach(clearIsLayoutDirty);
-        return;
-      }
-      this.animationCommitId = this.animationId;
-      if (!this.isUpdating) {
-        this.nodes.forEach(clearIsLayoutDirty);
-      } else {
-        this.isUpdating = false;
-        this.nodes.forEach(ensureDraggedNodesSnapshotted);
-        this.nodes.forEach(resetTransformStyle);
-        this.nodes.forEach(updateLayout);
-        this.nodes.forEach(notifyLayoutUpdate);
-      }
-      this.clearAllSnapshots();
-      const now = time.now();
-      frameData.delta = clamp(0, 1e3 / 60, now - frameData.timestamp);
-      frameData.timestamp = now;
-      frameData.isProcessing = true;
-      frameSteps.update.process(frameData);
-      frameSteps.preRender.process(frameData);
-      frameSteps.render.process(frameData);
-      frameData.isProcessing = false;
-    }
-    didUpdate() {
-      if (!this.updateScheduled) {
-        this.updateScheduled = true;
-        microtask.read(this.scheduleUpdate);
-      }
-    }
-    clearAllSnapshots() {
-      this.nodes.forEach(clearSnapshot);
-      this.sharedNodes.forEach(removeLeadSnapshots);
-    }
-    scheduleUpdateProjection() {
-      if (!this.projectionUpdateScheduled) {
-        this.projectionUpdateScheduled = true;
-        frame.preRender(this.updateProjection, false, true);
-      }
-    }
-    scheduleCheckAfterUnmount() {
-      frame.postRender(() => {
-        if (this.isLayoutDirty) {
-          this.root.didUpdate();
-        } else {
-          this.root.checkUpdateFailed();
-        }
-      });
-    }
-    /**
-     * Update measurements
-     */
-    updateSnapshot() {
-      if (this.snapshot || !this.instance)
-        return;
-      this.snapshot = this.measure();
-      if (this.snapshot && !calcLength(this.snapshot.measuredBox.x) && !calcLength(this.snapshot.measuredBox.y)) {
-        this.snapshot = void 0;
-      }
-    }
-    updateLayout() {
-      if (!this.instance)
-        return;
-      this.updateScroll();
-      if (!(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty) {
-        return;
-      }
-      if (this.resumeFrom && !this.resumeFrom.instance) {
-        for (let i = 0; i < this.path.length; i++) {
-          const node = this.path[i];
-          node.updateScroll();
-        }
-      }
-      const prevLayout = this.layout;
-      this.layout = this.measure(false);
-      this.layoutVersion++;
-      if (!this.layoutCorrected)
-        this.layoutCorrected = createBox();
-      this.isLayoutDirty = false;
-      this.projectionDelta = void 0;
-      this.notifyListeners("measure", this.layout.layoutBox);
-      const { visualElement } = this.options;
-      visualElement && visualElement.notify("LayoutMeasure", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : void 0);
-    }
-    updateScroll(phase = "measure") {
-      let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);
-      if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === phase) {
-        needsMeasurement = false;
-      }
-      if (needsMeasurement && this.instance) {
-        const isRoot = checkIsScrollRoot(this.instance);
-        this.scroll = {
-          animationId: this.root.animationId,
-          phase,
-          isRoot,
-          offset: measureScroll(this.instance),
-          wasRoot: this.scroll ? this.scroll.isRoot : isRoot
-        };
-      }
-    }
-    resetTransform() {
-      if (!resetTransform)
-        return;
-      const isResetRequested = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout;
-      const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);
-      const transformTemplate = this.getTransformTemplate();
-      const transformTemplateValue = transformTemplate ? transformTemplate(this.latestValues, "") : void 0;
-      const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;
-      if (isResetRequested && this.instance && (hasProjection || hasTransform(this.latestValues) || transformTemplateHasChanged)) {
-        resetTransform(this.instance, transformTemplateValue);
-        this.shouldResetTransform = false;
-        this.scheduleRender();
-      }
-    }
-    measure(removeTransform = true) {
-      const pageBox = this.measurePageBox();
-      let layoutBox = this.removeElementScroll(pageBox);
-      if (removeTransform) {
-        layoutBox = this.removeTransform(layoutBox);
-      }
-      roundBox(layoutBox);
-      return {
-        animationId: this.root.animationId,
-        measuredBox: pageBox,
-        layoutBox,
-        latestValues: {},
-        source: this.id
-      };
-    }
-    measurePageBox() {
-      var _a;
-      const { visualElement } = this.options;
-      if (!visualElement)
-        return createBox();
-      const box = visualElement.measureViewportBox();
-      const wasInScrollRoot = ((_a = this.scroll) == null ? void 0 : _a.wasRoot) || this.path.some(checkNodeWasScrollRoot);
-      if (!wasInScrollRoot) {
-        const { scroll } = this.root;
-        if (scroll) {
-          translateAxis(box.x, scroll.offset.x);
-          translateAxis(box.y, scroll.offset.y);
-        }
-      }
-      return box;
-    }
-    removeElementScroll(box) {
-      var _a;
-      const boxWithoutScroll = createBox();
-      copyBoxInto(boxWithoutScroll, box);
-      if ((_a = this.scroll) == null ? void 0 : _a.wasRoot) {
-        return boxWithoutScroll;
-      }
-      for (let i = 0; i < this.path.length; i++) {
-        const node = this.path[i];
-        const { scroll, options } = node;
-        if (node !== this.root && scroll && options.layoutScroll) {
-          if (scroll.wasRoot) {
-            copyBoxInto(boxWithoutScroll, box);
-          }
-          translateAxis(boxWithoutScroll.x, scroll.offset.x);
-          translateAxis(boxWithoutScroll.y, scroll.offset.y);
-        }
-      }
-      return boxWithoutScroll;
-    }
-    applyTransform(box, transformOnly = false, output) {
-      var _a, _b;
-      const withTransforms = output || createBox();
-      copyBoxInto(withTransforms, box);
-      for (let i = 0; i < this.path.length; i++) {
-        const node = this.path[i];
-        if (!transformOnly && node.options.layoutScroll && node.scroll && node !== node.root) {
-          translateAxis(withTransforms.x, -node.scroll.offset.x);
-          translateAxis(withTransforms.y, -node.scroll.offset.y);
-        }
-        if (!hasTransform(node.latestValues))
-          continue;
-        transformBox(withTransforms, node.latestValues, (_a = node.layout) == null ? void 0 : _a.layoutBox);
-      }
-      if (hasTransform(this.latestValues)) {
-        transformBox(withTransforms, this.latestValues, (_b = this.layout) == null ? void 0 : _b.layoutBox);
-      }
-      return withTransforms;
-    }
-    removeTransform(box) {
-      var _a;
-      const boxWithoutTransform = createBox();
-      copyBoxInto(boxWithoutTransform, box);
-      for (let i = 0; i < this.path.length; i++) {
-        const node = this.path[i];
-        if (!hasTransform(node.latestValues))
-          continue;
-        let sourceBox;
-        if (node.instance) {
-          hasScale(node.latestValues) && node.updateSnapshot();
-          sourceBox = createBox();
-          copyBoxInto(sourceBox, node.measurePageBox());
-        }
-        removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) == null ? void 0 : _a.layoutBox, sourceBox);
-      }
-      if (hasTransform(this.latestValues)) {
-        removeBoxTransforms(boxWithoutTransform, this.latestValues);
-      }
-      return boxWithoutTransform;
-    }
-    setTargetDelta(delta) {
-      this.targetDelta = delta;
-      this.root.scheduleUpdateProjection();
-      this.isProjectionDirty = true;
-    }
-    setOptions(options) {
-      this.options = {
-        ...this.options,
-        ...options,
-        crossfade: options.crossfade !== void 0 ? options.crossfade : true
-      };
-    }
-    clearMeasurements() {
-      this.scroll = void 0;
-      this.layout = void 0;
-      this.snapshot = void 0;
-      this.prevTransformTemplateValue = void 0;
-      this.targetDelta = void 0;
-      this.target = void 0;
-      this.isLayoutDirty = false;
-    }
-    forceRelativeParentToResolveTarget() {
-      if (!this.relativeParent)
-        return;
-      if (this.relativeParent.resolvedRelativeTargetAt !== frameData.timestamp) {
-        this.relativeParent.resolveTargetDelta(true);
-      }
-    }
-    resolveTargetDelta(forceRecalculation = false) {
-      var _a;
-      const lead = this.getLead();
-      this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);
-      this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);
-      this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);
-      const isShared = Boolean(this.resumingFrom) || this !== lead;
-      const canSkip = !(forceRecalculation || isShared && this.isSharedProjectionDirty || this.isProjectionDirty || ((_a = this.parent) == null ? void 0 : _a.isProjectionDirty) || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize);
-      if (canSkip)
-        return;
-      const { layout, layoutId } = this.options;
-      if (!this.layout || !(layout || layoutId))
-        return;
-      this.resolvedRelativeTargetAt = frameData.timestamp;
-      const relativeParent = this.getClosestProjectingParent();
-      if (relativeParent && this.linkedParentVersion !== relativeParent.layoutVersion && !relativeParent.options.layoutRoot) {
-        this.removeRelativeTarget();
-      }
-      if (!this.targetDelta && !this.relativeTarget) {
-        if (this.options.layoutAnchor !== false && relativeParent && relativeParent.layout) {
-          this.createRelativeTarget(relativeParent, this.layout.layoutBox, relativeParent.layout.layoutBox);
-        } else {
-          this.removeRelativeTarget();
-        }
-      }
-      if (!this.relativeTarget && !this.targetDelta)
-        return;
-      if (!this.target) {
-        this.target = createBox();
-        this.targetWithTransforms = createBox();
-      }
-      if (this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target) {
-        this.forceRelativeParentToResolveTarget();
-        calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target, this.options.layoutAnchor || void 0);
-      } else if (this.targetDelta) {
-        if (Boolean(this.resumingFrom)) {
-          this.applyTransform(this.layout.layoutBox, false, this.target);
-        } else {
-          copyBoxInto(this.target, this.layout.layoutBox);
-        }
-        applyBoxDelta(this.target, this.targetDelta);
-      } else {
-        copyBoxInto(this.target, this.layout.layoutBox);
-      }
-      if (this.attemptToResolveRelativeTarget) {
-        this.attemptToResolveRelativeTarget = false;
-        if (this.options.layoutAnchor !== false && relativeParent && Boolean(relativeParent.resumingFrom) === Boolean(this.resumingFrom) && !relativeParent.options.layoutScroll && relativeParent.target && this.animationProgress !== 1) {
-          this.createRelativeTarget(relativeParent, this.target, relativeParent.target);
-        } else {
-          this.relativeParent = this.relativeTarget = void 0;
-        }
-      }
-    }
-    getClosestProjectingParent() {
-      if (!this.parent || hasScale(this.parent.latestValues) || has2DTranslate(this.parent.latestValues)) {
-        return void 0;
-      }
-      if (this.parent.isProjecting()) {
-        return this.parent;
-      } else {
-        return this.parent.getClosestProjectingParent();
-      }
-    }
-    isProjecting() {
-      return Boolean((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
-    }
-    createRelativeTarget(relativeParent, layout, parentLayout) {
-      this.relativeParent = relativeParent;
-      this.linkedParentVersion = relativeParent.layoutVersion;
-      this.forceRelativeParentToResolveTarget();
-      this.relativeTarget = createBox();
-      this.relativeTargetOrigin = createBox();
-      calcRelativePosition(this.relativeTargetOrigin, layout, parentLayout, this.options.layoutAnchor || void 0);
-      copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);
-    }
-    removeRelativeTarget() {
-      this.relativeParent = this.relativeTarget = void 0;
-    }
-    calcProjection() {
-      var _a;
-      const lead = this.getLead();
-      const isShared = Boolean(this.resumingFrom) || this !== lead;
-      let canSkip = true;
-      if (this.isProjectionDirty || ((_a = this.parent) == null ? void 0 : _a.isProjectionDirty)) {
-        canSkip = false;
-      }
-      if (isShared && (this.isSharedProjectionDirty || this.isTransformDirty)) {
-        canSkip = false;
-      }
-      if (this.resolvedRelativeTargetAt === frameData.timestamp) {
-        canSkip = false;
-      }
-      if (canSkip)
-        return;
-      const { layout, layoutId } = this.options;
-      this.isTreeAnimating = Boolean(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation);
-      if (!this.isTreeAnimating) {
-        this.targetDelta = this.relativeTarget = void 0;
-      }
-      if (!this.layout || !(layout || layoutId))
-        return;
-      copyBoxInto(this.layoutCorrected, this.layout.layoutBox);
-      const prevTreeScaleX = this.treeScale.x;
-      const prevTreeScaleY = this.treeScale.y;
-      applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);
-      if (lead.layout && !lead.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1)) {
-        lead.target = lead.layout.layoutBox;
-        lead.targetWithTransforms = createBox();
-      }
-      const { target } = lead;
-      if (!target) {
-        if (this.prevProjectionDelta) {
-          this.createProjectionDeltas();
-          this.scheduleRender();
-        }
-        return;
-      }
-      if (!this.projectionDelta || !this.prevProjectionDelta) {
-        this.createProjectionDeltas();
-      } else {
-        copyAxisDeltaInto(this.prevProjectionDelta.x, this.projectionDelta.x);
-        copyAxisDeltaInto(this.prevProjectionDelta.y, this.projectionDelta.y);
-      }
-      calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);
-      if (this.treeScale.x !== prevTreeScaleX || this.treeScale.y !== prevTreeScaleY || !axisDeltaEquals(this.projectionDelta.x, this.prevProjectionDelta.x) || !axisDeltaEquals(this.projectionDelta.y, this.prevProjectionDelta.y)) {
-        this.hasProjected = true;
-        this.scheduleRender();
-        this.notifyListeners("projectionUpdate", target);
-      }
-    }
-    hide() {
-      this.isVisible = false;
-    }
-    show() {
-      this.isVisible = true;
-    }
-    scheduleRender(notifyAll = true) {
-      var _a;
-      (_a = this.options.visualElement) == null ? void 0 : _a.scheduleRender();
-      if (notifyAll) {
-        const stack = this.getStack();
-        stack && stack.scheduleRender();
-      }
-      if (this.resumingFrom && !this.resumingFrom.instance) {
-        this.resumingFrom = void 0;
-      }
-    }
-    createProjectionDeltas() {
-      this.prevProjectionDelta = createDelta();
-      this.projectionDelta = createDelta();
-      this.projectionDeltaWithTransform = createDelta();
-    }
-    setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {
-      const snapshot = this.snapshot;
-      const snapshotLatestValues = snapshot ? snapshot.latestValues : {};
-      const mixedValues = { ...this.latestValues };
-      const targetDelta = createDelta();
-      if (!this.relativeParent || !this.relativeParent.options.layoutRoot) {
-        this.relativeTarget = this.relativeTargetOrigin = void 0;
-      }
-      this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;
-      const relativeLayout = createBox();
-      const snapshotSource = snapshot ? snapshot.source : void 0;
-      const layoutSource = this.layout ? this.layout.source : void 0;
-      const isSharedLayoutAnimation = snapshotSource !== layoutSource;
-      const stack = this.getStack();
-      const isOnlyMember = !stack || stack.members.length <= 1;
-      const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation && !isOnlyMember && this.options.crossfade === true && !this.path.some(hasOpacityCrossfade));
-      this.animationProgress = 0;
-      let prevRelativeTarget;
-      this.mixTargetDelta = (latest) => {
-        const progress = latest / 1e3;
-        mixAxisDelta(targetDelta.x, delta.x, progress);
-        mixAxisDelta(targetDelta.y, delta.y, progress);
-        this.setTargetDelta(targetDelta);
-        if (this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout) {
-          calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox, this.options.layoutAnchor || void 0);
-          mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);
-          if (prevRelativeTarget && boxEquals(this.relativeTarget, prevRelativeTarget)) {
-            this.isProjectionDirty = false;
-          }
-          if (!prevRelativeTarget)
-            prevRelativeTarget = createBox();
-          copyBoxInto(prevRelativeTarget, this.relativeTarget);
-        }
-        if (isSharedLayoutAnimation) {
-          this.animationValues = mixedValues;
-          mixValues(mixedValues, snapshotLatestValues, this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);
-        }
-        this.root.scheduleUpdateProjection();
-        this.scheduleRender();
-        this.animationProgress = progress;
-      };
-      this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
-    }
-    startAnimation(options) {
-      var _a, _b, _c;
-      this.notifyListeners("animationStart");
-      (_a = this.currentAnimation) == null ? void 0 : _a.stop();
-      (_c = (_b = this.resumingFrom) == null ? void 0 : _b.currentAnimation) == null ? void 0 : _c.stop();
-      if (this.pendingAnimation) {
-        cancelFrame(this.pendingAnimation);
-        this.pendingAnimation = void 0;
-      }
-      this.pendingAnimation = frame.update(() => {
-        globalProjectionState.hasAnimatedSinceResize = true;
-        this.motionValue || (this.motionValue = motionValue(0));
-        this.motionValue.jump(0, false);
-        this.currentAnimation = animateSingleValue(this.motionValue, [0, 1e3], {
-          ...options,
-          velocity: 0,
-          isSync: true,
-          onUpdate: (latest) => {
-            this.mixTargetDelta(latest);
-            options.onUpdate && options.onUpdate(latest);
-          },
-          onStop: () => {
-          },
-          onComplete: () => {
-            options.onComplete && options.onComplete();
-            this.completeAnimation();
-          }
-        });
-        if (this.resumingFrom) {
-          this.resumingFrom.currentAnimation = this.currentAnimation;
-        }
-        this.pendingAnimation = void 0;
-      });
-    }
-    completeAnimation() {
-      if (this.resumingFrom) {
-        this.resumingFrom.currentAnimation = void 0;
-        this.resumingFrom.preserveOpacity = void 0;
-      }
-      const stack = this.getStack();
-      stack && stack.exitAnimationComplete();
-      this.resumingFrom = this.currentAnimation = this.animationValues = void 0;
-      this.notifyListeners("animationComplete");
-    }
-    finishAnimation() {
-      if (this.currentAnimation) {
-        this.mixTargetDelta && this.mixTargetDelta(animationTarget);
-        this.currentAnimation.stop();
-      }
-      this.completeAnimation();
-    }
-    applyTransformsToTarget() {
-      const lead = this.getLead();
-      let { targetWithTransforms, target, layout, latestValues } = lead;
-      if (!targetWithTransforms || !target || !layout)
-        return;
-      if (this !== lead && this.layout && layout && shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout.layoutBox)) {
-        target = this.target || createBox();
-        const xLength = calcLength(this.layout.layoutBox.x);
-        target.x.min = lead.target.x.min;
-        target.x.max = target.x.min + xLength;
-        const yLength = calcLength(this.layout.layoutBox.y);
-        target.y.min = lead.target.y.min;
-        target.y.max = target.y.min + yLength;
-      }
-      copyBoxInto(targetWithTransforms, target);
-      transformBox(targetWithTransforms, latestValues);
-      calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);
-    }
-    registerSharedNode(layoutId, node) {
-      if (!this.sharedNodes.has(layoutId)) {
-        this.sharedNodes.set(layoutId, new NodeStack());
-      }
-      const stack = this.sharedNodes.get(layoutId);
-      stack.add(node);
-      const config = node.options.initialPromotionConfig;
-      node.promote({
-        transition: config ? config.transition : void 0,
-        preserveFollowOpacity: config && config.shouldPreserveFollowOpacity ? config.shouldPreserveFollowOpacity(node) : void 0
-      });
-    }
-    isLead() {
-      const stack = this.getStack();
-      return stack ? stack.lead === this : true;
-    }
-    getLead() {
-      var _a;
-      const { layoutId } = this.options;
-      return layoutId ? ((_a = this.getStack()) == null ? void 0 : _a.lead) || this : this;
-    }
-    getPrevLead() {
-      var _a;
-      const { layoutId } = this.options;
-      return layoutId ? (_a = this.getStack()) == null ? void 0 : _a.prevLead : void 0;
-    }
-    getStack() {
-      const { layoutId } = this.options;
-      if (layoutId)
-        return this.root.sharedNodes.get(layoutId);
-    }
-    promote({ needsReset, transition, preserveFollowOpacity } = {}) {
-      const stack = this.getStack();
-      if (stack)
-        stack.promote(this, preserveFollowOpacity);
-      if (needsReset) {
-        this.projectionDelta = void 0;
-        this.needsReset = true;
-      }
-      if (transition)
-        this.setOptions({ transition });
-    }
-    relegate() {
-      const stack = this.getStack();
-      if (stack) {
-        return stack.relegate(this);
-      } else {
-        return false;
-      }
-    }
-    resetSkewAndRotation() {
-      const { visualElement } = this.options;
-      if (!visualElement)
-        return;
-      let hasDistortingTransform = false;
-      const { latestValues } = visualElement;
-      if (latestValues.z || latestValues.rotate || latestValues.rotateX || latestValues.rotateY || latestValues.rotateZ || latestValues.skewX || latestValues.skewY) {
-        hasDistortingTransform = true;
-      }
-      if (!hasDistortingTransform)
-        return;
-      const resetValues = {};
-      if (latestValues.z) {
-        resetDistortingTransform("z", visualElement, resetValues, this.animationValues);
-      }
-      for (let i = 0; i < transformAxes.length; i++) {
-        resetDistortingTransform(`rotate${transformAxes[i]}`, visualElement, resetValues, this.animationValues);
-        resetDistortingTransform(`skew${transformAxes[i]}`, visualElement, resetValues, this.animationValues);
-      }
-      visualElement.render();
-      for (const key in resetValues) {
-        visualElement.setStaticValue(key, resetValues[key]);
-        if (this.animationValues) {
-          this.animationValues[key] = resetValues[key];
-        }
-      }
-      visualElement.scheduleRender();
-    }
-    applyProjectionStyles(targetStyle, styleProp) {
-      if (!this.instance || this.isSVG)
-        return;
-      if (!this.isVisible) {
-        targetStyle.visibility = "hidden";
-        return;
-      }
-      const transformTemplate = this.getTransformTemplate();
-      if (this.needsReset) {
-        this.needsReset = false;
-        targetStyle.visibility = "";
-        targetStyle.opacity = "";
-        targetStyle.pointerEvents = resolveMotionValue(styleProp == null ? void 0 : styleProp.pointerEvents) || "";
-        targetStyle.transform = transformTemplate ? transformTemplate(this.latestValues, "") : "none";
-        return;
-      }
-      const lead = this.getLead();
-      if (!this.projectionDelta || !this.layout || !lead.target) {
-        if (this.options.layoutId) {
-          targetStyle.opacity = this.latestValues.opacity !== void 0 ? this.latestValues.opacity : 1;
-          targetStyle.pointerEvents = resolveMotionValue(styleProp == null ? void 0 : styleProp.pointerEvents) || "";
-        }
-        if (this.hasProjected && !hasTransform(this.latestValues)) {
-          targetStyle.transform = transformTemplate ? transformTemplate({}, "") : "none";
-          this.hasProjected = false;
-        }
-        return;
-      }
-      targetStyle.visibility = "";
-      const valuesToRender = lead.animationValues || lead.latestValues;
-      this.applyTransformsToTarget();
-      let transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);
-      if (transformTemplate) {
-        transform = transformTemplate(valuesToRender, transform);
-      }
-      targetStyle.transform = transform;
-      const { x, y } = this.projectionDelta;
-      targetStyle.transformOrigin = `${x.origin * 100}% ${y.origin * 100}% 0`;
-      if (lead.animationValues) {
-        targetStyle.opacity = lead === this ? valuesToRender.opacity ?? this.latestValues.opacity ?? 1 : this.preserveOpacity ? this.latestValues.opacity : valuesToRender.opacityExit;
-      } else {
-        targetStyle.opacity = lead === this ? valuesToRender.opacity !== void 0 ? valuesToRender.opacity : "" : valuesToRender.opacityExit !== void 0 ? valuesToRender.opacityExit : 0;
-      }
-      for (const key in scaleCorrectors) {
-        if (valuesToRender[key] === void 0)
-          continue;
-        const { correct, applyTo, isCSSVariable } = scaleCorrectors[key];
-        const corrected = transform === "none" ? valuesToRender[key] : correct(valuesToRender[key], lead);
-        if (applyTo) {
-          const num = applyTo.length;
-          for (let i = 0; i < num; i++) {
-            targetStyle[applyTo[i]] = corrected;
-          }
-        } else {
-          if (isCSSVariable) {
-            this.options.visualElement.renderState.vars[key] = corrected;
-          } else {
-            targetStyle[key] = corrected;
-          }
-        }
-      }
-      if (this.options.layoutId) {
-        targetStyle.pointerEvents = lead === this ? resolveMotionValue(styleProp == null ? void 0 : styleProp.pointerEvents) || "" : "none";
-      }
-    }
-    clearSnapshot() {
-      this.resumeFrom = this.snapshot = void 0;
-    }
-    // Only run on root
-    resetTree() {
-      this.root.nodes.forEach((node) => {
-        var _a;
-        return (_a = node.currentAnimation) == null ? void 0 : _a.stop();
-      });
-      this.root.nodes.forEach(clearMeasurements);
-      this.root.sharedNodes.clear();
-    }
-  };
-}
-function updateLayout(node) {
-  node.updateLayout();
-}
-function notifyLayoutUpdate(node) {
-  var _a;
-  const snapshot = ((_a = node.resumeFrom) == null ? void 0 : _a.snapshot) || node.snapshot;
-  if (node.isLead() && node.layout && snapshot && node.hasListeners("didUpdate")) {
-    const { layoutBox: layout, measuredBox: measuredLayout } = node.layout;
-    const { animationType } = node.options;
-    const isShared = snapshot.source !== node.layout.source;
-    if (animationType === "size") {
-      eachAxis((axis) => {
-        const axisSnapshot = isShared ? snapshot.measuredBox[axis] : snapshot.layoutBox[axis];
-        const length = calcLength(axisSnapshot);
-        axisSnapshot.min = layout[axis].min;
-        axisSnapshot.max = axisSnapshot.min + length;
-      });
-    } else if (animationType === "x" || animationType === "y") {
-      const snapAxis = animationType === "x" ? "y" : "x";
-      copyAxisInto(isShared ? snapshot.measuredBox[snapAxis] : snapshot.layoutBox[snapAxis], layout[snapAxis]);
-    } else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout)) {
-      eachAxis((axis) => {
-        const axisSnapshot = isShared ? snapshot.measuredBox[axis] : snapshot.layoutBox[axis];
-        const length = calcLength(layout[axis]);
-        axisSnapshot.max = axisSnapshot.min + length;
-        if (node.relativeTarget && !node.currentAnimation) {
-          node.isProjectionDirty = true;
-          node.relativeTarget[axis].max = node.relativeTarget[axis].min + length;
-        }
-      });
-    }
-    const layoutDelta = createDelta();
-    calcBoxDelta(layoutDelta, layout, snapshot.layoutBox);
-    const visualDelta = createDelta();
-    if (isShared) {
-      calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measuredBox);
-    } else {
-      calcBoxDelta(visualDelta, layout, snapshot.layoutBox);
-    }
-    const hasLayoutChanged = !isDeltaZero(layoutDelta);
-    let hasRelativeLayoutChanged = false;
-    if (!node.resumeFrom) {
-      const relativeParent = node.getClosestProjectingParent();
-      if (relativeParent && !relativeParent.resumeFrom) {
-        const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;
-        if (parentSnapshot && parentLayout) {
-          const anchor = node.options.layoutAnchor || void 0;
-          const relativeSnapshot = createBox();
-          calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox, anchor);
-          const relativeLayout = createBox();
-          calcRelativePosition(relativeLayout, layout, parentLayout.layoutBox, anchor);
-          if (!boxEqualsRounded(relativeSnapshot, relativeLayout)) {
-            hasRelativeLayoutChanged = true;
-          }
-          if (relativeParent.options.layoutRoot) {
-            node.relativeTarget = relativeLayout;
-            node.relativeTargetOrigin = relativeSnapshot;
-            node.relativeParent = relativeParent;
-          }
-        }
-      }
-    }
-    node.notifyListeners("didUpdate", {
-      layout,
-      snapshot,
-      delta: visualDelta,
-      layoutDelta,
-      hasLayoutChanged,
-      hasRelativeLayoutChanged
-    });
-  } else if (node.isLead()) {
-    const { onExitComplete } = node.options;
-    onExitComplete && onExitComplete();
-  }
-  node.options.transition = void 0;
-}
-function propagateDirtyNodes(node) {
-  if (!node.parent)
-    return;
-  if (!node.isProjecting()) {
-    node.isProjectionDirty = node.parent.isProjectionDirty;
-  }
-  node.isSharedProjectionDirty || (node.isSharedProjectionDirty = Boolean(node.isProjectionDirty || node.parent.isProjectionDirty || node.parent.isSharedProjectionDirty));
-  node.isTransformDirty || (node.isTransformDirty = node.parent.isTransformDirty);
-}
-function cleanDirtyNodes(node) {
-  node.isProjectionDirty = node.isSharedProjectionDirty = node.isTransformDirty = false;
-}
-function clearSnapshot(node) {
-  node.clearSnapshot();
-}
-function clearMeasurements(node) {
-  node.clearMeasurements();
-}
-function forceLayoutMeasure(node) {
-  node.isLayoutDirty = true;
-  node.updateLayout();
-}
-function clearIsLayoutDirty(node) {
-  node.isLayoutDirty = false;
-}
-function ensureDraggedNodesSnapshotted(node) {
-  if (node.isAnimationBlocked && node.layout && !node.isLayoutDirty) {
-    node.snapshot = node.layout;
-    node.isLayoutDirty = true;
-  }
-}
-function resetTransformStyle(node) {
-  const { visualElement } = node.options;
-  if (visualElement && visualElement.getProps().onBeforeLayoutMeasure) {
-    visualElement.notify("BeforeLayoutMeasure");
-  }
-  node.resetTransform();
-}
-function finishAnimation(node) {
-  node.finishAnimation();
-  node.targetDelta = node.relativeTarget = node.target = void 0;
-  node.isProjectionDirty = true;
-}
-function resolveTargetDelta(node) {
-  node.resolveTargetDelta();
-}
-function calcProjection(node) {
-  node.calcProjection();
-}
-function resetSkewAndRotation(node) {
-  node.resetSkewAndRotation();
-}
-function removeLeadSnapshots(stack) {
-  stack.removeLeadSnapshot();
-}
-function mixAxisDelta(output, delta, p) {
-  output.translate = mixNumber(delta.translate, 0, p);
-  output.scale = mixNumber(delta.scale, 1, p);
-  output.origin = delta.origin;
-  output.originPoint = delta.originPoint;
-}
-function mixAxis(output, from, to, p) {
-  output.min = mixNumber(from.min, to.min, p);
-  output.max = mixNumber(from.max, to.max, p);
-}
-function mixBox(output, from, to, p) {
-  mixAxis(output.x, from.x, to.x, p);
-  mixAxis(output.y, from.y, to.y, p);
-}
-function hasOpacityCrossfade(node) {
-  return node.animationValues && node.animationValues.opacityExit !== void 0;
-}
-const defaultLayoutTransition = {
-  duration: 0.45,
-  ease: [0.4, 0, 0.1, 1]
-};
-const userAgentContains = (string) => typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().includes(string);
-const roundPoint = userAgentContains("applewebkit/") && !userAgentContains("chrome/") ? Math.round : noop;
-function roundAxis(axis) {
-  axis.min = roundPoint(axis.min);
-  axis.max = roundPoint(axis.max);
-}
-function roundBox(box) {
-  roundAxis(box.x);
-  roundAxis(box.y);
-}
-function shouldAnimatePositionOnly(animationType, snapshot, layout) {
-  return animationType === "position" || animationType === "preserve-aspect" && !isNear(aspectRatio(snapshot), aspectRatio(layout), 0.2);
-}
-function checkNodeWasScrollRoot(node) {
-  var _a;
-  return node !== node.root && ((_a = node.scroll) == null ? void 0 : _a.wasRoot);
-}
-export {
-  cleanDirtyNodes,
-  createProjectionNode,
-  mixAxis,
-  mixAxisDelta,
-  mixBox,
-  propagateDirtyNodes
-};
-//# sourceMappingURL=create-projection-node.js.map