frontend-admin / Daocheng-Yading

  'use strict';
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  var jsxRuntime = require('react/jsx-runtime');
  require('motion-utils');
  var react = require('react');
  var motionDom = require('motion-dom');
  
  const LayoutGroupContext = react.createContext({});
  
  const LazyContext = react.createContext({ strict: false });
  
  /**
   * @public
   */
  const MotionConfigContext = react.createContext({
      transformPagePoint: (p) => p,
      isStatic: false,
      reducedMotion: "never",
  });
  
  const MotionContext = /* @__PURE__ */ react.createContext({});
  
  function getCurrentTreeVariants(props, context) {
      if (motionDom.isControllingVariants(props)) {
          const { initial, animate } = props;
          return {
              initial: initial === false || motionDom.isVariantLabel(initial)
                  ? initial
                  : undefined,
              animate: motionDom.isVariantLabel(animate) ? animate : undefined,
          };
      }
      return props.inherit !== false ? context : {};
  }
  
  function useCreateMotionContext(props) {
      const { initial, animate } = getCurrentTreeVariants(props, react.useContext(MotionContext));
      return react.useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
  }
  function variantLabelsAsDependency(prop) {
      return Array.isArray(prop) ? prop.join(" ") : prop;
  }
  
  const createHtmlRenderState = () => ({
      style: {},
      transform: {},
      transformOrigin: {},
      vars: {},
  });
  
  function copyRawValuesOnly(target, source, props) {
      for (const key in source) {
          if (!motionDom.isMotionValue(source[key]) && !motionDom.isForcedMotionValue(key, props)) {
              target[key] = source[key];
          }
      }
  }
  function useInitialMotionValues({ transformTemplate }, visualState) {
      return react.useMemo(() => {
          const state = createHtmlRenderState();
          motionDom.buildHTMLStyles(state, visualState, transformTemplate);
          return Object.assign({}, state.vars, state.style);
      }, [visualState]);
  }
  function useStyle(props, visualState) {
      const styleProp = props.style || {};
      const style = {};
      /**
       * Copy non-Motion Values straight into style
       */
      copyRawValuesOnly(style, styleProp, props);
      Object.assign(style, useInitialMotionValues(props, visualState));
      return style;
  }
  function useHTMLProps(props, visualState) {
      // The `any` isn't ideal but it is the type of createElement props argument
      const htmlProps = {};
      const style = useStyle(props, visualState);
      if (props.drag && props.dragListener !== false) {
          // Disable the ghost element when a user drags
          htmlProps.draggable = false;
          // Disable text selection
          style.userSelect =
              style.WebkitUserSelect =
                  style.WebkitTouchCallout =
                      "none";
          // Disable scrolling on the draggable direction
          style.touchAction =
              props.drag === true
                  ? "none"
                  : `pan-${props.drag === "x" ? "y" : "x"}`;
      }
      if (props.tabIndex === undefined &&
          (props.onTap || props.onTapStart || props.whileTap)) {
          htmlProps.tabIndex = 0;
      }
      htmlProps.style = style;
      return htmlProps;
  }
  
  const createSvgRenderState = () => ({
      ...createHtmlRenderState(),
      attrs: {},
  });
  
  function useSVGProps(props, visualState, _isStatic, Component) {
      const visualProps = react.useMemo(() => {
          const state = createSvgRenderState();
          motionDom.buildSVGAttrs(state, visualState, motionDom.isSVGTag(Component), props.transformTemplate, props.style);
          return {
              ...state.attrs,
              style: { ...state.style },
          };
      }, [visualState]);
      if (props.style) {
          const rawStyles = {};
          copyRawValuesOnly(rawStyles, props.style, props);
          visualProps.style = { ...rawStyles, ...visualProps.style };
      }
      return visualProps;
  }
  
  /**
   * A list of all valid MotionProps.
   *
   * @privateRemarks
   * This doesn't throw if a `MotionProp` name is missing - it should.
   */
  const validMotionProps = 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",
  ]);
  /**
   * Check whether a prop name is a valid `MotionProp` key.
   *
   * @param key - Name of the property to check
   * @returns `true` is key is a valid `MotionProp`.
   *
   * @public
   */
  function isValidMotionProp(key) {
      return (key.startsWith("while") ||
          (key.startsWith("drag") && key !== "draggable") ||
          key.startsWith("layout") ||
          key.startsWith("onTap") ||
          key.startsWith("onPan") ||
          key.startsWith("onLayout") ||
          validMotionProps.has(key));
  }
  
  let shouldForward = (key) => !isValidMotionProp(key);
  function loadExternalIsValidProp(isValidProp) {
      if (typeof isValidProp !== "function")
          return;
      // Explicitly filter our events
      shouldForward = (key) => key.startsWith("on") ? !isValidMotionProp(key) : isValidProp(key);
  }
  /**
   * Emotion and Styled Components both allow users to pass through arbitrary props to their components
   * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which
   * of these should be passed to the underlying DOM node.
   *
   * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props
   * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props
   * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of
   * `@emotion/is-prop-valid`, however to fix this problem we need to use it.
   *
   * By making it an optionalDependency we can offer this functionality only in the situations where it's
   * actually required.
   */
  try {
      /**
       * We attempt to import this package but require won't be defined in esm environments, in that case
       * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed
       * in favour of explicit injection.
       *
       * String concatenation prevents bundlers like webpack (e.g. Storybook)
       * from statically resolving this optional dependency at build time.
       */
      const emotionPkg = "@emotion/is-prop-" + "valid";
      loadExternalIsValidProp(require(emotionPkg).default);
  }
  catch {
      // We don't need to actually do anything here - the fallback is the existing `isPropValid`.
  }
  function filterProps(props, isDom, forwardMotionProps) {
      const filteredProps = {};
      for (const key in props) {
          /**
           * values is considered a valid prop by Emotion, so if it's present
           * this will be rendered out to the DOM unless explicitly filtered.
           *
           * We check the type as it could be used with the `feColorMatrix`
           * element, which we support.
           */
          if (key === "values" && typeof props.values === "object")
              continue;
          if (motionDom.isMotionValue(props[key]))
              continue;
          if (shouldForward(key) ||
              (forwardMotionProps === true && isValidMotionProp(key)) ||
              (!isDom && !isValidMotionProp(key)) ||
              // If trying to use native HTML drag events, forward drag listeners
              (props["draggable"] &&
                  key.startsWith("onDrag"))) {
              filteredProps[key] =
                  props[key];
          }
      }
      return filteredProps;
  }
  
  /**
   * We keep these listed separately as we use the lowercase tag names as part
   * of the runtime bundle to detect SVG components
   */
  const lowercaseSVGElements = [
      "animate",
      "circle",
      "defs",
      "desc",
      "ellipse",
      "g",
      "image",
      "line",
      "filter",
      "marker",
      "mask",
      "metadata",
      "path",
      "pattern",
      "polygon",
      "polyline",
      "rect",
      "stop",
      "switch",
      "symbol",
      "svg",
      "text",
      "tspan",
      "use",
      "view",
  ];
  
  function isSVGComponent(Component) {
      if (
      /**
       * If it's not a string, it's a custom React component. Currently we only support
       * HTML custom React components.
       */
      typeof Component !== "string" ||
          /**
           * If it contains a dash, the element is a custom HTML webcomponent.
           */
          Component.includes("-")) {
          return false;
      }
      else if (
      /**
       * If it's in our list of lowercase SVG tags, it's an SVG component
       */
      lowercaseSVGElements.indexOf(Component) > -1 ||
          /**
           * If it contains a capital letter, it's an SVG component
           */
          /[A-Z]/u.test(Component)) {
          return true;
      }
      return false;
  }
  
  function useRender(Component, props, ref, { latestValues, }, isStatic, forwardMotionProps = false, isSVG) {
      const useVisualProps = (isSVG ?? isSVGComponent(Component)) ? useSVGProps : useHTMLProps;
      const visualProps = useVisualProps(props, latestValues, isStatic, Component);
      const filteredProps = filterProps(props, typeof Component === "string", forwardMotionProps);
      const elementProps = Component !== react.Fragment ? { ...filteredProps, ...visualProps, ref } : {};
      /**
       * If component has been handed a motion value as its child,
       * memoise its initial value and render that. Subsequent updates
       * will be handled by the onChange handler
       */
      const { children } = props;
      const renderedChildren = react.useMemo(() => (motionDom.isMotionValue(children) ? children.get() : children), [children]);
      return react.createElement(Component, {
          ...elementProps,
          children: renderedChildren,
      });
  }
  
  /**
   * @public
   */
  const PresenceContext = 
  /* @__PURE__ */ react.createContext(null);
  
  /**
   * Creates a constant value over the lifecycle of a component.
   *
   * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer
   * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`
   * you can ensure that initialisers don't execute twice or more.
   */
  function useConstant(init) {
      const ref = react.useRef(null);
      if (ref.current === null) {
          ref.current = init();
      }
      return ref.current;
  }
  
  function makeState({ scrapeMotionValuesFromProps, createRenderState, }, props, context, presenceContext) {
      const state = {
          latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),
          renderState: createRenderState(),
      };
      return state;
  }
  function makeLatestValues(props, context, presenceContext, scrapeMotionValues) {
      const values = {};
      const motionValues = scrapeMotionValues(props, {});
      for (const key in motionValues) {
          values[key] = motionDom.resolveMotionValue(motionValues[key]);
      }
      let { initial, animate } = props;
      const isControllingVariants = motionDom.isControllingVariants(props);
      const isVariantNode = motionDom.isVariantNode(props);
      if (context &&
          isVariantNode &&
          !isControllingVariants &&
          props.inherit !== false) {
          if (initial === undefined)
              initial = context.initial;
          if (animate === undefined)
              animate = context.animate;
      }
      let isInitialAnimationBlocked = presenceContext
          ? presenceContext.initial === false
          : false;
      isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;
      const variantToSet = isInitialAnimationBlocked ? animate : initial;
      if (variantToSet &&
          typeof variantToSet !== "boolean" &&
          !motionDom.isAnimationControls(variantToSet)) {
          const list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];
          for (let i = 0; i < list.length; i++) {
              const resolved = motionDom.resolveVariantFromProps(props, list[i]);
              if (resolved) {
                  const { transitionEnd, transition, ...target } = resolved;
                  for (const key in target) {
                      let valueTarget = target[key];
                      if (Array.isArray(valueTarget)) {
                          /**
                           * Take final keyframe if the initial animation is blocked because
                           * we want to initialise at the end of that blocked animation.
                           */
                          const index = isInitialAnimationBlocked
                              ? valueTarget.length - 1
                              : 0;
                          valueTarget = valueTarget[index];
                      }
                      if (valueTarget !== null) {
                          values[key] = valueTarget;
                      }
                  }
                  for (const key in transitionEnd) {
                      values[key] = transitionEnd[key];
                  }
              }
          }
      }
      return values;
  }
  const makeUseVisualState = (config) => (props, isStatic) => {
      const context = react.useContext(MotionContext);
      const presenceContext = react.useContext(PresenceContext);
      const make = () => makeState(config, props, context, presenceContext);
      return isStatic ? make() : useConstant(make);
  };
  
  const useHTMLVisualState = /*@__PURE__*/ makeUseVisualState({
      scrapeMotionValuesFromProps: motionDom.scrapeHTMLMotionValuesFromProps,
      createRenderState: createHtmlRenderState,
  });
  
  const useSVGVisualState = /*@__PURE__*/ makeUseVisualState({
      scrapeMotionValuesFromProps: motionDom.scrapeSVGMotionValuesFromProps,
      createRenderState: createSvgRenderState,
  });
  
  const featureProps = {
      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 isInitialized = false;
  /**
   * Initialize feature definitions with isEnabled checks.
   * This must be called before any motion components are rendered.
   */
  function initFeatureDefinitions() {
      if (isInitialized)
          return;
      const initialFeatureDefinitions = {};
      for (const key in featureProps) {
          initialFeatureDefinitions[key] = {
              isEnabled: (props) => featureProps[key].some((name) => !!props[name]),
          };
      }
      motionDom.setFeatureDefinitions(initialFeatureDefinitions);
      isInitialized = true;
  }
  /**
   * Get the current feature definitions, initializing if needed.
   */
  function getInitializedFeatureDefinitions() {
      initFeatureDefinitions();
      return motionDom.getFeatureDefinitions();
  }
  
  const motionComponentSymbol = Symbol.for("motionComponentSymbol");
  
  /**
   * Creates a ref function that, when called, hydrates the provided
   * external ref and VisualElement.
   */
  function useMotionRef(visualState, visualElement, externalRef) {
      /**
       * Store externalRef in a ref to avoid including it in the useCallback
       * dependency array. Including externalRef in dependencies causes issues
       * with libraries like Radix UI that create new callback refs on each render
       * when using asChild - this would cause the callback to be recreated,
       * triggering element remounts and breaking AnimatePresence exit animations.
       */
      const externalRefContainer = react.useRef(externalRef);
      react.useInsertionEffect(() => {
          externalRefContainer.current = externalRef;
      });
      // Store cleanup function returned by callback refs (React 19 feature)
      const refCleanup = react.useRef(null);
      return react.useCallback((instance) => {
          if (instance) {
              visualState.onMount?.(instance);
          }
          const ref = externalRefContainer.current;
          if (typeof ref === "function") {
              if (instance) {
                  const cleanup = ref(instance);
                  if (typeof cleanup === "function") {
                      refCleanup.current = cleanup;
                  }
              }
              else if (refCleanup.current) {
                  refCleanup.current();
                  refCleanup.current = null;
              }
              else {
                  ref(instance);
              }
          }
          else if (ref) {
              ref.current = instance;
          }
          if (visualElement) {
              instance ? visualElement.mount(instance) : visualElement.unmount();
          }
      }, [visualElement]);
  }
  
  /**
   * Internal, exported only for usage in Framer
   */
  const SwitchLayoutGroupContext = react.createContext({});
  
  function isRefObject(ref) {
      return (ref &&
          typeof ref === "object" &&
          Object.prototype.hasOwnProperty.call(ref, "current"));
  }
  
  const isBrowser = typeof window !== "undefined";
  
  const useIsomorphicLayoutEffect = isBrowser ? react.useLayoutEffect : react.useEffect;
  
  function useVisualElement(Component, visualState, props, createVisualElement, ProjectionNodeConstructor, isSVG) {
      const { visualElement: parent } = react.useContext(MotionContext);
      const lazyContext = react.useContext(LazyContext);
      const presenceContext = react.useContext(PresenceContext);
      const motionConfig = react.useContext(MotionConfigContext);
      const reducedMotionConfig = motionConfig.reducedMotion;
      const skipAnimations = motionConfig.skipAnimations;
      const visualElementRef = react.useRef(null);
      /**
       * Track whether the component has been through React's commit phase.
       * Used to detect when LazyMotion features load after the component has mounted.
       */
      const hasMountedOnce = react.useRef(false);
      /**
       * If we haven't preloaded a renderer, check to see if we have one lazy-loaded
       */
      createVisualElement =
          createVisualElement ||
              lazyContext.renderer;
      if (!visualElementRef.current && createVisualElement) {
          visualElementRef.current = createVisualElement(Component, {
              visualState,
              parent,
              props,
              presenceContext,
              blockInitialAnimation: presenceContext
                  ? presenceContext.initial === false
                  : false,
              reducedMotionConfig,
              skipAnimations,
              isSVG,
          });
          /**
           * If the component has already mounted before features loaded (e.g. via
           * LazyMotion with async feature loading), we need to force the initial
           * animation to run. Otherwise state changes that occurred before features
           * loaded will be lost and the element will snap to its final state.
           */
          if (hasMountedOnce.current && visualElementRef.current) {
              visualElementRef.current.manuallyAnimateOnMount = true;
          }
      }
      const visualElement = visualElementRef.current;
      /**
       * Load Motion gesture and animation features. These are rendered as renderless
       * components so each feature can optionally make use of React lifecycle methods.
       */
      const initialLayoutGroupConfig = react.useContext(SwitchLayoutGroupContext);
      if (visualElement &&
          !visualElement.projection &&
          ProjectionNodeConstructor &&
          (visualElement.type === "html" || visualElement.type === "svg")) {
          createProjectionNode(visualElementRef.current, props, ProjectionNodeConstructor, initialLayoutGroupConfig);
      }
      const isMounted = react.useRef(false);
      react.useInsertionEffect(() => {
          /**
           * Check the component has already mounted before calling
           * `update` unnecessarily. This ensures we skip the initial update.
           */
          if (visualElement && isMounted.current) {
              visualElement.update(props, presenceContext);
          }
      });
      /**
       * Cache this value as we want to know whether HandoffAppearAnimations
       * was present on initial render - it will be deleted after this.
       */
      const optimisedAppearId = props[motionDom.optimizedAppearDataAttribute];
      const wantsHandoff = react.useRef(Boolean(optimisedAppearId) &&
          typeof window !== "undefined" &&
          !window.MotionHandoffIsComplete?.(optimisedAppearId) &&
          window.MotionHasOptimisedAnimation?.(optimisedAppearId));
      useIsomorphicLayoutEffect(() => {
          /**
           * Track that this component has mounted. This is used to detect when
           * LazyMotion features load after the component has already committed.
           */
          hasMountedOnce.current = true;
          if (!visualElement)
              return;
          isMounted.current = true;
          window.MotionIsMounted = true;
          visualElement.updateFeatures();
          visualElement.scheduleRenderMicrotask();
          /**
           * Ideally this function would always run in a useEffect.
           *
           * However, if we have optimised appear animations to handoff from,
           * it needs to happen synchronously to ensure there's no flash of
           * incorrect styles in the event of a hydration error.
           *
           * So if we detect a situtation where optimised appear animations
           * are running, we use useLayoutEffect to trigger animations.
           */
          if (wantsHandoff.current && visualElement.animationState) {
              visualElement.animationState.animateChanges();
          }
      });
      react.useEffect(() => {
          if (!visualElement)
              return;
          if (!wantsHandoff.current && visualElement.animationState) {
              visualElement.animationState.animateChanges();
          }
          if (wantsHandoff.current) {
              // This ensures all future calls to animateChanges() in this component will run in useEffect
              queueMicrotask(() => {
                  window.MotionHandoffMarkAsComplete?.(optimisedAppearId);
              });
              wantsHandoff.current = false;
          }
          /**
           * Now we've finished triggering animations for this element we
           * can wipe the enteringChildren set for the next render.
           */
          visualElement.enteringChildren = undefined;
      });
      return visualElement;
  }
  function createProjectionNode(visualElement, props, ProjectionNodeConstructor, initialPromotionConfig) {
      const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, layoutAnchor, layoutCrossfade, } = props;
      visualElement.projection = new ProjectionNodeConstructor(visualElement.latestValues, props["data-framer-portal-id"]
          ? undefined
          : getClosestProjectingNode(visualElement.parent));
      visualElement.projection.setOptions({
          layoutId,
          layout,
          alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),
          visualElement,
          /**
           * 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 layout === "string" ? layout : "both",
          initialPromotionConfig,
          crossfade: layoutCrossfade,
          layoutScroll,
          layoutRoot,
          layoutAnchor,
      });
  }
  function getClosestProjectingNode(visualElement) {
      if (!visualElement)
          return undefined;
      return visualElement.options.allowProjection !== false
          ? visualElement.projection
          : getClosestProjectingNode(visualElement.parent);
  }
  
  /**
   * Create a `motion` component.
   *
   * This function accepts a Component argument, which can be either a string (ie "div"
   * for `motion.div`), or an actual React component.
   *
   * Alongside this is a config option which provides a way of rendering the provided
   * component "offline", or outside the React render cycle.
   */
  function createMotionComponent(Component, { forwardMotionProps = false, type } = {}, preloadedFeatures, createVisualElement) {
      /**
       * Determine whether to use SVG or HTML rendering based on:
       * 1. Explicit `type` option (highest priority)
       * 2. Auto-detection via `isSVGComponent`
       */
      const isSVG = type ? type === "svg" : isSVGComponent(Component);
      const useVisualState = isSVG ? useSVGVisualState : useHTMLVisualState;
      function MotionDOMComponent(props, externalRef) {
          /**
           * If we need to measure the element we load this functionality in a
           * separate class component in order to gain access to getSnapshotBeforeUpdate.
           */
          let MeasureLayout;
          const configAndProps = {
              ...react.useContext(MotionConfigContext),
              ...props,
              layoutId: useLayoutId(props),
          };
          const { isStatic } = configAndProps;
          const context = useCreateMotionContext(props);
          const visualState = useVisualState(props, isStatic);
          if (!isStatic && typeof window !== "undefined") {
              useStrictMode(configAndProps, preloadedFeatures);
              const layoutProjection = getProjectionFunctionality(configAndProps);
              MeasureLayout = layoutProjection.MeasureLayout;
              /**
               * Create a VisualElement for this component. A VisualElement provides a common
               * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as
               * providing a way of rendering to these APIs outside of the React render loop
               * for more performant animations and interactions
               */
              context.visualElement = useVisualElement(Component, visualState, configAndProps, createVisualElement, layoutProjection.ProjectionNode, isSVG);
          }
          /**
           * The mount order and hierarchy is specific to ensure our element ref
           * is hydrated by the time features fire their effects.
           */
          return (jsxRuntime.jsxs(MotionContext.Provider, { value: context, children: [MeasureLayout && context.visualElement ? (jsxRuntime.jsx(MeasureLayout, { visualElement: context.visualElement, ...configAndProps })) : null, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, forwardMotionProps, isSVG)] }));
      }
      MotionDOMComponent.displayName = `motion.${typeof Component === "string"
          ? Component
          : `create(${Component.displayName ?? Component.name ?? ""})`}`;
      const ForwardRefMotionComponent = react.forwardRef(MotionDOMComponent);
      ForwardRefMotionComponent[motionComponentSymbol] = Component;
      return ForwardRefMotionComponent;
  }
  function useLayoutId({ layoutId }) {
      const layoutGroupId = react.useContext(LayoutGroupContext).id;
      return layoutGroupId && layoutId !== undefined
          ? layoutGroupId + "-" + layoutId
          : layoutId;
  }
  function useStrictMode(configAndProps, preloadedFeatures) {
      react.useContext(LazyContext).strict;
      /**
       * If we're in development mode, check to make sure we're not rendering a motion component
       * as a child of LazyMotion, as this will break the file-size benefits of using it.
       */
      if (process.env.NODE_ENV !== "production" &&
          preloadedFeatures) ;
  }
  function getProjectionFunctionality(props) {
      const featureDefinitions = getInitializedFeatureDefinitions();
      const { drag, layout } = featureDefinitions;
      if (!drag && !layout)
          return {};
      const combined = { ...drag, ...layout };
      return {
          MeasureLayout: drag?.isEnabled(props) || layout?.isEnabled(props)
              ? combined.MeasureLayout
              : undefined,
          ProjectionNode: combined.ProjectionNode,
      };
  }
  
  function createMinimalMotionComponent(Component, options) {
      return createMotionComponent(Component, options);
  }
  
  /**
   * HTML components
   */
  const MotionA = /*@__PURE__*/ createMinimalMotionComponent("a");
  const MotionAbbr = /*@__PURE__*/ createMinimalMotionComponent("abbr");
  const MotionAddress = 
  /*@__PURE__*/ createMinimalMotionComponent("address");
  const MotionArea = /*@__PURE__*/ createMinimalMotionComponent("area");
  const MotionArticle = 
  /*@__PURE__*/ createMinimalMotionComponent("article");
  const MotionAside = /*@__PURE__*/ createMinimalMotionComponent("aside");
  const MotionAudio = /*@__PURE__*/ createMinimalMotionComponent("audio");
  const MotionB = /*@__PURE__*/ createMinimalMotionComponent("b");
  const MotionBase = /*@__PURE__*/ createMinimalMotionComponent("base");
  const MotionBdi = /*@__PURE__*/ createMinimalMotionComponent("bdi");
  const MotionBdo = /*@__PURE__*/ createMinimalMotionComponent("bdo");
  const MotionBig = /*@__PURE__*/ createMinimalMotionComponent("big");
  const MotionBlockquote = 
  /*@__PURE__*/ createMinimalMotionComponent("blockquote");
  const MotionBody = /*@__PURE__*/ createMinimalMotionComponent("body");
  const MotionButton = /*@__PURE__*/ createMinimalMotionComponent("button");
  const MotionCanvas = /*@__PURE__*/ createMinimalMotionComponent("canvas");
  const MotionCaption = 
  /*@__PURE__*/ createMinimalMotionComponent("caption");
  const MotionCite = /*@__PURE__*/ createMinimalMotionComponent("cite");
  const MotionCode = /*@__PURE__*/ createMinimalMotionComponent("code");
  const MotionCol = /*@__PURE__*/ createMinimalMotionComponent("col");
  const MotionColgroup = 
  /*@__PURE__*/ createMinimalMotionComponent("colgroup");
  const MotionData = /*@__PURE__*/ createMinimalMotionComponent("data");
  const MotionDatalist = 
  /*@__PURE__*/ createMinimalMotionComponent("datalist");
  const MotionDd = /*@__PURE__*/ createMinimalMotionComponent("dd");
  const MotionDel = /*@__PURE__*/ createMinimalMotionComponent("del");
  const MotionDetails = 
  /*@__PURE__*/ createMinimalMotionComponent("details");
  const MotionDfn = /*@__PURE__*/ createMinimalMotionComponent("dfn");
  const MotionDialog = /*@__PURE__*/ createMinimalMotionComponent("dialog");
  const MotionDiv = /*@__PURE__*/ createMinimalMotionComponent("div");
  const MotionDl = /*@__PURE__*/ createMinimalMotionComponent("dl");
  const MotionDt = /*@__PURE__*/ createMinimalMotionComponent("dt");
  const MotionEm = /*@__PURE__*/ createMinimalMotionComponent("em");
  const MotionEmbed = /*@__PURE__*/ createMinimalMotionComponent("embed");
  const MotionFieldset = 
  /*@__PURE__*/ createMinimalMotionComponent("fieldset");
  const MotionFigcaption = 
  /*@__PURE__*/ createMinimalMotionComponent("figcaption");
  const MotionFigure = /*@__PURE__*/ createMinimalMotionComponent("figure");
  const MotionFooter = /*@__PURE__*/ createMinimalMotionComponent("footer");
  const MotionForm = /*@__PURE__*/ createMinimalMotionComponent("form");
  const MotionH1 = /*@__PURE__*/ createMinimalMotionComponent("h1");
  const MotionH2 = /*@__PURE__*/ createMinimalMotionComponent("h2");
  const MotionH3 = /*@__PURE__*/ createMinimalMotionComponent("h3");
  const MotionH4 = /*@__PURE__*/ createMinimalMotionComponent("h4");
  const MotionH5 = /*@__PURE__*/ createMinimalMotionComponent("h5");
  const MotionH6 = /*@__PURE__*/ createMinimalMotionComponent("h6");
  const MotionHead = /*@__PURE__*/ createMinimalMotionComponent("head");
  const MotionHeader = /*@__PURE__*/ createMinimalMotionComponent("header");
  const MotionHgroup = /*@__PURE__*/ createMinimalMotionComponent("hgroup");
  const MotionHr = /*@__PURE__*/ createMinimalMotionComponent("hr");
  const MotionHtml = /*@__PURE__*/ createMinimalMotionComponent("html");
  const MotionI = /*@__PURE__*/ createMinimalMotionComponent("i");
  const MotionIframe = /*@__PURE__*/ createMinimalMotionComponent("iframe");
  const MotionImg = /*@__PURE__*/ createMinimalMotionComponent("img");
  const MotionInput = /*@__PURE__*/ createMinimalMotionComponent("input");
  const MotionIns = /*@__PURE__*/ createMinimalMotionComponent("ins");
  const MotionKbd = /*@__PURE__*/ createMinimalMotionComponent("kbd");
  const MotionKeygen = /*@__PURE__*/ createMinimalMotionComponent("keygen");
  const MotionLabel = /*@__PURE__*/ createMinimalMotionComponent("label");
  const MotionLegend = /*@__PURE__*/ createMinimalMotionComponent("legend");
  const MotionLi = /*@__PURE__*/ createMinimalMotionComponent("li");
  const MotionLink = /*@__PURE__*/ createMinimalMotionComponent("link");
  const MotionMain = /*@__PURE__*/ createMinimalMotionComponent("main");
  const MotionMap = /*@__PURE__*/ createMinimalMotionComponent("map");
  const MotionMark = /*@__PURE__*/ createMinimalMotionComponent("mark");
  const MotionMenu = /*@__PURE__*/ createMinimalMotionComponent("menu");
  const MotionMenuitem = 
  /*@__PURE__*/ createMinimalMotionComponent("menuitem");
  const MotionMeter = /*@__PURE__*/ createMinimalMotionComponent("meter");
  const MotionNav = /*@__PURE__*/ createMinimalMotionComponent("nav");
  const MotionObject = /*@__PURE__*/ createMinimalMotionComponent("object");
  const MotionOl = /*@__PURE__*/ createMinimalMotionComponent("ol");
  const MotionOptgroup = 
  /*@__PURE__*/ createMinimalMotionComponent("optgroup");
  const MotionOption = /*@__PURE__*/ createMinimalMotionComponent("option");
  const MotionOutput = /*@__PURE__*/ createMinimalMotionComponent("output");
  const MotionP = /*@__PURE__*/ createMinimalMotionComponent("p");
  const MotionParam = /*@__PURE__*/ createMinimalMotionComponent("param");
  const MotionPicture = 
  /*@__PURE__*/ createMinimalMotionComponent("picture");
  const MotionPre = /*@__PURE__*/ createMinimalMotionComponent("pre");
  const MotionProgress = 
  /*@__PURE__*/ createMinimalMotionComponent("progress");
  const MotionQ = /*@__PURE__*/ createMinimalMotionComponent("q");
  const MotionRp = /*@__PURE__*/ createMinimalMotionComponent("rp");
  const MotionRt = /*@__PURE__*/ createMinimalMotionComponent("rt");
  const MotionRuby = /*@__PURE__*/ createMinimalMotionComponent("ruby");
  const MotionS = /*@__PURE__*/ createMinimalMotionComponent("s");
  const MotionSamp = /*@__PURE__*/ createMinimalMotionComponent("samp");
  const MotionScript = /*@__PURE__*/ createMinimalMotionComponent("script");
  const MotionSection = 
  /*@__PURE__*/ createMinimalMotionComponent("section");
  const MotionSelect = /*@__PURE__*/ createMinimalMotionComponent("select");
  const MotionSmall = /*@__PURE__*/ createMinimalMotionComponent("small");
  const MotionSource = /*@__PURE__*/ createMinimalMotionComponent("source");
  const MotionSpan = /*@__PURE__*/ createMinimalMotionComponent("span");
  const MotionStrong = /*@__PURE__*/ createMinimalMotionComponent("strong");
  const MotionStyle = /*@__PURE__*/ createMinimalMotionComponent("style");
  const MotionSub = /*@__PURE__*/ createMinimalMotionComponent("sub");
  const MotionSummary = 
  /*@__PURE__*/ createMinimalMotionComponent("summary");
  const MotionSup = /*@__PURE__*/ createMinimalMotionComponent("sup");
  const MotionTable = /*@__PURE__*/ createMinimalMotionComponent("table");
  const MotionTbody = /*@__PURE__*/ createMinimalMotionComponent("tbody");
  const MotionTd = /*@__PURE__*/ createMinimalMotionComponent("td");
  const MotionTextarea = 
  /*@__PURE__*/ createMinimalMotionComponent("textarea");
  const MotionTfoot = /*@__PURE__*/ createMinimalMotionComponent("tfoot");
  const MotionTh = /*@__PURE__*/ createMinimalMotionComponent("th");
  const MotionThead = /*@__PURE__*/ createMinimalMotionComponent("thead");
  const MotionTime = /*@__PURE__*/ createMinimalMotionComponent("time");
  const MotionTitle = /*@__PURE__*/ createMinimalMotionComponent("title");
  const MotionTr = /*@__PURE__*/ createMinimalMotionComponent("tr");
  const MotionTrack = /*@__PURE__*/ createMinimalMotionComponent("track");
  const MotionU = /*@__PURE__*/ createMinimalMotionComponent("u");
  const MotionUl = /*@__PURE__*/ createMinimalMotionComponent("ul");
  const MotionVideo = /*@__PURE__*/ createMinimalMotionComponent("video");
  const MotionWbr = /*@__PURE__*/ createMinimalMotionComponent("wbr");
  const MotionWebview = 
  /*@__PURE__*/ createMinimalMotionComponent("webview");
  /**
   * SVG components
   */
  const MotionAnimate = 
  /*@__PURE__*/ createMinimalMotionComponent("animate");
  const MotionCircle = /*@__PURE__*/ createMinimalMotionComponent("circle");
  const MotionDefs = /*@__PURE__*/ createMinimalMotionComponent("defs");
  const MotionDesc = /*@__PURE__*/ createMinimalMotionComponent("desc");
  const MotionEllipse = 
  /*@__PURE__*/ createMinimalMotionComponent("ellipse");
  const MotionG = /*@__PURE__*/ createMinimalMotionComponent("g");
  const MotionImage = /*@__PURE__*/ createMinimalMotionComponent("image");
  const MotionLine = /*@__PURE__*/ createMinimalMotionComponent("line");
  const MotionFilter = /*@__PURE__*/ createMinimalMotionComponent("filter");
  const MotionMarker = /*@__PURE__*/ createMinimalMotionComponent("marker");
  const MotionMask = /*@__PURE__*/ createMinimalMotionComponent("mask");
  const MotionMetadata = 
  /*@__PURE__*/ createMinimalMotionComponent("metadata");
  const MotionPath = /*@__PURE__*/ createMinimalMotionComponent("path");
  const MotionPattern = 
  /*@__PURE__*/ createMinimalMotionComponent("pattern");
  const MotionPolygon = 
  /*@__PURE__*/ createMinimalMotionComponent("polygon");
  const MotionPolyline = 
  /*@__PURE__*/ createMinimalMotionComponent("polyline");
  const MotionRect = /*@__PURE__*/ createMinimalMotionComponent("rect");
  const MotionStop = /*@__PURE__*/ createMinimalMotionComponent("stop");
  const MotionSvg = /*@__PURE__*/ createMinimalMotionComponent("svg");
  const MotionSymbol = /*@__PURE__*/ createMinimalMotionComponent("symbol");
  const MotionText = /*@__PURE__*/ createMinimalMotionComponent("text");
  const MotionTspan = /*@__PURE__*/ createMinimalMotionComponent("tspan");
  const MotionUse = /*@__PURE__*/ createMinimalMotionComponent("use");
  const MotionView = /*@__PURE__*/ createMinimalMotionComponent("view");
  const MotionClipPath = 
  /*@__PURE__*/ createMinimalMotionComponent("clipPath");
  const MotionFeBlend = 
  /*@__PURE__*/ createMinimalMotionComponent("feBlend");
  const MotionFeColorMatrix = 
  /*@__PURE__*/ createMinimalMotionComponent("feColorMatrix");
  const MotionFeComponentTransfer = 
  /*@__PURE__*/ createMinimalMotionComponent("feComponentTransfer");
  const MotionFeComposite = 
  /*@__PURE__*/ createMinimalMotionComponent("feComposite");
  const MotionFeConvolveMatrix = 
  /*@__PURE__*/ createMinimalMotionComponent("feConvolveMatrix");
  const MotionFeDiffuseLighting = 
  /*@__PURE__*/ createMinimalMotionComponent("feDiffuseLighting");
  const MotionFeDisplacementMap = 
  /*@__PURE__*/ createMinimalMotionComponent("feDisplacementMap");
  const MotionFeDistantLight = 
  /*@__PURE__*/ createMinimalMotionComponent("feDistantLight");
  const MotionFeDropShadow = 
  /*@__PURE__*/ createMinimalMotionComponent("feDropShadow");
  const MotionFeFlood = 
  /*@__PURE__*/ createMinimalMotionComponent("feFlood");
  const MotionFeFuncA = 
  /*@__PURE__*/ createMinimalMotionComponent("feFuncA");
  const MotionFeFuncB = 
  /*@__PURE__*/ createMinimalMotionComponent("feFuncB");
  const MotionFeFuncG = 
  /*@__PURE__*/ createMinimalMotionComponent("feFuncG");
  const MotionFeFuncR = 
  /*@__PURE__*/ createMinimalMotionComponent("feFuncR");
  const MotionFeGaussianBlur = 
  /*@__PURE__*/ createMinimalMotionComponent("feGaussianBlur");
  const MotionFeImage = 
  /*@__PURE__*/ createMinimalMotionComponent("feImage");
  const MotionFeMerge = 
  /*@__PURE__*/ createMinimalMotionComponent("feMerge");
  const MotionFeMergeNode = 
  /*@__PURE__*/ createMinimalMotionComponent("feMergeNode");
  const MotionFeMorphology = 
  /*@__PURE__*/ createMinimalMotionComponent("feMorphology");
  const MotionFeOffset = 
  /*@__PURE__*/ createMinimalMotionComponent("feOffset");
  const MotionFePointLight = 
  /*@__PURE__*/ createMinimalMotionComponent("fePointLight");
  const MotionFeSpecularLighting = 
  /*@__PURE__*/ createMinimalMotionComponent("feSpecularLighting");
  const MotionFeSpotLight = 
  /*@__PURE__*/ createMinimalMotionComponent("feSpotLight");
  const MotionFeTile = /*@__PURE__*/ createMinimalMotionComponent("feTile");
  const MotionFeTurbulence = 
  /*@__PURE__*/ createMinimalMotionComponent("feTurbulence");
  const MotionForeignObject = 
  /*@__PURE__*/ createMinimalMotionComponent("foreignObject");
  const MotionLinearGradient = 
  /*@__PURE__*/ createMinimalMotionComponent("linearGradient");
  const MotionRadialGradient = 
  /*@__PURE__*/ createMinimalMotionComponent("radialGradient");
  const MotionTextPath = 
  /*@__PURE__*/ createMinimalMotionComponent("textPath");
  
  exports.a = MotionA;
  exports.abbr = MotionAbbr;
  exports.address = MotionAddress;
  exports.animate = MotionAnimate;
  exports.area = MotionArea;
  exports.article = MotionArticle;
  exports.aside = MotionAside;
  exports.audio = MotionAudio;
  exports.b = MotionB;
  exports.base = MotionBase;
  exports.bdi = MotionBdi;
  exports.bdo = MotionBdo;
  exports.big = MotionBig;
  exports.blockquote = MotionBlockquote;
  exports.body = MotionBody;
  exports.button = MotionButton;
  exports.canvas = MotionCanvas;
  exports.caption = MotionCaption;
  exports.circle = MotionCircle;
  exports.cite = MotionCite;
  exports.clipPath = MotionClipPath;
  exports.code = MotionCode;
  exports.col = MotionCol;
  exports.colgroup = MotionColgroup;
  exports.create = createMinimalMotionComponent;
  exports.data = MotionData;
  exports.datalist = MotionDatalist;
  exports.dd = MotionDd;
  exports.defs = MotionDefs;
  exports.del = MotionDel;
  exports.desc = MotionDesc;
  exports.details = MotionDetails;
  exports.dfn = MotionDfn;
  exports.dialog = MotionDialog;
  exports.div = MotionDiv;
  exports.dl = MotionDl;
  exports.dt = MotionDt;
  exports.ellipse = MotionEllipse;
  exports.em = MotionEm;
  exports.embed = MotionEmbed;
  exports.feBlend = MotionFeBlend;
  exports.feColorMatrix = MotionFeColorMatrix;
  exports.feComponentTransfer = MotionFeComponentTransfer;
  exports.feComposite = MotionFeComposite;
  exports.feConvolveMatrix = MotionFeConvolveMatrix;
  exports.feDiffuseLighting = MotionFeDiffuseLighting;
  exports.feDisplacementMap = MotionFeDisplacementMap;
  exports.feDistantLight = MotionFeDistantLight;
  exports.feDropShadow = MotionFeDropShadow;
  exports.feFlood = MotionFeFlood;
  exports.feFuncA = MotionFeFuncA;
  exports.feFuncB = MotionFeFuncB;
  exports.feFuncG = MotionFeFuncG;
  exports.feFuncR = MotionFeFuncR;
  exports.feGaussianBlur = MotionFeGaussianBlur;
  exports.feImage = MotionFeImage;
  exports.feMerge = MotionFeMerge;
  exports.feMergeNode = MotionFeMergeNode;
  exports.feMorphology = MotionFeMorphology;
  exports.feOffset = MotionFeOffset;
  exports.fePointLight = MotionFePointLight;
  exports.feSpecularLighting = MotionFeSpecularLighting;
  exports.feSpotLight = MotionFeSpotLight;
  exports.feTile = MotionFeTile;
  exports.feTurbulence = MotionFeTurbulence;
  exports.fieldset = MotionFieldset;
  exports.figcaption = MotionFigcaption;
  exports.figure = MotionFigure;
  exports.filter = MotionFilter;
  exports.footer = MotionFooter;
  exports.foreignObject = MotionForeignObject;
  exports.form = MotionForm;
  exports.g = MotionG;
  exports.h1 = MotionH1;
  exports.h2 = MotionH2;
  exports.h3 = MotionH3;
  exports.h4 = MotionH4;
  exports.h5 = MotionH5;
  exports.h6 = MotionH6;
  exports.head = MotionHead;
  exports.header = MotionHeader;
  exports.hgroup = MotionHgroup;
  exports.hr = MotionHr;
  exports.html = MotionHtml;
  exports.i = MotionI;
  exports.iframe = MotionIframe;
  exports.image = MotionImage;
  exports.img = MotionImg;
  exports.input = MotionInput;
  exports.ins = MotionIns;
  exports.kbd = MotionKbd;
  exports.keygen = MotionKeygen;
  exports.label = MotionLabel;
  exports.legend = MotionLegend;
  exports.li = MotionLi;
  exports.line = MotionLine;
  exports.linearGradient = MotionLinearGradient;
  exports.link = MotionLink;
  exports.main = MotionMain;
  exports.map = MotionMap;
  exports.mark = MotionMark;
  exports.marker = MotionMarker;
  exports.mask = MotionMask;
  exports.menu = MotionMenu;
  exports.menuitem = MotionMenuitem;
  exports.metadata = MotionMetadata;
  exports.meter = MotionMeter;
  exports.nav = MotionNav;
  exports.object = MotionObject;
  exports.ol = MotionOl;
  exports.optgroup = MotionOptgroup;
  exports.option = MotionOption;
  exports.output = MotionOutput;
  exports.p = MotionP;
  exports.param = MotionParam;
  exports.path = MotionPath;
  exports.pattern = MotionPattern;
  exports.picture = MotionPicture;
  exports.polygon = MotionPolygon;
  exports.polyline = MotionPolyline;
  exports.pre = MotionPre;
  exports.progress = MotionProgress;
  exports.q = MotionQ;
  exports.radialGradient = MotionRadialGradient;
  exports.rect = MotionRect;
  exports.rp = MotionRp;
  exports.rt = MotionRt;
  exports.ruby = MotionRuby;
  exports.s = MotionS;
  exports.samp = MotionSamp;
  exports.script = MotionScript;
  exports.section = MotionSection;
  exports.select = MotionSelect;
  exports.small = MotionSmall;
  exports.source = MotionSource;
  exports.span = MotionSpan;
  exports.stop = MotionStop;
  exports.strong = MotionStrong;
  exports.style = MotionStyle;
  exports.sub = MotionSub;
  exports.summary = MotionSummary;
  exports.sup = MotionSup;
  exports.svg = MotionSvg;
  exports.symbol = MotionSymbol;
  exports.table = MotionTable;
  exports.tbody = MotionTbody;
  exports.td = MotionTd;
  exports.text = MotionText;
  exports.textPath = MotionTextPath;
  exports.textarea = MotionTextarea;
  exports.tfoot = MotionTfoot;
  exports.th = MotionTh;
  exports.thead = MotionThead;
  exports.time = MotionTime;
  exports.title = MotionTitle;
  exports.tr = MotionTr;
  exports.track = MotionTrack;
  exports.tspan = MotionTspan;
  exports.u = MotionU;
  exports.ul = MotionUl;
  exports.use = MotionUse;
  exports.video = MotionVideo;
  exports.view = MotionView;
  exports.wbr = MotionWbr;
  exports.webview = MotionWebview;
  //# sourceMappingURL=m.js.map