hunk.code_window:         const previous =
             entry.interpolation &&
             entry.interpolation._interpolation(entry.animation._value)
           animation = new AnimatedValue(0)
           interpolation = animation.interpolate({
             range: [0, 1],
             output: [previous !== undefined ? previous : fromValue, value],
  
hunk.labels: keep keep keep replace replace keep keep
hunk.after_edit:         if (entry.animation) {
             animation = entry.animation
             animation.setValue(0)
           } else animation = new AnimatedValue(0)
           const config = {
  
hunk.file_path: src/Spring.js
hunk.type: replace
file: import {
    Component,
    PureComponent,
    ReactNode,
    ComponentClass,
    ComponentType,
  } from 'react'
  
  export type SpringEasingFunc = (t: number) => number
  
  export interface SpringConfig {
    tension?: number
    friction?: number
    velocity?: number
    overshootClamping?: boolean
    restSpeedThreshold?: number
    restDisplacementThreshold?: number
  
    duration?: number
    easing?: SpringEasingFunc
  }
  
  type SpringRendererFunc<S extends object, DS extends object = {}> = (
    params: DS & S
  ) => ReactNode
  
  interface SpringProps<S extends object, DS extends object = {}> {
    /**
     * Spring config ({ tension, friction })
     * @default config.default
     */
    config?: SpringConfig | ((key: string) => SpringConfig)
    /**
     * Will skip rendering the component if true and write to the dom directly
     * @default false
     */
    native?: boolean
    /**
     * Base styles
     * @default {}
     */
    from?: DS
    /**
     * Animates to...
     * @default {}
     */
    to: DS
    /**
     * Callback when the animation starts to animate
     */
    onStart?: () => void
    /**
     * Callback when the animation comes to a still-stand
     */
    onRest?: () => void
    /**
     * Frame by frame callback, first argument passed is the animated value
     */
    onFrame?: () => void
    /**
     * Takes a function that receives interpolated styles
     */
    children?: SpringRendererFunc<S, DS> | Array<SpringRendererFunc<S, DS>>
    /**
     * Same as children, but takes precedence if present
     */
    render?: SpringRendererFunc<S, DS>
    /**
     * Prevents animation if true, you can also pass individual keys
     * @default false
     */
    immediate?: boolean | string[] | ((key: string) => boolean)
    /**
     * When true it literally resets: from -> to
     * @default false
     */
    reset?: boolean
    /**
     * Animation implementation
     * @default SpringAnimation
     */
    impl?: any
    /**
     * Inject props
     * @default undefined
     */
    inject?: any
    /**
     * Animation start delay, optional
     */
    delay?: number
  }
  
  export const config: {
    /** default: { tension: 170, friction: 26 } */
    default: SpringConfig
    /** gentle: { tension: 120, friction: 14 } */
    gentle: SpringConfig
    /** wobbly: { tension: 180, friction: 12 } */
    wobbly: SpringConfig
    /** stiff: { tension: 210, friction: 20 } */
    stiff: SpringConfig
    /** slow: { tension: 280, friction: 60 } */
    slow: SpringConfig
  }
  
  export class Spring<S extends object, DS extends object> extends PureComponent<
    SpringProps<S, DS> & S
  > {}
  
  export function interpolate(
    parent: number[],
    config: (...args: number[]) => any
  ): any
  
  export const animated: {
    [Tag in keyof JSX.IntrinsicElements]: ComponentClass<
      JSX.IntrinsicElements[Tag]
    >
  }
  
  type TransitionKeyProps = string | number
  type TransitionItemProps = string | number | object
  
  interface TransitionProps<S extends object, DS extends object = {}> {
    /**
     * Will skip rendering the component if true and write to the dom directly
     * @default false
     */
    native?: boolean
    /**
     * Spring config ({ tension, friction })
     * @default config.default
     */
    config?: SpringConfig | ((key: string) => SpringConfig)
    /**
     * Base styles
     * @default {}
     */
    from?: DS
    /**
     * Animated styles when the component is mounted
     * @default {}
     */
    enter?: DS
    /**
     * Unmount styles
     * @default {}
     */
    leave?: DS
  
    update?: DS
    /**
     * A collection of unique keys that must match with the childrens order
     * Can be omitted if children/render aren't an array
     * Can be a function, which then acts as a key-accessor which is useful when you use the items prop
     * @default {}
     */
    keys?:
      | ((params: TransitionItemProps) => TransitionKeyProps)
      | Array<TransitionKeyProps>
      | TransitionKeyProps
    /**
     * Optional. Let items refer to the actual data and from/enter/leaver/update can return per-object styles
     * @default {}
     */
    items?: Array<TransitionItemProps> | TransitionItemProps
  
    children?:
      | SpringRendererFunc<S, DS>
      | Array<SpringRendererFunc<S, DS>>
      | boolean
  
    render?:
      | SpringRendererFunc<S, DS>
      | Array<SpringRendererFunc<S, DS>>
      | boolean
  }
  
  export class Transition<
    S extends object,
    DS extends object
  > extends PureComponent<TransitionProps<S, DS> & S> {}
  
  type TrailKeyProps = string | number
  type TrailKeyItemProps = string | number | object
  
  interface TrailProps<S extends object, DS extends object = {}> {
    native?: boolean
  
    config?: SpringConfig | ((key: string) => SpringConfig)
  
    from?: DS
  
    to?: DS
  
    keys?:
      | ((params: TrailKeyItemProps) => TrailKeyProps)
      | Array<TrailKeyProps>
      | TrailKeyProps
  
    children?: SpringRendererFunc<S, DS> | Array<SpringRendererFunc<S, DS>>
  
    render?: SpringRendererFunc<S, DS> | Array<SpringRendererFunc<S, DS>>
  }
  
  export class Trail<S extends object, DS extends object> extends PureComponent<
    TrailProps<S, DS> & S
  > {}
  
  interface ParallaxProps<S extends object, DS extends object = {}> {
    pages: number
  
    config?: SpringConfig | ((key: string) => SpringConfig)
  
    scrolling?: boolean
  
    horizontal?: boolean
  }
  
  export class Parallax<
    S extends object,
    DS extends object
  > extends PureComponent<ParallaxProps<S, DS> & S> {}
  
  interface ParallaxLayerProps<S extends object, DS extends object = {}> {
    factor?: number
  
    offset?: number
  
    speed?: number
  }
  
  export class ParallaxLayer<
    S extends object,
    DS extends object
  > extends PureComponent<ParallaxLayerProps<S, DS> & S> {}
  
  interface KeyframesProps<S extends object, DS extends object = {}> {
    state?: string
  }
  
  export class Keyframes<S extends object, DS extends object> extends PureComponent<
    KeyframesProps<S, DS> & S
  > {
    static create<S extends object, DS extends object>(
      primitive: ComponentType
    ): (states: object) => (props: object) => Keyframes<S, DS>
    static Spring<S extends object, DS extends object>(
      states: object
    ): (props: object) => Keyframes<S | Pick<SpringProps<S,DS>, Exclude<keyof SpringProps<S,DS>, "to">>, DS>
    static Trail<S extends object, DS extends object>(
      states: object
    ): (props: object) => Keyframes<S | Pick<TrailProps<S,DS>, Exclude<keyof TrailProps<S,DS>, "to">>, DS> 
    static Transition<S extends object, DS extends object>(
      states: object
    ): (props: object) => Keyframes<S | Pick<TransitionProps<S,DS>, Exclude<keyof TransitionProps<S,DS>, "to">>, DS> 
  }
  