hunk.code_window:    *
      * When you pass a queue (instead of nothing), that queue is used instead of
      * the queued animations added with the `update` method, which are left alone.
      */
     start(props?: OneOrMore<UnknownPartial<ControllerProps<State>>>) {
       const queue = props
         ? toArray<any>(props).map(props => this._prepareUpdate(props))
         : this.queue
  
hunk.labels: keep keep keep keep replace keep keep keep
hunk.after_edit:   start(props?: OneOrMore<ControllerProps<State>>) {
  
hunk.file_path: packages/core/src/Controller.ts
hunk.type: replace
file: import { CSSProperties, ForwardRefExoticComponent } from 'react'
  import { withAnimated, extendAnimated } from 'animated'
  import {
    AssignableKeys,
    ElementType,
    ComponentPropsWithRef,
    FluidValue,
  } from 'shared'
  import { KonvaExports, KonvaElements, elements } from './elements'
  
  type CreateAnimated = <T extends ElementType>(
    wrappedComponent: T
  ) => AnimatedComponent<T>
  
  type KonvaComponents = {
    [Tag in KonvaElements]: AnimatedComponent<KonvaExports[Tag]>
  }
  
  // Extend animated with all the available Konva elements
  export const animated: CreateAnimated & KonvaComponents = extendAnimated(
    withAnimated,
    elements
  )
  
  export { animated as a }
  
  /** The type of an `animated()` component */
  export type AnimatedComponent<
    T extends ElementType
  > = ForwardRefExoticComponent<AnimatedProps<ComponentPropsWithRef<T>>>
  
  /** The props of an `animated()` component */
  export type AnimatedProps<Props extends object> = {
    [P in keyof Props]: P extends 'ref' | 'key'
      ? Props[P]
      : AnimatedProp<Props[P]>
  }
  
  // The animated prop value of a React element
  type AnimatedProp<T> = [T, T] extends [infer T, infer DT]
    ? [DT] extends [never]
      ? never
      : DT extends void
      ? undefined
      : DT extends object
      ? [AssignableKeys<DT, CSSProperties>] extends [never]
        ? DT extends ReadonlyArray<any>
          ? AnimatedStyles<DT>
          : DT
        : AnimatedStyle<T>
      : DT | AnimatedLeaf<T>
    : never
  
  // An animated array of style objects
  type AnimatedStyles<T extends ReadonlyArray<any>> = {
    [P in keyof T]: [T[P]] extends [infer DT]
      ? DT extends object
        ? [AssignableKeys<DT, CSSProperties>] extends [never]
          ? DT extends ReadonlyArray<any>
            ? AnimatedStyles<DT>
            : DT
          : { [P in keyof DT]: AnimatedProp<DT[P]> }
        : DT
      : never
  }
  
  // An animated object of style attributes
  type AnimatedStyle<T> = [T, T] extends [infer T, infer DT]
    ? DT extends void
      ? undefined
      : [DT] extends [never]
      ? never
      : DT extends object
      ? { [P in keyof DT]: AnimatedStyle<DT[P]> }
      : DT | AnimatedLeaf<T>
    : never
  
  // An animated primitive (or an array of them)
  type AnimatedLeaf<T> =
    | Exclude<T, object | void>
    | Extract<T, ReadonlyArray<number | string>> extends infer U
    ? [U] extends [never]
      ? never
      : FluidValue<U | Exclude<T, object | void>>
    : never
  