{"version":3,"file":"index.d.ts","sources":["../src/utilities/index.ts","../src/constants.ts","../src/flip/animateUnflippedElements/index.ts","../src/springSettings/index.ts","../src/forked-rebound/onFrame.js","../src/forked-rebound/util.js","../src/forked-rebound/Loopers.js","../src/forked-rebound/Spring.js","../src/forked-rebound/SpringSystem.js","../src/flip/animateFlippedElements/spring/index.ts","../src/flip/animateFlippedElements/index.ts","../src/flip/getFlippedElementPositions/utilities.ts","../src/flip/index.ts","../src/flip/getFlippedElementPositions/getFlippedElementPositionsAfterUpdate/index.ts","../src/flip/getFlippedElementPositions/getFlippedElementPositionsBeforeUpdate/index.ts","../src/Flipper.ts","../src/Spring/index.ts"],"sourcesContent":["import { IndexableObject } from './types'\n\nexport const isNumber = (x: any) => typeof x === 'number'\n\nexport const isFunction = (x: any) => typeof x === 'function'\n\nexport const isObject = (x: any) =>\n  Object.prototype.toString.call(x) === '[object Object]'\n\nexport const toArray = (arrayLike: ArrayLike<any>) =>\n  Array.prototype.slice.apply(arrayLike)\n\nexport const getDuplicateValsAsStrings = (arr: string[]): string[] => {\n  const baseObj: IndexableObject = {}\n  const obj = arr.reduce((acc, curr) => {\n    acc[curr] = (acc[curr] || 0) + 1\n    return acc\n  }, baseObj)\n  return Object.keys(obj).filter(val => obj[val] > 1)\n}\n\n// tslint only likes this with a regular function, not an arrow function\nexport function assign(target: IndexableObject, ...args: IndexableObject[]) {\n  args.forEach(arg => {\n    if (!arg) {\n      return\n    }\n    // Skip over if undefined or null\n    for (const nextKey in arg) {\n      // Avoid bugs when hasOwnProperty is shadowed\n      if (Object.prototype.hasOwnProperty.call(arg, nextKey)) {\n        target[nextKey] = arg[nextKey]\n      }\n    }\n  })\n  return target\n}\n\nexport const tweenProp = (start: number, end: number, position: number) =>\n  start + (end - start) * position\n","export const DATA_FLIP_ID = 'data-flip-id'\nexport const DATA_INVERSE_FLIP_ID = 'data-inverse-flip-id'\nexport const DATA_FLIP_COMPONENT_ID = 'data-flip-component-id'\nexport const DATA_FLIP_CONFIG = 'data-flip-config'\nexport const DATA_PORTAL_KEY = 'data-portal-key'\nexport const DATA_EXIT_CONTAINER = 'data-exit-container'\n","import { AnimateUnflippedElementsArgs, FragmentTuple } from './types'\n\nconst animateUnflippedElements = ({\n  unflippedIds,\n  flipCallbacks,\n  getElement,\n  flippedElementPositionsBeforeUpdate,\n  flippedElementPositionsAfterUpdate,\n  inProgressAnimations,\n  decisionData\n}: AnimateUnflippedElementsArgs) => {\n  const enteringElementIds = unflippedIds.filter(\n    id => flippedElementPositionsAfterUpdate[id]\n  )\n  const animatedEnteringElementIds = enteringElementIds.filter(\n    id => flipCallbacks[id] && flipCallbacks[id].onAppear\n  )\n\n  const animatedExitingElementIds = unflippedIds.filter(\n    id =>\n      flippedElementPositionsBeforeUpdate[id] &&\n      flipCallbacks[id] &&\n      flipCallbacks[id].onExit\n  )\n\n  const hideEnteringElements = () => {\n    animatedEnteringElementIds.forEach(id => {\n      const element = getElement(id)\n      if (element) {\n        element.style.opacity = '0'\n      }\n    })\n  }\n\n  const animateEnteringElements = () => {\n    animatedEnteringElementIds.forEach((id, i) => {\n      const element = getElement(id)\n      if (element) {\n        flipCallbacks[id].onAppear!(element, i, decisionData)\n      }\n    })\n  }\n\n  let closureResolve: () => void\n\n  const promiseToReturn: Promise<void> = new Promise(resolve => {\n    closureResolve = resolve\n  })\n\n  const fragmentTuples: FragmentTuple[] = []\n  let exitingElementCount = 0\n\n  const onExitCallbacks = animatedExitingElementIds.map((id, i) => {\n    const {\n      domDataForExitAnimations: {\n        element,\n        parent,\n        childPosition: { top, left, width, height }\n      }\n    } = flippedElementPositionsBeforeUpdate[id]\n    // insert back into dom\n    if (getComputedStyle(parent).position === 'static') {\n      parent.style.position = 'relative'\n    }\n    element.style.transform = 'matrix(1, 0, 0, 1, 0, 0)'\n    element.style.position = 'absolute'\n    element.style.top = top + 'px'\n    element.style.left = left + 'px'\n    // taken out of the dom flow, the element might have lost these dimensions\n    element.style.height = height + 'px'\n    element.style.width = width + 'px'\n    let fragmentTuple: FragmentTuple | undefined = fragmentTuples.filter(\n      t => t[0] === parent\n    )[0]\n    if (!fragmentTuple) {\n      fragmentTuple = [parent, document.createDocumentFragment()]\n      fragmentTuples.push(fragmentTuple)\n    }\n    fragmentTuple[1].appendChild(element)\n\n    exitingElementCount += 1\n\n    const stop = () => {\n      try {\n        parent.removeChild(element)\n      } catch (DOMException) {\n        // the element is already gone\n      } finally {\n        exitingElementCount -= 1\n        if (exitingElementCount === 0) {\n          closureResolve()\n        }\n      }\n    }\n    // @ts-ignore\n    inProgressAnimations[id] = { stop }\n    return () => flipCallbacks[id].onExit!(element, i, stop, decisionData)\n  })\n\n  // now append all the fragments from the onExit callbacks\n  // (we use fragments for performance)\n  fragmentTuples.forEach(t => {\n    t[0].appendChild(t[1])\n  })\n\n  if (!onExitCallbacks.length) {\n    closureResolve!()\n  }\n\n  const animateExitingElements = () => {\n    onExitCallbacks.forEach(c => c())\n    return promiseToReturn\n  }\n\n  return {\n    hideEnteringElements,\n    animateEnteringElements,\n    animateExitingElements\n  }\n}\n\nexport default animateUnflippedElements\n","import { isObject, assign } from '../utilities'\nimport { SpringPresets, SpringConfig, SpringOption } from './types'\n\n// adapted from\n// https://github.com/chenglou/react-motion/blob/master/src/presets.js\nexport const springPresets: SpringPresets = {\n  noWobble: { stiffness: 200, damping: 26 },\n  gentle: { stiffness: 120, damping: 14 },\n  veryGentle: { stiffness: 130, damping: 17 },\n  wobbly: { stiffness: 180, damping: 12 },\n  stiff: { stiffness: 260, damping: 26 }\n}\n\nfunction argIsSpringConfig(\n  arg: SpringConfig | keyof SpringPresets | undefined\n): arg is SpringConfig {\n  return isObject(arg)\n}\n\nexport const normalizeSpring = (\n  spring?: SpringConfig | keyof SpringPresets | any\n) => {\n  if (argIsSpringConfig(spring)) {\n    return spring\n  } else if (Object.keys(springPresets).indexOf(spring) > -1) {\n    return springPresets[spring]\n  } else {\n    return {}\n  }\n}\n\nexport const getSpringConfig = ({\n  flipperSpring,\n  flippedSpring\n}: { flipperSpring?: SpringOption; flippedSpring?: SpringOption } = {}) => {\n  return assign(\n    {},\n    springPresets.noWobble,\n    normalizeSpring(flipperSpring),\n    normalizeSpring(flippedSpring)\n  )\n}\n","/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n *\n *\n */\n\nlet _onFrame\nif (typeof window !== \"undefined\") {\n  _onFrame = window.requestAnimationFrame\n}\n\n_onFrame =\n  _onFrame ||\n  function(callback) {\n    window.setTimeout(callback, 1000 / 60)\n  }\n\nexport default _onFrame\n","/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n *\n *\n */\n\nexport { default as onFrame } from './onFrame'\n\nconst start = Date.now()\nexport const performanceNow =\n  typeof performance === 'object' && typeof performance.now === 'function'\n    ? () => performance.now()\n    : () => Date.now() - start\n\n// Lop off the first occurence of the reference in the Array.\nexport function removeFirst(array, item) {\n  const idx = array.indexOf(item)\n  idx !== -1 && array.splice(idx, 1)\n}\n","/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n *\n *\n */\n\nimport { onFrame, performanceNow } from \"./util\"\n\n/**\n * Plays each frame of the SpringSystem on animation\n * timing loop. This is the default type of looper for a new spring system\n * as it is the most common when developing UI.\n * @public\n */\nexport class AnimationLooper {\n  run() {\n    onFrame(() => {\n      this.springSystem.loop(performanceNow())\n    })\n  }\n}\n","/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n *\n *\n */\n\nimport { removeFirst } from './util'\n\nclass PhysicsState {\n  constructor() {\n    this.position = 0\n    this.velocity = 0\n  }\n}\n\nlet ID = 0\nconst MAX_DELTA_TIME_SEC = 0.064\nconst SOLVER_TIMESTEP_SEC = 0.001\n\n/**\n * Provides a model of a classical spring acting to\n * resolve a body to equilibrium. Springs have configurable\n * tension which is a force multipler on the displacement of the\n * spring from its rest point or `endValue` as defined by [Hooke's\n * law](http://en.wikipedia.org/wiki/Hooke's_law). Springs also have\n * configurable friction, which ensures that they do not oscillate\n * infinitely. When a Spring is displaced by updating it's resting\n * or `currentValue`, the SpringSystems that contain that Spring\n * will automatically start looping to solve for equilibrium. As each\n * timestep passes, `SpringListener` objects attached to the Spring\n * will be notified of the updates providing a way to drive an\n * animation off of the spring's resolution curve.\n * @public\n */\nclass Spring {\n  constructor(springSystem) {\n    this._id = `s${ID++}`\n    this._springSystem = springSystem\n\n    this.listeners = []\n    this._startValue = 0\n\n    this._currentState = new PhysicsState()\n    this._displacementFromRestThreshold = 0.001\n    this._endValue = 0\n    this._overshootClampingEnabled = false\n    this._previousState = new PhysicsState()\n    this._restSpeedThreshold = 0.001\n\n    this._tempState = new PhysicsState()\n    this._timeAccumulator = 0\n    this._wasAtRest = true\n    // hack from alex -- only call 1x\n    this._onActivateCalled\n    this._cachedSpringConfig = {}\n  }\n\n  getId() {\n    return this._id\n  }\n\n  /**\n   * Remove a Spring from simulation and clear its listeners.\n   * @public\n   */\n  destroy() {\n    this.listeners = []\n    this._springSystem.deregisterSpring(this)\n  }\n\n  /**\n   * Set the configuration values for this Spring. A SpringConfig\n   * contains the tension and friction values used to solve for the\n   * equilibrium of the Spring in the physics loop.\n   * @public\n   */\n  setSpringConfig(springConfig) {\n    this._springConfig = springConfig\n    return this\n  }\n  /**\n   * Retrieve the current value of the Spring.\n   * @public\n   */\n  getCurrentValue() {\n    return this._currentState.position\n  }\n\n  /**\n   * Get the absolute distance of the Spring from a given state value\n   */\n  getDisplacementDistanceForState(state) {\n    return Math.abs(this._endValue - state.position)\n  }\n\n  /**\n   * Set the endValue or resting position of the spring. If this\n   * value is different than the current value, the SpringSystem will\n   * be notified and will begin running its solver loop to resolve\n   * the Spring to equilibrium. Any listeners that are registered\n   * for onSpringEndStateChange will also be notified of this update\n   * immediately.\n   * @public\n   */\n\n  setEndValue(endValue) {\n    if (endValue === this._endValue) return this\n    this.prevEndValue = endValue\n    if (this._endValue === endValue && this.isAtRest()) {\n      return this\n    }\n    this._startValue = this.getCurrentValue()\n    this._endValue = endValue\n    this._springSystem.activateSpring(this.getId())\n    for (let i = 0, len = this.listeners.length; i < len; i++) {\n      const listener = this.listeners[i]\n      const onChange = listener.onSpringEndStateChange\n      onChange && onChange(this)\n    }\n    return this\n  }\n\n  /**\n   * Set the current velocity of the Spring, in pixels per second. As\n   * previously mentioned, this can be useful when you are performing\n   * a direct manipulation gesture. When a UI element is released you\n   * may call setVelocity on its animation Spring so that the Spring\n   * continues with the same velocity as the gesture ended with. The\n   * friction, tension, and displacement of the Spring will then\n   * govern its motion to return to rest on a natural feeling curve.\n   * @public\n   */\n  setVelocity(velocity) {\n    if (velocity === this._currentState.velocity) {\n      return this\n    }\n    this._currentState.velocity = velocity\n    this._springSystem.activateSpring(this.getId())\n    return this\n  }\n\n  setCurrentValue(currentValue) {\n    this._startValue = currentValue\n    this._currentState.position = currentValue\n    for (var i = 0, len = this.listeners.length; i < len; i++) {\n      var listener = this.listeners[i]\n      listener.onSpringUpdate && listener.onSpringUpdate(this)\n    }\n    return this\n  }\n\n  setAtRest() {\n    this._endValue = this._currentState.position\n    this._tempState.position = this._currentState.position\n    this._currentState.velocity = 0\n    return this\n  }\n\n  /**\n   * Enable overshoot clamping. This means that the Spring will stop\n   * immediately when it reaches its resting position regardless of\n   * any existing momentum it may have. This can be useful for certain\n   * types of animations that should not oscillate such as a scale\n   * down to 0 or alpha fade.\n   * @public\n   */\n  setOvershootClampingEnabled(enabled) {\n    this._overshootClampingEnabled = enabled\n    return this\n  }\n\n  /**\n   * Check if the Spring has gone past its end point by comparing\n   * the direction it was moving in when it started to the current\n   * position and end value.\n   * @public\n   */\n  isOvershooting() {\n    const start = this._startValue\n    const end = this._endValue\n    return (\n      this._springConfig.tension > 0 &&\n      ((start < end && this.getCurrentValue() > end) ||\n        (start > end && this.getCurrentValue() < end))\n    )\n  }\n\n  /**\n   * The main solver method for the Spring. It takes\n   * the current time and delta since the last time step and performs\n   * an RK4 integration to get the new position and velocity state\n   * for the Spring based on the tension, friction, velocity, and\n   * displacement of the Spring.\n   * @public\n   */\n  advance(time, realDeltaTime) {\n    let isAtRest = this.isAtRest()\n\n    if (isAtRest && this._wasAtRest) {\n      return\n    }\n\n    let adjustedDeltaTime = realDeltaTime\n    if (realDeltaTime > MAX_DELTA_TIME_SEC) {\n      adjustedDeltaTime = MAX_DELTA_TIME_SEC\n    }\n\n    this._timeAccumulator += adjustedDeltaTime\n\n    const tension = this._springConfig.tension\n    const friction = this._springConfig.friction\n    let position = this._currentState.position\n    let velocity = this._currentState.velocity\n    let tempPosition = this._tempState.position\n    let tempVelocity = this._tempState.velocity\n    let aVelocity\n    let aAcceleration\n    let bVelocity\n    let bAcceleration\n    let cVelocity\n    let cAcceleration\n    let dVelocity\n    let dAcceleration\n    let dxdt\n    let dvdt\n\n    while (this._timeAccumulator >= SOLVER_TIMESTEP_SEC) {\n      this._timeAccumulator -= SOLVER_TIMESTEP_SEC\n\n      if (this._timeAccumulator < SOLVER_TIMESTEP_SEC) {\n        this._previousState.position = position\n        this._previousState.velocity = velocity\n      }\n\n      aVelocity = velocity\n      aAcceleration =\n        tension * (this._endValue - tempPosition) - friction * velocity\n\n      tempPosition = position + aVelocity * SOLVER_TIMESTEP_SEC * 0.5\n      tempVelocity = velocity + aAcceleration * SOLVER_TIMESTEP_SEC * 0.5\n      bVelocity = tempVelocity\n      bAcceleration =\n        tension * (this._endValue - tempPosition) - friction * tempVelocity\n\n      tempPosition = position + bVelocity * SOLVER_TIMESTEP_SEC * 0.5\n      tempVelocity = velocity + bAcceleration * SOLVER_TIMESTEP_SEC * 0.5\n      cVelocity = tempVelocity\n      cAcceleration =\n        tension * (this._endValue - tempPosition) - friction * tempVelocity\n\n      tempPosition = position + cVelocity * SOLVER_TIMESTEP_SEC\n      tempVelocity = velocity + cAcceleration * SOLVER_TIMESTEP_SEC\n      dVelocity = tempVelocity\n      dAcceleration =\n        tension * (this._endValue - tempPosition) - friction * tempVelocity\n\n      dxdt =\n        (1.0 / 6.0) * (aVelocity + 2.0 * (bVelocity + cVelocity) + dVelocity)\n      dvdt =\n        (1.0 / 6.0) *\n        (aAcceleration + 2.0 * (bAcceleration + cAcceleration) + dAcceleration)\n\n      position += dxdt * SOLVER_TIMESTEP_SEC\n      velocity += dvdt * SOLVER_TIMESTEP_SEC\n    }\n\n    this._tempState.position = tempPosition\n    this._tempState.velocity = tempVelocity\n\n    this._currentState.position = position\n    this._currentState.velocity = velocity\n\n    if (this._timeAccumulator > 0) {\n      this._interpolate(this._timeAccumulator / SOLVER_TIMESTEP_SEC)\n    }\n\n    if (\n      this.isAtRest() ||\n      (this._overshootClampingEnabled && this.isOvershooting())\n    ) {\n      if (this._springConfig.tension > 0) {\n        this._startValue = this._endValue\n        this._currentState.position = this._endValue\n      } else {\n        this._endValue = this._currentState.position\n        this._startValue = this._endValue\n      }\n      this.setVelocity(0)\n      isAtRest = true\n    }\n\n    let notifyActivate = false\n    if (this._wasAtRest) {\n      this._wasAtRest = false\n      notifyActivate = true\n    }\n\n    let notifyAtRest = false\n    if (isAtRest) {\n      this._wasAtRest = true\n      notifyAtRest = true\n    }\n\n    this.notifyPositionUpdated(notifyActivate, notifyAtRest)\n  }\n\n  notifyPositionUpdated(notifyActivate, notifyAtRest) {\n    this.listeners.filter(Boolean).forEach(listener => {\n      if (\n        notifyActivate &&\n        listener.onSpringActivate &&\n        !this._onActivateCalled\n      ) {\n        listener.onSpringActivate(this)\n        this._onActivateCalled = true\n      }\n\n      if (listener.onSpringUpdate) {\n        listener.onSpringUpdate(this)\n      }\n\n      if (notifyAtRest && listener.onSpringAtRest) {\n        listener.onSpringAtRest(this)\n      }\n    })\n  }\n\n  /**\n   * Check if the SpringSystem should advance. Springs are advanced\n   * a final frame after they reach equilibrium to ensure that the\n   * currentValue is exactly the requested endValue regardless of the\n   * displacement threshold.\n   * @public\n   */\n  systemShouldAdvance() {\n    return !this.isAtRest() || !this.wasAtRest()\n  }\n\n  wasAtRest() {\n    return this._wasAtRest\n  }\n\n  /**\n   * Check if the Spring is atRest meaning that it's currentValue and\n   * endValue are the same and that it has no velocity. The previously\n   * described thresholds for speed and displacement define the bounds\n   * of this equivalence check. If the Spring has 0 tension, then it will\n   * be considered at rest whenever its absolute velocity drops below the\n   * restSpeedThreshold.\n   * @public\n   */\n  isAtRest() {\n    const isAtRest =\n      Math.abs(this._currentState.velocity) < this._restSpeedThreshold &&\n      (this.getDisplacementDistanceForState(this._currentState) <=\n        this._displacementFromRestThreshold ||\n        this._springConfig.tension === 0)\n    return isAtRest\n  }\n\n  _interpolate(alpha) {\n    this._currentState.position =\n      this._currentState.position * alpha +\n      this._previousState.position * (1 - alpha)\n    this._currentState.velocity =\n      this._currentState.velocity * alpha +\n      this._previousState.velocity * (1 - alpha)\n  }\n\n  addListener(newListener) {\n    this.listeners.push(newListener)\n    return this\n  }\n\n  addOneTimeListener(newListener) {\n    const oneTimeFunc = func => (...args) => {\n      func(...args)\n      this.removeListener(newListener)\n    }\n    Object.keys(newListener).forEach(key => {\n      newListener[key] = oneTimeFunc(newListener[key])\n    })\n    this.listeners.push(newListener)\n    return this\n  }\n\n  removeListener(listenerToRemove) {\n    removeFirst(this.listeners, listenerToRemove)\n    return this\n  }\n}\n\nexport default Spring\n","//\n/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n *\n */\n\nimport { AnimationLooper } from './Loopers'\nimport Spring from './Spring'\nimport { removeFirst } from './util'\n\n/**\n * A set of Springs that all run on the same physics\n * timing loop. To get started with a Rebound animation, first\n * create a new SpringSystem and then add springs to it.\n * @public\n */\nclass SpringSystem {\n  constructor(looper) {\n    this.looper = looper || new AnimationLooper()\n    this.looper.springSystem = this\n\n    this.listeners = []\n    this._activeSprings = []\n    this._idleSpringIndices = []\n    this._isIdle = true\n    this._lastTimeMillis = -1\n    this._springRegistry = {}\n  }\n\n  /**\n   * Add a new spring to this SpringSystem. This Spring will now be solved for\n   * during the physics iteration loop. By default the spring will use the\n   * default Origami spring config with 40 tension and 7 friction, but you can\n   * also provide your own values here.\n   * @public\n   */\n  createSpring(tension, friction) {\n    return this.createSpringWithConfig({ tension, friction })\n  }\n  /**\n   * Add a spring with the provided SpringConfig.\n   * @public\n   */\n  createSpringWithConfig(springConfig) {\n    const spring = new Spring(this)\n    this.registerSpring(spring)\n    spring.setSpringConfig(springConfig)\n    return spring\n  }\n\n  /**\n   * Check if a SpringSystem is idle or active. If all of the Springs in the\n   * SpringSystem are at rest, i.e. the physics forces have reached equilibrium,\n   * then this method will return true.\n   * @public\n   */\n  getIsIdle() {\n    return this._isIdle\n  }\n\n  /**\n   * Manually add a spring to this system. This is called automatically\n   * if a Spring is created with SpringSystem#createSpring.\n   *\n   * This method sets the spring up in the registry so that it can be solved\n   * in the solver loop.\n   * @public\n   */\n  registerSpring(spring) {\n    this._springRegistry[spring.getId()] = spring\n  }\n\n  /**\n   * Deregister a spring with this SpringSystem. The SpringSystem will\n   * no longer consider this Spring during its integration loop once\n   * this is called. This is normally done automatically for you when\n   * you call Spring#destroy.\n   * @public\n   */\n  deregisterSpring(spring) {\n    removeFirst(this._activeSprings, spring)\n    delete this._springRegistry[spring.getId()]\n  }\n\n  advance(time, deltaTime) {\n    while (this._idleSpringIndices.length > 0) {\n      this._idleSpringIndices.pop()\n    }\n    this._activeSprings.filter(Boolean).forEach(spring => {\n      if (spring.systemShouldAdvance()) {\n        spring.advance(time / 1000.0, deltaTime / 1000.0)\n      } else {\n        this._idleSpringIndices.push(this._activeSprings.indexOf(spring))\n      }\n    })\n\n    while (this._idleSpringIndices.length > 0) {\n      const idx = this._idleSpringIndices.pop()\n      idx >= 0 && this._activeSprings.splice(idx, 1)\n    }\n  }\n\n  /**\n   * This is the main solver loop called to move the simulation\n   * forward through time. Before each pass in the solver loop\n   * onBeforeIntegrate is called on an any listeners that have\n   * registered themeselves with the SpringSystem. This gives you\n   * an opportunity to apply any constraints or adjustments to\n   * the springs that should be enforced before each iteration\n   * loop. Next the advance method is called to move each Spring in\n   * the systemShouldAdvance forward to the current time. After the\n   * integration step runs in advance, onAfterIntegrate is called\n   * on any listeners that have registered themselves with the\n   * SpringSystem. This gives you an opportunity to run any post\n   * integration constraints or adjustments on the Springs in the\n   * SpringSystem.\n   * @public\n   */\n  loop(currentTimeMillis) {\n    let listener\n    if (this._lastTimeMillis === -1) {\n      this._lastTimeMillis = currentTimeMillis - 1\n    }\n    const ellapsedMillis = currentTimeMillis - this._lastTimeMillis\n    this._lastTimeMillis = currentTimeMillis\n\n    let i = 0\n    const len = this.listeners.length\n    for (i = 0; i < len; i++) {\n      listener = this.listeners[i]\n      listener.onBeforeIntegrate && listener.onBeforeIntegrate(this)\n    }\n\n    this.advance(currentTimeMillis, ellapsedMillis)\n    if (this._activeSprings.length === 0) {\n      this._isIdle = true\n      this._lastTimeMillis = -1\n    }\n\n    for (i = 0; i < len; i++) {\n      listener = this.listeners[i]\n      listener.onAfterIntegrate && listener.onAfterIntegrate(this)\n    }\n\n    if (!this._isIdle) {\n      this.looper.run()\n    }\n  }\n\n  /**\n   * Used to notify the SpringSystem that a Spring has become displaced.\n   * The system responds by starting its solver loop up if it is currently idle.\n   */\n  activateSpring(springId) {\n    const spring = this._springRegistry[springId]\n    if (this._activeSprings.indexOf(spring) === -1) {\n      this._activeSprings.push(spring)\n    }\n    if (this.getIsIdle()) {\n      this._isIdle = false\n      this.looper.run()\n    }\n  }\n}\n\nexport default SpringSystem\n","import { SpringSystem } from '../../../forked-rebound'\nimport { StaggerConfigValue } from '../../../types'\nimport { FlipData, FlipDataArray } from '../types'\nimport {\n  SpringSystemInterface,\n  AddListenerArgs\n} from '../../../forked-rebound/types'\n\n// this should get created only 1x\nconst springSystem: SpringSystemInterface = new SpringSystem()\n\nexport const createSuspendedSpring = (flipData: FlipData) => {\n  const {\n    springConfig: { stiffness, damping, overshootClamping },\n    getOnUpdateFunc,\n    onAnimationEnd,\n    onSpringActivate\n  } = flipData\n\n  const spring = springSystem.createSpring(stiffness!, damping!)\n  spring.setOvershootClampingEnabled(!!overshootClamping)\n  const onSpringAtRest = () => {\n    // prevent SpringSystem from caching unused springs\n    spring.destroy()\n    onAnimationEnd()\n  }\n\n  const springConfig: AddListenerArgs = {\n    onSpringActivate,\n    onSpringAtRest,\n    onSpringUpdate: getOnUpdateFunc({\n      spring,\n      onAnimationEnd\n    })\n  }\n\n  spring.addListener(springConfig)\n  return spring\n}\n\nexport const createSpring = (flipped: FlipData) => {\n  const spring = createSuspendedSpring(flipped)\n  spring.setEndValue(1)\n  return spring\n}\n\nexport const normalizeSpeed = (speedConfig: number | undefined) => {\n  if (typeof speedConfig !== 'number') return 1.1\n  return 1 + Math.min(Math.max(speedConfig * 5, 0), 5)\n}\n\nexport const createStaggeredSprings = (\n  flippedArray: FlipDataArray,\n  staggerConfig: StaggerConfigValue = {}\n) => {\n  if (!flippedArray || !flippedArray.length) {\n    return\n  }\n\n  if (staggerConfig.reverse) {\n    flippedArray.reverse()\n  }\n\n  const normalizedSpeed = normalizeSpeed(staggerConfig.speed)\n\n  const nextThreshold = 1 / Math.max(Math.min(flippedArray.length, 100), 10)\n\n  const setEndValueFuncs = flippedArray\n    .map((flipped, i) => {\n      const cachedGetOnUpdate = flipped.getOnUpdateFunc\n\n      // modify the update function to adjust\n      // the end value of the trailing Flipped component\n      flipped.getOnUpdateFunc = args => {\n        const onUpdate = cachedGetOnUpdate(args)\n        return spring => {\n          let currentValue = spring.getCurrentValue()\n          // make sure trailing animations complete\n          currentValue =\n            currentValue < 0.01 ? 0 : currentValue > 0.99 ? 1 : currentValue\n\n          const updateTrailingAnimation = currentValue >= nextThreshold\n          if (updateTrailingAnimation) {\n            if (setEndValueFuncs[i + 1]) {\n              setEndValueFuncs[i + 1]!(\n                Math.max(Math.min(currentValue * normalizedSpeed, 1), 0)\n              )\n            }\n          }\n          // now call the actual update function\n          onUpdate(spring)\n        }\n      }\n      return flipped\n    })\n    .map(flipped => {\n      const spring = createSuspendedSpring(flipped)\n      if (!spring) {\n        return\n      }\n      return spring.setEndValue.bind(spring)\n    })\n    .filter(Boolean)\n\n  if (setEndValueFuncs[0]) {\n    setEndValueFuncs[0]!(1)\n  }\n}\n","import * as Rematrix from 'rematrix'\nimport { getSpringConfig } from '../../springSettings'\nimport {\n  toArray,\n  isFunction,\n  isNumber,\n  getDuplicateValsAsStrings,\n  assign,\n  tweenProp\n} from '../../utilities'\nimport * as constants from '../../constants'\nimport {\n  GetOnUpdateFunc,\n  OnUpdate,\n  Matrix,\n  InvertedChildren,\n  AnimateFlippedElementsArgs,\n  AnimatedVals,\n  FlipDataArray,\n  FlipData,\n  InitializeFlip\n} from './types'\nimport { BoundingClientRect } from '../getFlippedElementPositions/types'\nimport { FlippedIds } from '../types'\nimport { createSpring, createStaggeredSprings } from './spring'\nimport { IndexableObject } from '../../utilities/types'\nimport { FlipId } from '../../types'\n\n// 3d transforms were causing weird issues in chrome,\n// especially when opacity was also being tweened,\n// so convert to a 2d matrix\nexport const convertMatrix3dArrayTo2dArray = (matrix: Matrix): Matrix =>\n  [0, 1, 4, 5, 12, 13].map(index => matrix[index])\n\nexport const convertMatrix2dArrayToString = (matrix: Matrix) =>\n  `matrix(${matrix.join(', ')})`\n\nexport const invertTransformsForChildren = ({\n  invertedChildren,\n  matrix,\n  body\n}: {\n  matrix: Matrix\n  body: HTMLBodyElement\n  invertedChildren: InvertedChildren\n}) => {\n  invertedChildren.forEach(([child, childFlipConfig]) => {\n    if (!body.contains(child)) {\n      return\n    }\n    const scaleX = matrix[0]\n    const scaleY = matrix[3]\n    const translateX = matrix[4]\n    const translateY = matrix[5]\n\n    const inverseVals = { translateX: 0, translateY: 0, scaleX: 1, scaleY: 1 }\n    let transformString = ''\n    if (childFlipConfig.translate) {\n      inverseVals.translateX = -translateX / scaleX\n      inverseVals.translateY = -translateY / scaleY\n      transformString += `translate(${inverseVals.translateX}px, ${inverseVals.translateY}px)`\n    }\n    if (childFlipConfig.scale) {\n      inverseVals.scaleX = 1 / scaleX\n      inverseVals.scaleY = 1 / scaleY\n      transformString += ` scale(${inverseVals.scaleX}, ${inverseVals.scaleY})`\n    }\n    child.style.transform = transformString\n  })\n}\n\nexport const createApplyStylesFunc =\n  ({\n    element,\n    invertedChildren,\n    body\n  }: {\n    element: HTMLElement\n    invertedChildren: InvertedChildren\n    body: HTMLBodyElement\n  }) =>\n  ({\n    matrix,\n    opacity,\n    forceMinVals\n  }: {\n    matrix: Matrix\n    opacity?: number\n    forceMinVals?: boolean\n  }) => {\n    if (isNumber(opacity)) {\n      element.style.opacity = opacity + ''\n    }\n\n    if (forceMinVals) {\n      element.style.minHeight = '1px'\n      element.style.minWidth = '1px'\n    }\n\n    if (!matrix) {\n      return\n    }\n\n    const stringTransform = convertMatrix2dArrayToString(matrix)\n\n    // always apply transform, even if identity,\n    // because identity might be the starting state in a FLIP\n    // transition, if the element's position is controlled by transforms\n    element.style.transform = stringTransform\n\n    if (invertedChildren) {\n      invertTransformsForChildren({\n        invertedChildren,\n        matrix,\n        body\n      })\n    }\n  }\n\nexport const rectInViewport = ({\n  top,\n  bottom,\n  left,\n  right\n}: BoundingClientRect) => {\n  return (\n    top < window.innerHeight &&\n    bottom > 0 &&\n    left < window.innerWidth &&\n    right > 0\n  )\n}\n\nconst getInvertedChildren = (element: HTMLElement, id: string) =>\n  toArray(\n    element.querySelectorAll(`[${constants.DATA_INVERSE_FLIP_ID}=\"${id}\"]`)\n  )\n\nfunction extractFlipConfig(element: HTMLElement) {\n  const flipConfig = JSON.parse(element.dataset.flipConfig || '{}')\n  return flipConfig\n}\n\nexport default ({\n  flippedIds,\n  flipCallbacks,\n  inProgressAnimations,\n  flippedElementPositionsBeforeUpdate,\n  flippedElementPositionsAfterUpdate,\n  applyTransformOrigin,\n  spring,\n  getElement,\n  debug,\n  staggerConfig = {},\n  decisionData = {},\n  onComplete,\n  containerEl\n}: AnimateFlippedElementsArgs) => {\n  // the stuff below is used so we can return a promise that resolves when all FLIP animations have\n  // completed\n  let closureResolve: (flipIds: FlippedIds) => void\n\n  const flipCompletedPromise: Promise<FlippedIds> = new Promise(resolve => {\n    closureResolve = resolve\n  })\n  // hook for users of lib to attach logic when all flip animations have completed\n  if (onComplete) {\n    flipCompletedPromise.then(() => onComplete(containerEl, decisionData))\n  }\n  if (!flippedIds.length) {\n    return () => {\n      closureResolve!([])\n      return flipCompletedPromise\n    }\n  }\n\n  const completedAnimationIds: FlippedIds = []\n\n  const firstElement: HTMLElement = getElement(flippedIds[0])\n  // special handling for iframes\n  const body = firstElement\n    ? firstElement.ownerDocument!.querySelector('body')!\n    : document.querySelector('body')!\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (debug) {\n      // eslint-disable-next-line no-console\n      console.error(\n        '[react-flip-toolkit]\\nThe \"debug\" prop is set to true. All FLIP animations will return at the beginning of the transition.'\n      )\n    }\n  }\n\n  const duplicateFlipIds = getDuplicateValsAsStrings(flippedIds)\n  if (process.env.NODE_ENV !== 'production') {\n    if (duplicateFlipIds.length) {\n      // eslint-disable-next-line no-console\n      console.error(\n        `[react-flip-toolkit]\\nThere are currently multiple elements with the same flipId on the page.\\nThe animation will only work if each Flipped component has a unique flipId.\\nDuplicate flipId${\n          duplicateFlipIds.length > 1 ? 's' : ''\n        }: ${duplicateFlipIds.join('\\n')}`\n      )\n    }\n  }\n\n  const flipDataArray: FlipDataArray = flippedIds\n\n    // take all the measurements we need\n    // and return an object with animation functions + necessary data\n    .map(id => {\n      const prevRect = flippedElementPositionsBeforeUpdate[id].rect\n      const currentRect = flippedElementPositionsAfterUpdate[id].rect\n      const prevOpacity = flippedElementPositionsBeforeUpdate[id].opacity\n      const currentOpacity = flippedElementPositionsAfterUpdate[id].opacity\n      const needsForcedMinVals = currentRect.width < 1 || currentRect.height < 1\n      const element = flippedElementPositionsAfterUpdate[id].element\n\n      // don't animate elements outside of the user's viewport\n      if (!rectInViewport(prevRect) && !rectInViewport(currentRect)) {\n        return false\n      }\n\n      // this might happen if we are rapidly adding & removing elements(?)\n      if (!element) {\n        return false\n      }\n\n      const flipConfig = extractFlipConfig(element)\n\n      const springConfig = getSpringConfig({\n        flipperSpring: spring,\n        flippedSpring: flipConfig.spring\n      })\n\n      const stagger =\n        flipConfig.stagger === true ? 'default' : flipConfig.stagger\n\n      const toReturn = {\n        element,\n        id,\n        stagger,\n        springConfig\n      }\n\n      if (flipCallbacks[id] && flipCallbacks[id].shouldFlip) {\n        const elementShouldFlip = flipCallbacks[id].shouldFlip!(\n          decisionData.previous,\n          decisionData.current\n        )\n        if (!elementShouldFlip) {\n          return false\n        }\n      }\n\n      // don't animate elements that didn't visibly change\n      // but possibly animate their children\n\n      const translateXDifference = Math.abs(prevRect.left - currentRect.left)\n      const translateYDifference = Math.abs(prevRect.top - currentRect.top)\n\n      const translateDifference = translateXDifference + translateYDifference\n\n      const scaleXDifference = Math.abs(prevRect.width - currentRect.width)\n      const scaleYDifference = Math.abs(prevRect.height - currentRect.height)\n\n      const scaleDifference = scaleXDifference + scaleYDifference\n\n      const opacityDifference = Math.abs(currentOpacity - prevOpacity)\n      const differenceTooSmall =\n        translateDifference < 0.5 &&\n        scaleDifference < 0.5 &&\n        opacityDifference < 0.01\n\n      const hiddenDueToDimensions =\n        (prevRect.height === 0 && currentRect.height === 0) ||\n        (prevRect.width === 0 && currentRect.width === 0)\n      if (hiddenDueToDimensions || differenceTooSmall) {\n        return false\n      }\n\n      const currentTransform = Rematrix.parse(\n        flippedElementPositionsAfterUpdate[id].transform\n      )\n\n      const toVals: AnimatedVals = { matrix: currentTransform }\n\n      const fromVals: AnimatedVals = { matrix: [] }\n      const transformsArray = [currentTransform]\n\n      // we're only going to animate the values that the child wants animated\n      if (flipConfig.translate) {\n        transformsArray.push(\n          Rematrix.translateX(prevRect.left - currentRect.left)\n        )\n        transformsArray.push(\n          Rematrix.translateY(prevRect.top - currentRect.top)\n        )\n      }\n      // going any smaller than 1px breaks transitions in Chrome\n      if (flipConfig.scale) {\n        transformsArray.push(\n          Rematrix.scaleX(\n            Math.max(prevRect.width, 1) / Math.max(currentRect.width, 1)\n          )\n        )\n        transformsArray.push(\n          Rematrix.scaleY(\n            Math.max(prevRect.height, 1) / Math.max(currentRect.height, 1)\n          )\n        )\n      }\n\n      if (flipConfig.opacity) {\n        fromVals.opacity = prevOpacity\n        toVals.opacity = currentOpacity\n      }\n\n      let invertedChildren: InvertedChildren = []\n\n      if (\n        !flipCallbacks[id] ||\n        !flipCallbacks[id].shouldInvert ||\n        flipCallbacks[id].shouldInvert!(\n          decisionData.previous,\n          decisionData.current\n        )\n      ) {\n        const invertedChildElements = getInvertedChildren(element, id)\n        invertedChildren = invertedChildElements.map(c => [\n          c,\n          extractFlipConfig(c)\n        ]) as InvertedChildren\n      }\n\n      fromVals.matrix = convertMatrix3dArrayTo2dArray(\n        transformsArray.reduce(Rematrix.multiply)\n      )\n\n      toVals.matrix = convertMatrix3dArrayTo2dArray(toVals.matrix)\n\n      const applyStyles = createApplyStylesFunc({\n        element,\n        invertedChildren,\n        body\n      })\n\n      let onComplete: () => void\n      if (flipCallbacks[id] && flipCallbacks[id].onComplete) {\n        // must cache or else this could cause an error\n        const cachedOnComplete = flipCallbacks[id].onComplete\n        onComplete = () => cachedOnComplete!(element, decisionData)\n      }\n\n      // this should be called when animation ends naturally\n      // but also when it is interrupted\n      // when it is called, the animation has already been cancelled\n      const onAnimationEnd = (isCancellation: boolean) => {\n        delete inProgressAnimations[id]\n        if (isFunction(onComplete)) {\n          onComplete()\n        }\n        // remove identity transform -- this should have no effect on layout\n        element.style.transform = ''\n        invertedChildren.forEach(([element]) => {\n          element.style.transform = ''\n        })\n        if (needsForcedMinVals && element) {\n          element.style.minHeight = ''\n          element.style.minWidth = ''\n        }\n        if (isCancellation) return\n\n        completedAnimationIds.push(id)\n\n        if (completedAnimationIds.length >= flipDataArray.length) {\n          // we can theoretically call multiple times since a promise only resolves 1x\n          // but that shouldnt happen\n          closureResolve(completedAnimationIds)\n        }\n      }\n\n      const animateOpacity =\n        isNumber(fromVals.opacity) &&\n        isNumber(toVals.opacity) &&\n        fromVals.opacity !== toVals.opacity\n\n      let onStartCalled = false\n\n      const getOnUpdateFunc: GetOnUpdateFunc = ({ spring, onAnimationEnd }) => {\n        inProgressAnimations[id] = {\n          destroy: spring.destroy.bind(spring),\n          onAnimationEnd\n        }\n        const onUpdate: OnUpdate = spring => {\n          if (flipCallbacks[id] && flipCallbacks[id].onSpringUpdate) {\n            flipCallbacks[id].onSpringUpdate!(spring.getCurrentValue())\n          }\n          // trigger the user provided onStart function\n          if (!onStartCalled) {\n            onStartCalled = true\n            if (flipCallbacks[id] && flipCallbacks[id].onStart) {\n              flipCallbacks[id].onStart!(element, decisionData)\n            }\n          }\n\n          const currentValue = spring.getCurrentValue()\n          if (!body.contains(element)) {\n            spring.destroy()\n            return\n          }\n\n          const vals: AnimatedVals = { matrix: [] }\n\n          vals.matrix = fromVals.matrix.map((fromVal, index) =>\n            tweenProp(fromVal, toVals.matrix[index], currentValue)\n          )\n\n          if (animateOpacity) {\n            vals.opacity = tweenProp(\n              fromVals.opacity!,\n              toVals.opacity!,\n              currentValue\n            )\n          }\n          applyStyles(vals)\n        }\n        return onUpdate\n      }\n\n      const initializeFlip: InitializeFlip = () => {\n        // before animating, immediately apply FLIP styles to prevent flicker\n        applyStyles({\n          matrix: fromVals.matrix,\n          opacity: animateOpacity ? fromVals.opacity : undefined,\n          forceMinVals: needsForcedMinVals\n        })\n\n        if (flipCallbacks[id] && flipCallbacks[id].onStartImmediate) {\n          flipCallbacks[id].onStartImmediate!(element, decisionData)\n        }\n        // and batch any other style updates if necessary\n        if (flipConfig.transformOrigin) {\n          element.style.transformOrigin = flipConfig.transformOrigin\n        } else if (applyTransformOrigin) {\n          element.style.transformOrigin = '0 0'\n        }\n\n        invertedChildren.forEach(([child, childFlipConfig]) => {\n          if (childFlipConfig.transformOrigin) {\n            child.style.transformOrigin = childFlipConfig.transformOrigin\n          } else if (applyTransformOrigin) {\n            child.style.transformOrigin = '0 0'\n          }\n        })\n      }\n\n      return assign({}, toReturn, {\n        stagger,\n        springConfig,\n        getOnUpdateFunc,\n        initializeFlip,\n        onAnimationEnd,\n        delayUntil: flipConfig.delayUntil\n      }) as FlipData\n    })\n    // filter out data for all non-animated elements first\n    .filter(Boolean) as FlipDataArray\n\n  flipDataArray.forEach(({ initializeFlip }) => initializeFlip())\n\n  if (debug) {\n    return () => {}\n  }\n\n  const elementIsFlipped = (flipId: FlipId) =>\n    flipDataArray.filter(f => f.id === flipId).length\n\n  const delayedFlip = flipDataArray.filter(\n    f => f.delayUntil && elementIsFlipped(f.delayUntil)\n  )\n\n  // key: flipId value: flip to delay until key is called\n  const delayUntilSprings = {} as IndexableObject\n  // key: flipId value: stagger to delay until key is called\n  const delayUntilStaggers = {} as IndexableObject\n  // key: stagger value: true\n  const delayedStaggerKeys = {} as IndexableObject\n\n  delayedFlip.forEach(flip => {\n    if (flip.stagger) {\n      delayedStaggerKeys[flip.stagger] = true\n      if (delayUntilStaggers[flip.delayUntil!])\n        delayUntilStaggers[flip.delayUntil!].push(flip.stagger)\n      else delayUntilStaggers[flip.delayUntil!] = [flip.stagger]\n    } else {\n      if (delayUntilSprings[flip.delayUntil!])\n        delayUntilSprings[flip.delayUntil!].push(flip)\n      else delayUntilSprings[flip.delayUntil!] = [flip]\n    }\n  })\n\n  const staggerDict = flipDataArray\n    .filter(flipData => flipData.stagger)\n    .reduce((acc, curr) => {\n      if (acc[curr.stagger]) {\n        acc[curr.stagger].push(curr)\n      } else {\n        acc[curr.stagger] = [curr]\n      }\n      return acc\n    }, {} as IndexableObject)\n\n  const immediateFlip = flipDataArray.filter(f => delayedFlip.indexOf(f) === -1)\n\n  immediateFlip.forEach(flipData => {\n    flipData.onSpringActivate = () => {\n      if (delayUntilSprings[flipData.id]) {\n        delayUntilSprings[flipData.id].forEach(createSpring)\n      }\n      if (delayUntilStaggers[flipData.id]) {\n        const uniqueStaggerKeys = Object.keys(\n          delayUntilStaggers[flipData.id].reduce(\n            (acc: IndexableObject, curr: string) =>\n              assign(acc, { [curr]: true }),\n            {}\n          )\n        )\n        uniqueStaggerKeys.forEach((staggerKey: string) => {\n          createStaggeredSprings(\n            staggerDict[staggerKey],\n            staggerConfig[staggerKey]\n          )\n        })\n      }\n    }\n  })\n\n  return () => {\n    // if there are no active FLIP animations, immediately resolve the\n    // returned promise\n    if (!flipDataArray.length) {\n      closureResolve([])\n    }\n    // animate non-staggered elements\n    immediateFlip\n      .filter(flipData => {\n        return !flipData.stagger\n      })\n      .forEach(createSpring)\n\n    // animate staggered elements\n    Object.keys(staggerDict).forEach(staggerKey => {\n      if (delayedStaggerKeys[staggerKey]) return\n      createStaggeredSprings(staggerDict[staggerKey], staggerConfig[staggerKey])\n    })\n    return flipCompletedPromise\n  }\n}\n","import { toArray, assign } from '../../utilities'\nimport * as constants from '../../constants'\nimport { BoundingClientRect } from './types'\n\nexport const addTupleToObject = <T>(\n  acc: Record<string, T>,\n  curr: [string, T]\n): Record<string, T> => assign(acc, { [curr[0]]: curr[1] })\n\nexport const getAllElements = (\n  element?: HTMLElement,\n  portalKey?: string\n): HTMLElement[] => {\n  if (portalKey) {\n    return toArray(\n      document.querySelectorAll(`[${constants.DATA_PORTAL_KEY}=\"${portalKey}\"]`)\n    )\n  } else {\n    return toArray(element!.querySelectorAll(`[${constants.DATA_FLIP_ID}]`))\n  }\n}\nexport const getRects = (\n  flippedElements: HTMLElement[]\n): [HTMLElement, BoundingClientRect][] => {\n  return flippedElements.map(\n    (child: HTMLElement): [HTMLElement, BoundingClientRect] => [\n      child,\n      child.getBoundingClientRect()\n    ]\n  )\n}\n","import animateUnflippedElements from './animateUnflippedElements'\nimport animateFlippedElements from './animateFlippedElements'\nimport getFlippedElementPositionsAfterUpdate from './getFlippedElementPositions/getFlippedElementPositionsAfterUpdate'\nimport * as constants from '../constants'\nimport { assign, toArray } from '../utilities'\nimport {\n  GetElement,\n  BaseFlipArgs,\n  OnFlipKeyUpdateArgs,\n  FlippedIds\n} from './types'\nimport { AnimateUnflippedElementsArgs } from './animateUnflippedElements/types'\nimport {\n  AnimateFlippedElementsArgs,\n  ScopedSelector\n} from './animateFlippedElements/types'\n\nlet enabled = true\n\nexport const disableFlip = () => (enabled = false)\n\nexport const enableFlip = () => (enabled = true)\n\nexport const isFlipEnabled = () => enabled\n\nconst createPortalScopedSelector =\n  (portalKey: string) => (selector: string) => {\n    return toArray(\n      document.querySelectorAll(\n        `[${constants.DATA_PORTAL_KEY}=\"${portalKey}\"]${selector}`\n      )\n    )\n  }\nconst createFlipperScopedSelector = (containerEl: HTMLElement) => {\n  const tempFlipperId = Math.random().toFixed(5)\n  containerEl.dataset.flipperId = tempFlipperId\n\n  return (selector: string) => {\n    return toArray(\n      containerEl.querySelectorAll(\n        `[data-flipper-id=\"${tempFlipperId}\"] ${selector}`\n      )\n    )\n  }\n}\nconst createScopedSelector = ({\n  containerEl,\n  portalKey\n}: {\n  containerEl?: HTMLElement\n  portalKey?: string\n}): ScopedSelector => {\n  if (portalKey) {\n    return createPortalScopedSelector(portalKey)\n  } else if (containerEl) {\n    return createFlipperScopedSelector(containerEl)\n  } else {\n    return () => []\n  }\n}\n\nconst createGetElementFunc = (scopedSelector: ScopedSelector): GetElement => {\n  return (id: string) => {\n    return scopedSelector(`[${constants.DATA_FLIP_ID}=\"${id}\"]`)[0]\n  }\n}\n\nexport const onFlipKeyUpdate = ({\n  cachedOrderedFlipIds = [],\n  inProgressAnimations = {},\n  flippedElementPositionsBeforeUpdate = {},\n  flipCallbacks = {},\n  containerEl,\n  applyTransformOrigin,\n  spring,\n  debug,\n  portalKey,\n  staggerConfig = {},\n  decisionData = {},\n  handleEnterUpdateDelete,\n  onComplete,\n  onStart\n}: OnFlipKeyUpdateArgs) => {\n  if (!enabled) return\n  const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)')\n  if (mediaQuery.matches) return\n  const flippedElementPositionsAfterUpdate =\n    getFlippedElementPositionsAfterUpdate({\n      element: containerEl,\n      portalKey\n    })\n\n  const scopedSelector = createScopedSelector({\n    containerEl,\n    portalKey\n  })\n  const getElement = createGetElementFunc(scopedSelector)\n\n  const isFlipped = (id: string) =>\n    flippedElementPositionsBeforeUpdate[id] &&\n    flippedElementPositionsAfterUpdate[id]\n\n  const unflippedIds = Object.keys(flippedElementPositionsBeforeUpdate)\n    .concat(Object.keys(flippedElementPositionsAfterUpdate))\n    .filter(id => !isFlipped(id))\n\n  const baseArgs: BaseFlipArgs = {\n    flipCallbacks,\n    getElement,\n    flippedElementPositionsBeforeUpdate,\n    flippedElementPositionsAfterUpdate,\n    inProgressAnimations,\n    decisionData\n  }\n\n  const animateUnFlippedElementsArgs = assign({}, baseArgs, {\n    unflippedIds\n  }) as AnimateUnflippedElementsArgs\n\n  const {\n    hideEnteringElements,\n    animateEnteringElements,\n    animateExitingElements\n  } = animateUnflippedElements(animateUnFlippedElementsArgs)\n\n  const flippedIds: FlippedIds = cachedOrderedFlipIds.filter(isFlipped)\n  // @ts-ignore\n  const animateFlippedElementsArgs: AnimateFlippedElementsArgs = assign(\n    {},\n    baseArgs,\n    {\n      containerEl,\n      flippedIds,\n      applyTransformOrigin,\n      spring,\n      debug,\n      staggerConfig,\n      scopedSelector,\n      onComplete\n    }\n  )\n  if (onStart) onStart(containerEl, decisionData)\n\n  // the function handles putting flipped elements back in their original positions\n  // and returns another function to actually call the flip animation\n  const flip = animateFlippedElements(animateFlippedElementsArgs)\n\n  if (handleEnterUpdateDelete) {\n    handleEnterUpdateDelete({\n      hideEnteringElements,\n      animateEnteringElements,\n      animateExitingElements,\n      animateFlippedElements: flip\n    })\n  } else {\n    hideEnteringElements()\n    animateExitingElements().then(animateEnteringElements)\n    flip()\n  }\n}\n\n","import { addTupleToObject, getRects, getAllElements } from '../utilities'\nimport {\n  FlippedElementPositionsAfterUpdate,\n  FlippedElementPositionDatumAfterUpdate\n} from './types'\n\nconst getFlippedElementPositionsAfterUpdate = ({\n  element,\n  portalKey\n}: {\n  element: HTMLElement\n  portalKey?: string\n}): FlippedElementPositionsAfterUpdate => {\n  const positionArray = getRects(getAllElements(element, portalKey)).map(\n    ([child, childBCR]) => {\n      const computedStyle = window.getComputedStyle(child)\n      return [\n        child.dataset.flipId,\n        {\n          element: child,\n          rect: childBCR,\n          opacity: parseFloat(computedStyle.opacity!),\n          transform: computedStyle.transform\n        }\n      ]\n    }\n  ) as [string, FlippedElementPositionDatumAfterUpdate][]\n\n  return positionArray.reduce(addTupleToObject, {})\n}\n\nexport default getFlippedElementPositionsAfterUpdate\n","import { addTupleToObject, getAllElements, getRects } from '../utilities'\nimport * as constants from '../../../constants'\nimport { toArray, assign } from '../../../utilities'\nimport {\n  FlippedElementPositionsBeforeUpdateReturnVals,\n  FlippedElementPositionDatumBeforeUpdate,\n  GetFlippedElementPositionsBeforeUpdateArgs,\n  ParentBCRs,\n  ChildIdsToParentBCRs,\n  ChildIdsToParents\n} from './types'\nimport { InProgressAnimations } from '../../../types'\n\nexport const cancelInProgressAnimations = (\n  inProgressAnimations: InProgressAnimations,\n  animatingElements: HTMLElement[]\n) => {\n  Object.keys(inProgressAnimations).forEach(id => {\n    if (inProgressAnimations[id].destroy) {\n      inProgressAnimations[id].destroy!()\n    }\n    if (inProgressAnimations[id].onAnimationEnd) {\n      inProgressAnimations[id].onAnimationEnd!(true)\n    }\n    delete inProgressAnimations[id]\n  })\n  animatingElements.forEach(el => {\n    el.style.transform = ''\n    el.style.opacity = ''\n  })\n}\n\nconst getFlippedElementPositionsBeforeUpdate = ({\n  element,\n  flipCallbacks = {},\n  inProgressAnimations = {},\n  portalKey\n}: GetFlippedElementPositionsBeforeUpdateArgs): FlippedElementPositionsBeforeUpdateReturnVals => {\n  const flippedElements = getAllElements(element, portalKey)\n\n  const inverseFlippedElements = toArray(\n    element.querySelectorAll(`[${constants.DATA_INVERSE_FLIP_ID}]`)\n  )\n\n  const childIdsToParentBCRs: ChildIdsToParentBCRs = {}\n  const parentBCRs: ParentBCRs = []\n  const childIdsToParents: ChildIdsToParents = {}\n  // this is for exit animations so we can re-insert exiting elements in the\n  // DOM later\n  flippedElements\n    .filter(\n      el =>\n        flipCallbacks &&\n        flipCallbacks[el.dataset.flipId!] &&\n        flipCallbacks[el.dataset.flipId!].onExit\n    )\n    .forEach(el => {\n      let parent = el.parentNode as HTMLElement\n      // this won't work for IE11\n      if (el.closest) {\n        const exitContainer = el.closest(\n          `[${constants.DATA_EXIT_CONTAINER}]`\n        ) as HTMLElement\n        if (exitContainer) {\n          parent = exitContainer\n        }\n      }\n      let bcrIndex = parentBCRs.findIndex(n => n[0] === parent)\n      if (bcrIndex === -1) {\n        parentBCRs.push([parent, parent.getBoundingClientRect()])\n        bcrIndex = parentBCRs.length - 1\n      }\n      childIdsToParentBCRs[el.dataset.flipId!] = parentBCRs[bcrIndex][1]\n      childIdsToParents[el.dataset.flipId!] = parent\n    })\n\n  const filteredFlippedElements = getRects(flippedElements)\n\n  const flippedElementPositionsTupleArray: [\n    string,\n    FlippedElementPositionDatumBeforeUpdate\n  ][] = filteredFlippedElements.map(([child, childBCR]) => {\n    const domDataForExitAnimations = {}\n\n    // only cache extra data for exit animations\n    // if the element has an onExit listener\n    if (\n      flipCallbacks &&\n      flipCallbacks[child.dataset.flipId!] &&\n      flipCallbacks[child.dataset.flipId!].onExit\n    ) {\n      const parentBCR = childIdsToParentBCRs[child.dataset.flipId!]\n\n      assign(domDataForExitAnimations, {\n        element: child,\n        parent: childIdsToParents[child.dataset.flipId!],\n        childPosition: {\n          top: childBCR.top - parentBCR.top,\n          left: childBCR.left - parentBCR.left,\n          width: childBCR.width,\n          height: childBCR.height\n        }\n      })\n    }\n\n    return [\n      child.dataset.flipId!,\n      {\n        rect: childBCR,\n        opacity: parseFloat(window.getComputedStyle(child).opacity || '1'),\n        domDataForExitAnimations\n      }\n    ]\n  }) as [string, FlippedElementPositionDatumBeforeUpdate][]\n\n  const flippedElementPositions = flippedElementPositionsTupleArray.reduce(\n    addTupleToObject,\n    {}\n  )\n\n  // do this at the very end since we want to cache positions of elements\n  // while they are mid-transition\n  cancelInProgressAnimations(\n    inProgressAnimations,\n    flippedElements.concat(inverseFlippedElements)\n  )\n\n  return {\n    flippedElementPositions,\n    cachedOrderedFlipIds: filteredFlippedElements.map(\n      ([el]) => el.dataset.flipId!\n    )\n  }\n}\n\nexport default getFlippedElementPositionsBeforeUpdate\n","import { onFlipKeyUpdate } from './flip'\nimport getFlippedElementPositionsBeforeUpdate from './flip/getFlippedElementPositions/getFlippedElementPositionsBeforeUpdate'\nimport { assign } from './utilities'\nimport {\n  StaggerConfig,\n  HandleEnterUpdateDelete,\n  InProgressAnimations,\n  FlipCallbacks,\n  OnFlipperComplete,\n  FlippedProps,\n  OnFlipperStart\n} from './types'\nimport { SpringOption } from './springSettings/types'\nimport { FlippedElementPositionsBeforeUpdate } from './flip/getFlippedElementPositions/getFlippedElementPositionsBeforeUpdate/types'\nimport { FlippedIds } from './flip/types'\n\ninterface Options {\n  element: HTMLElement\n  staggerConfig?: StaggerConfig\n  spring?: SpringOption\n  applyTransformOrigin?: boolean\n  handleEnterUpdateDelete?: HandleEnterUpdateDelete\n  debug?: boolean\n  onStart?: OnFlipperStart\n  onComplete?: OnFlipperComplete\n}\n\nclass Flipper {\n  private element!: HTMLElement\n  private staggerConfig!: StaggerConfig\n  private applyTransformOrigin = true\n  private handleEnterUpdateDelete!: HandleEnterUpdateDelete\n  private debug?: boolean\n  private spring!: SpringOption\n  private inProgressAnimations: InProgressAnimations\n  private flipCallbacks: FlipCallbacks\n  private snapshot?: {\n    flippedElementPositions: FlippedElementPositionsBeforeUpdate\n    cachedOrderedFlipIds: FlippedIds\n  }\n  private onComplete?: OnFlipperComplete\n  private onStart?: OnFlipperStart\n\n  constructor(options: Options) {\n    assign(this, options)\n\n    this.inProgressAnimations = {}\n    this.flipCallbacks = {}\n\n    this.recordBeforeUpdate = this.recordBeforeUpdate.bind(this)\n    this.update = this.update.bind(this)\n    this.addFlipped = this.addFlipped.bind(this)\n    this.addInverted = this.addInverted.bind(this)\n  }\n\n  recordBeforeUpdate() {\n    this.snapshot = getFlippedElementPositionsBeforeUpdate({\n      element: this.element,\n      flipCallbacks: this.flipCallbacks,\n      inProgressAnimations: this.inProgressAnimations\n    })\n  }\n  update(prevDecisionData: any, currentDecisionData: any) {\n    if (this.snapshot) {\n      onFlipKeyUpdate({\n        flippedElementPositionsBeforeUpdate:\n          this.snapshot.flippedElementPositions,\n        cachedOrderedFlipIds: this.snapshot.cachedOrderedFlipIds,\n        containerEl: this.element,\n        inProgressAnimations: this.inProgressAnimations,\n        flipCallbacks: this.flipCallbacks,\n        applyTransformOrigin: this.applyTransformOrigin,\n        spring: this.spring,\n        debug: this.debug,\n        staggerConfig: this.staggerConfig,\n        handleEnterUpdateDelete: this.handleEnterUpdateDelete,\n        decisionData: {\n          previous: prevDecisionData,\n          current: currentDecisionData\n        },\n        onComplete: this.onComplete,\n        onStart: this.onStart\n      })\n      delete this.snapshot\n    }\n  }\n\n  addFlipped({\n    element,\n    flipId,\n    opacity,\n    translate,\n    scale,\n    transformOrigin,\n    spring,\n    stagger,\n    delayUntil,\n    onAppear,\n    onStart,\n    onSpringUpdate,\n    onComplete,\n    onExit,\n    shouldFlip,\n    shouldInvert\n  }: FlippedProps & { element: HTMLElement }) {\n    if (!element) {\n      throw new Error('no element provided')\n    }\n    if (!flipId) {\n      throw new Error('No flipId provided')\n    }\n    const flipConfig = {\n      scale,\n      translate,\n      opacity,\n      transformOrigin,\n      spring,\n      stagger,\n      delayUntil\n    }\n    if (!flipConfig.scale && !flipConfig.translate && !flipConfig.opacity) {\n      assign(flipConfig, {\n        translate: true,\n        scale: true,\n        opacity: true\n      })\n    }\n    if (flipId) {\n      element.dataset.flipId = String(flipId)\n    }\n    element.dataset.flipConfig = JSON.stringify(flipConfig)\n    // finally, add callbacks\n    this.flipCallbacks[flipId] = {\n      shouldFlip,\n      shouldInvert,\n      onAppear,\n      onStart,\n      onSpringUpdate,\n      onComplete,\n      onExit\n    }\n  }\n\n  addInverted({\n    element,\n    parent,\n    opacity,\n    translate,\n    scale,\n    transformOrigin\n  }: {\n    element: HTMLElement\n    parent: HTMLElement\n    opacity: boolean\n    translate: boolean\n    scale: boolean\n    transformOrigin: string\n  }) {\n    if (!element) {\n      throw new Error('no element provided')\n    }\n    if (!parent) {\n      throw new Error('parent must be provided')\n    }\n\n    const inverseFlipId = parent.dataset.flipId\n    const flipConfig = {\n      scale,\n      translate,\n      opacity,\n      transformOrigin\n    }\n    if (!flipConfig.scale && !flipConfig.translate && !flipConfig.opacity) {\n      assign(flipConfig, {\n        translate: true,\n        scale: true,\n        opacity: true\n      })\n    }\n    element.dataset.inverseFlipId = inverseFlipId\n    element.dataset.flipConfig = JSON.stringify(flipConfig)\n  }\n}\n\nexport default Flipper\n","// this is exclusively for users of the library to create their own enter + exit animations\nimport { SpringSystem } from '../forked-rebound'\nimport { SpringSystemInterface } from '../forked-rebound/types.d'\nimport { tweenProp, assign } from '../utilities'\nimport { normalizeSpring, springPresets } from '../springSettings'\nimport { SimpleSpringOptions } from './types'\nimport { SpringConfig } from '../springSettings/types'\n\n// this should get created only 1x\nconst springSystem: SpringSystemInterface = new SpringSystem()\n\n/**\n * A simple spring function for animating DOM properties.\n * Returns a function that will immediately cancel the in-progress animation.\n * */\nconst createSimpleSpring = ({\n  config,\n  values,\n  onUpdate,\n  delay = 0,\n  onComplete\n}: SimpleSpringOptions) => {\n  const { stiffness, damping, overshootClamping } = assign(\n    {},\n    springPresets.noWobble,\n    normalizeSpring(config)\n  ) as SpringConfig\n  const spring = springSystem.createSpring(stiffness!, damping!)\n  spring.setOvershootClampingEnabled(!!overshootClamping)\n  spring.addListener({\n    onSpringAtRest: spring => {\n      if (onComplete) onComplete()\n      spring.destroy()\n    },\n    onSpringUpdate: spring => {\n      const springVal = spring.getCurrentValue()\n      if (!values) return onUpdate(springVal)\n      const currentValues = Object.keys(values)\n        .map(value => [\n          value,\n          tweenProp(values[value][0], values[value][1], springVal)\n        ])\n        .reduce((acc, curr) => {\n          return Object.assign(acc, { [curr[0]]: curr[1] })\n        }, {})\n      onUpdate(currentValues)\n    }\n  })\n  if (delay) {\n    setTimeout(() => {\n      spring.setEndValue(1)\n    }, delay)\n  } else {\n    spring.setEndValue(1)\n  }\n  return spring\n}\n\nexport default createSimpleSpring\n"],"names":["isNumber","x","isFunction","isObject","Object","prototype","toString","call","toArray","arrayLike","Array","slice","apply","getDuplicateValsAsStrings","arr","obj","reduce","acc","curr","keys","filter","val","assign","target","args","forEach","arg","nextKey","hasOwnProperty","tweenProp","start","end","position","DATA_FLIP_ID","DATA_INVERSE_FLIP_ID","DATA_PORTAL_KEY","DATA_EXIT_CONTAINER","springPresets","noWobble","stiffness","damping","gentle","veryGentle","wobbly","stiff","normalizeSpring","spring","indexOf","_onFrame","window","requestAnimationFrame","callback","setTimeout","Date","now","performanceNow","performance","removeFirst","array","item","idx","splice","AnimationLooper","run","onFrame","this","springSystem","loop","PhysicsState","constructor","velocity","ID","SOLVER_TIMESTEP_SEC","Spring","_id","_springSystem","listeners","_startValue","_currentState","_displacementFromRestThreshold","_endValue","_overshootClampingEnabled","_previousState","_restSpeedThreshold","_tempState","_timeAccumulator","_wasAtRest","_cachedSpringConfig","getId","destroy","deregisterSpring","setSpringConfig","springConfig","_springConfig","getCurrentValue","getDisplacementDistanceForState","state","Math","abs","setEndValue","endValue","prevEndValue","isAtRest","activateSpring","i","len","length","onChange","onSpringEndStateChange","setVelocity","setCurrentValue","currentValue","listener","onSpringUpdate","setAtRest","setOvershootClampingEnabled","enabled","isOvershooting","tension","advance","time","realDeltaTime","adjustedDeltaTime","friction","aVelocity","aAcceleration","bVelocity","bAcceleration","cVelocity","cAcceleration","dVelocity","dAcceleration","dxdt","dvdt","tempPosition","tempVelocity","_interpolate","notifyActivate","notifyAtRest","notifyPositionUpdated","Boolean","onSpringActivate","_onActivateCalled","onSpringAtRest","systemShouldAdvance","wasAtRest","alpha","addListener","newListener","push","addOneTimeListener","oneTimeFunc","func","removeListener","key","listenerToRemove","SpringSystem","looper","_activeSprings","_idleSpringIndices","_isIdle","_lastTimeMillis","_springRegistry","createSpring","createSpringWithConfig","registerSpring","getIsIdle","deltaTime","pop","currentTimeMillis","ellapsedMillis","onBeforeIntegrate","onAfterIntegrate","springId","createSuspendedSpring","flipData","overshootClamping","getOnUpdateFunc","onAnimationEnd","flipped","createStaggeredSprings","flippedArray","staggerConfig","reverse","normalizedSpeed","speedConfig","speed","min","max","nextThreshold","setEndValueFuncs","map","cachedGetOnUpdate","onUpdate","bind","convertMatrix3dArrayTo2dArray","matrix","index","rectInViewport","top","bottom","left","right","innerHeight","innerWidth","extractFlipConfig","element","JSON","parse","dataset","flipConfig","addTupleToObject","getAllElements","portalKey","document","querySelectorAll","constants","getRects","flippedElements","child","getBoundingClientRect","disableFlip","enableFlip","isFlipEnabled","onFlipKeyUpdate","cachedOrderedFlipIds","inProgressAnimations","flippedElementPositionsBeforeUpdate","flipCallbacks","containerEl","applyTransformOrigin","debug","decisionData","handleEnterUpdateDelete","onComplete","onStart","matchMedia","matches","flippedElementPositionsAfterUpdate","getFlippedElementPositionsAfterUpdate","childBCR","computedStyle","getComputedStyle","flipId","rect","opacity","parseFloat","transform","scopedSelector","createScopedSelector","selector","createPortalScopedSelector","tempFlipperId","random","toFixed","flipperId","createFlipperScopedSelector","getElement","id","createGetElementFunc","isFlipped","unflippedIds","concat","baseArgs","animateUnFlippedElementsArgs","hideEnteringElements","animateEnteringElements","animateExitingElements","animateUnflippedElements","animatedEnteringElementIds","onAppear","animatedExitingElementIds","onExit","closureResolve","promiseToReturn","Promise","resolve","fragmentTuples","exitingElementCount","onExitCallbacks","domDataForExitAnimations","parent","childPosition","width","height","style","fragmentTuple","t","createDocumentFragment","appendChild","stop","removeChild","DOMException","c","animateFlippedElementsArgs","flippedIds","flip","flipCompletedPromise","then","completedAnimationIds","firstElement","body","ownerDocument","querySelector","flipDataArray","prevRect","currentRect","prevOpacity","currentOpacity","needsForcedMinVals","getSpringConfig","flipperSpring","flippedSpring","stagger","toReturn","shouldFlip","previous","current","translateDifference","scaleDifference","opacityDifference","currentTransform","Rematrix","toVals","fromVals","transformsArray","translate","translateX","translateY","scale","scaleX","scaleY","invertedChildren","shouldInvert","invertedChildElements","getInvertedChildren","multiply","applyStyles","createApplyStylesFunc","forceMinVals","minHeight","minWidth","stringTransform","join","convertMatrix2dArrayToString","invertTransformsForChildren","childFlipConfig","contains","inverseVals","transformString","cachedOnComplete","animateOpacity","onStartCalled","vals","fromVal","initializeFlip","undefined","onStartImmediate","transformOrigin","isCancellation","delayUntil","delayedFlip","f","delayUntilSprings","delayUntilStaggers","delayedStaggerKeys","staggerDict","immediateFlip","staggerKey","animateFlippedElements","getFlippedElementPositionsBeforeUpdate","inverseFlippedElements","childIdsToParentBCRs","parentBCRs","childIdsToParents","el","parentNode","closest","exitContainer","bcrIndex","findIndex","n","filteredFlippedElements","flippedElementPositions","parentBCR","cancelInProgressAnimations","animatingElements","Flipper","options","snapshot","recordBeforeUpdate","update","addFlipped","addInverted","prevDecisionData","currentDecisionData","Error","String","stringify","inverseFlipId","createSimpleSpring","config","values","delay","springVal","currentValues","value"],"mappings":"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"}