7forwardreversenormalpreserve lowerBound upperBound debugLabelanimationBehaviorviewdurationreverseDuration_tickerresync _simulationvalue_valueresetvelocity_internalSetValuelastElapsedDuration_lastElapsedDuration isAnimating _directionstatus_statustoggle animateTo animateBack_animateToInternalrepeat_directionSetterfling animateWithanimateBackWith_startSimulationstopdispose_lastReportedStatus_checkStatusChanged_ticktoStringDetails_durationInSeconds_begin_end_curvexdxisDoneminmaxcountdirectionSetter_periodInSeconds _initialT_exitTimeInSeconds_AnimationDirection_kFlingSpringDescription_kFlingToleranceAnimationBehaviorAnimationController_InterpolationSimulation_DirectionSetter_RepeatingSimulationq lerpDouble SimulationSpringDescription TickerFutureTickerProvider AnimationAnimationStatusCurvewithDampingRatiomass stiffness TolerancevelocitydoubleinfinitydistanceAccessibilityFeaturesdisableAnimationspreserveState TickerModeTickerSingleTickerProviderStateMixinStatefulWidget initStatedisposeFutureorCanceldidUpdateWidgetTickerCanceledmountedSlideTransitiondurationTweenAnimationEagerListenerMixinAnimationLocalListenersMixin"AnimationLocalStatusListenersMixintoStringnormalforwarddebugMaybeDispatchCreatedvsync createTickernegativeInfinityStringnew unboundedDurationvoid absorbTickeroverridenotifyListenersdxinMicrosecondstoDoublemicrosecondsPerSecond clampDouble dismissed completedreversemuted isAnimatingboolisActivefrom FlutterErrorisForwardOrCompletedCurveslinearcurveSemanticsBindinginstanceisFiniteabszerocompleteminmaxcountintperiodspringDescription SpringTypecriticallyDamped overDamped underDampedanimationBehaviorSpringSimulation tolerancetypexstartstopcanceled fromPartsDiagnosticsNode ErrorSummaryErrorDescription runtimeTypeDiagnosticsPropertystyleDiagnosticsTreeStyle errorPropertydebugMaybeDispatchDisposedclearStatusListenersclearListenersnotifyStatusListenersisDonetoStringDetailstoStringAsFixed transformtimeisOdd AnimationAnimationEagerListenerMixinAnimationLocalListenersMixin"AnimationLocalStatusListenersMixin Simulationp[.üݳ Jm SimulationSpringDescriptionGpackage:flutter/physics.dart TickerFutureTickerProviderpackage:flutter/scheduler.dart AnimationAnimationStatusanimation.dart/9Curve curves.dart6E lerpDouble 03ui3dart:uiKpackage:flutter/foundation.dartvpackage:flutter/physics.dartpackage:flutter/scheduler.dartpackage:flutter/semantics.dartanimation.dart curves.dart%listener_helpers.dartk*=فHJuǁ $EGނ<>W̃*F}̈́ل܄ޅ6DY]_jTotƈhEL(58:^c\#(zˍO66ЏՐ^ Z;@sxēd+0&u SdivזܖBINɗΗߗAИ(Ybgxʙәؙ9BIRcx}ś(Zgݛ;U4v͟ QՠI .3ݡ 4b?F OV>ɥݥ ">Zeè$\c"){ǩFЪ.Re[wyĮ$&{SҰ$^ıg~αղ%9WYmoӲ%LQSoqEĴ۴ݵ%7>9@)0AH2Z?Wsxzɺrƻ 'v_@Wp %'T޿2@g@@R@@@AA:A<AAAB6BBBCCbCCCCD!D#D0DZD{D}DDEEEnEEEF2FtF{FGGAGkG|GGHHfHHHHHHHIAIIIIIIJ)J.J0JyJJJK*K@KGKKL0L7LLLM'M8MrMMNeNNNNNNNO@OOOOOOP(P-P/PPPQ;QQQQRRTRRSS$SOSrSSSST+TTTTTTTUUdUUV V9VNVUVVVVVVWQWXWWXXUXXXY7Y{YYYZ@Z\ZZ[[ [[\G\w\\\\\\]&]v]~]]]]^R^Y^^__V___`8`|```aAa]aab!b>bc ccccccdddtdddeEeJeLepeeeeffdfg grggh4h<hjhhhiiTi{iijjDjjjkk7kckkkkkl/lKlTllllm%m,m]mxmmmmmn;nlnsnooodopp2p9ppq9q@qqqr;rrrssdssssstt&t.tGt`tztttu1uuvv#v,v@vKvdvvvwwwwwwwwxx;x_x{xxxxxyFyyzz zTzz{E{j{q{{||R|Y|}}B}Z}v}}}~ ~g~~~Ky)ow(5gS-4yQXU%6= d"')z<V]nu,D0Z_aFy+02W^X29JQ!Sz@Ha'.$8IgK'4=Q\ Nn"')Kp]9@Xty{BZk-V[^`#!r 2^df,= f'>S~!EhjDFn<CHJW'Yg/// @docImport 'package:flutter/widgets.dart'; /// @docImport 'package:flutter_test/flutter_test.dart';436EJu $Gmۂ/9:"/// A controller for an animation. /// /// This class lets you perform tasks such as: /// /// * Play an animation [forward] or in [reverse], or [stop] an animation. /// * Set the animation to a specific [value]. /// * Define the [upperBound] and [lowerBound] values of an animation. /// * Create a [fling] animation effect using a physics simulation. /// /// By default, an [AnimationController] linearly produces values that range /// from 0.0 to 1.0, during a given duration. /// /// When the animation is actively animating, the animation controller generates /// a new value each time the device running your app is ready to display a new /// frame (typically, this rate is around 60–120 values per second). /// If the animation controller is associated with a [State] /// through a [TickerProvider], then its updates will be silenced when that /// [State]'s subtree is disabled as defined by [TickerMode]; time will still /// elapse, and methods like [forward] and [stop] can still be called and /// will change the value, but the controller will not generate new values /// on its own. /// /// ## Ticker providers /// /// An [AnimationController] needs a [TickerProvider], which is configured using /// the `vsync` argument on the constructor. /// The constructor uses the [TickerProvider] to create a [Ticker], which /// the [AnimationController] uses to step through the animation it controls. /// /// For advice on obtaining a ticker provider, see [TickerProvider]. /// Typically the relevant [State] serves as the ticker provider, /// after applying a suitable mixin (like [SingleTickerProviderStateMixin]) /// to cause the [State] subclass to implement [TickerProvider]. /// /// ## Life cycle /// /// An [AnimationController] should be [dispose]d when it is no longer needed. /// This reduces the likelihood of leaks. When used with a [StatefulWidget], it /// is common for an [AnimationController] to be created in the /// [State.initState] method and then disposed in the [State.dispose] method. /// /// ## Using [Future]s with [AnimationController] /// /// The methods that start animations return a [TickerFuture] object which /// completes when the animation completes successfully, and never throws an /// error; if the animation is canceled, the future never completes. This object /// also has a [TickerFuture.orCancel] property which returns a future that /// completes when the animation completes successfully, and completes with an /// error when the animation is aborted. /// /// This can be used to write code such as the `fadeOutAndUpdateState` method /// below. /// /// {@tool snippet} /// /// Here is a stateful `Foo` widget. Its [State] uses the /// [SingleTickerProviderStateMixin] to implement the necessary /// [TickerProvider], creating its controller in the [State.initState] method /// and disposing of it in the [State.dispose] method. The duration of the /// controller is configured from a property in the `Foo` widget; as that /// changes, the [State.didUpdateWidget] method is used to update the /// controller. /// /// ```dart /// class Foo extends StatefulWidget { /// const Foo({ super.key, required this.duration }); /// /// final Duration duration; /// /// @override /// State createState() => _FooState(); /// } /// /// class _FooState extends State with SingleTickerProviderStateMixin { /// late AnimationController _controller; /// /// @override /// void initState() { /// super.initState(); /// _controller = AnimationController( /// vsync: this, // the SingleTickerProviderStateMixin /// duration: widget.duration, /// ); /// } /// /// @override /// void didUpdateWidget(Foo oldWidget) { /// super.didUpdateWidget(oldWidget); /// _controller.duration = widget.duration; /// } /// /// @override /// void dispose() { /// _controller.dispose(); /// super.dispose(); /// } /// /// @override /// Widget build(BuildContext context) { /// return Container(); // ... /// } /// } /// ``` /// {@end-tool} /// {@tool snippet} /// /// The following method (for a [State] subclass) drives two animation /// controllers using Dart's asynchronous syntax for awaiting [Future] objects: /// /// ```dart /// Future fadeOutAndUpdateState() async { /// try { /// await fadeAnimationController.forward().orCancel; /// await sizeAnimationController.forward().orCancel; /// setState(() { /// dismissed = true; /// }); /// } on TickerCanceled { /// // the animation got canceled, probably because we were disposed /// } /// } /// ``` /// {@end-tool} /// /// The assumption in the code above is that the animation controllers are being /// disposed in the [State] subclass' override of the [State.dispose] method. /// Since disposing the controller cancels the animation (raising a /// [TickerCanceled] exception), the code here can skip verifying whether /// [State.mounted] is still true at each step. (Again, this assumes that the /// controllers are created in [State.initState] and disposed in /// [State.dispose], as described in the previous section.) /// /// {@tool dartpad} /// This example shows how to use [AnimationController] and /// [SlideTransition] to create an animated digit like you might find /// on an old pinball machine our your car's odometer. New digit /// values slide into place from below, as the old value slides /// upwards and out of view. Taps that occur while the controller is /// already animating cause the controller's /// [AnimationController.duration] to be reduced so that the visuals /// don't fall behind. /// /// ** See code in examples/api/lib/animation/animation_controller/animated_digit.0.dart ** /// {@end-tool} /// /// See also: /// /// * [Tween], the base class for converting an [AnimationController] to a /// range of values of other types.d[/// Creates an animation controller. /// /// * `value` is the initial value of the animation. If defaults to the lower /// bound. /// /// * [duration] is the length of time this animation should last. /// /// * [debugLabel] is a string to help identify this animation during /// debugging (used by [toString]). /// /// * [lowerBound] is the smallest value this animation can obtain and the /// value at which this animation is deemed to be dismissed. /// /// * [upperBound] is the largest value this animation can obtain and the /// value at which this animation is deemed to be completed. /// /// * `vsync` is the required [TickerProvider] for the current context. It can /// be changed by calling [resync]. See [TickerProvider] for advice on /// obtaining a ticker provider.  &,+BHG^1dc8TwæܦϦĦҦń쪯ªÂ/// Creates an animation controller with no upper or lower bound for its /// value. /// /// * [value] is the initial value of the animation. /// /// * [duration] is the length of time this animation should last. /// /// * [debugLabel] is a string to help identify this animation during /// debugging (used by [toString]). /// /// * `vsync` is the required [TickerProvider] for the current context. It can /// be changed by calling [resync]. See [TickerProvider] for advice on /// obtaining a ticker provider. /// /// This constructor is most useful for animations that will be driven using a /// physics simulation, especially when the physics simulation has no /// pre-determined bounds. "!2KJV3\[o̫Ϋԫի [@/// The value at which this animation is deemed to be dismissed.[jj@/// The value at which this animation is deemed to be completed.{/// A label that is used in the [toString] output. Intended to aid with /// identifying animation controller instances in debug output.(Vmm/// The behavior of the controller when [AccessibilityFeatures.disableAnimations] /// is true. /// /// Defaults to [AnimationBehavior.normal] for the [AnimationController.new] /// constructor, and [AnimationBehavior.preserve] for the /// [AnimationController.unbounded] constructor.ss/// The length of time this animation should last. /// /// If [reverseDuration] is specified, then [duration] is only used when going /// [forward]. Otherwise, it specifies the duration going in both directions.ҲEE/// The length of time this animation should last when going in [reverse]. /// /// The value of [duration] is used if [reverseDuration] is not specified or /// set to null.[ccUaaAA#A#DDDD\DqDq ?2ABvv/// Returns an [Animation] for this animation controller, so that a /// pointer to this object can be passed around without allowing users of that /// pointer to mutate the [AnimationController] state.sO/// The current value of the animation. /// /// Setting this value notifies all the listeners that the value /// changed. /// /// Setting this value also stops the controller if it is currently /// running; if this happens, it also notifies all the status /// listeners.hdd/// The rate of change of [value] per second. /// /// If [isAnimating] is false, then [value] is not changing and the rate of /// change is zero.@@@/// The amount of time that has passed between the time the animation started /// and the most recent tick of the animation. /// /// If the controller is not animating, the last elapsed duration is null.A>CCƂS/// Whether this animation is currently animating in either the forward or reverse direction. /// /// This is separate from whether it is actively ticking. An animation /// controller's ticker might get muted, in which case the animation /// controller's callbacks will no longer fire even though time is continuing /// to pass. See [Ticker.muted] and [TickerMode]. /// /// If the animation was stopped (e.g. with [stop] or by setting a new [value]), /// [isAnimating] will return `false` but the [status] will not change, /// so the value of [AnimationStatus.isAnimating] might still be `true`.CCD%3DFDFD%D&߄/// Stops the animation controller and sets the current value of the /// animation. /// /// The new value is clamped to the range set by [lowerBound] and /// [upperBound]. /// /// Value listeners are notified even if this does not change the value. /// Status listeners are notified if the animation was previously playing. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error. /// /// See also: /// /// * [reset], which is equivalent to setting [value] to [lowerBound]. /// * [stop], which aborts the animation without changing its value or status /// and without dispatching any notifications other than completing or /// canceling the [TickerFuture]. /// * [forward], [reverse], [animateTo], [animateWith], [animateBackWith], /// [fling], and [repeat], which start the animation controller.q޲9/// Recreates the [Ticker] with the new [TickerProvider].|9/// Sets the controller's value to [lowerBound], stopping the animation (if /// in progress), and resetting to its beginning point, or dismissed state. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error. /// /// See also: /// /// * [value], which can be explicitly set to a specific value as desired. /// * [forward], which starts the animation in the forward direction. /// * [stop], which aborts the animation without changing its value or status /// and without dispatching any notifications other than completing or /// canceling the [TickerFuture].)Ծ..@HGDGPGP/// Starts running this animation forwards (towards the end). /// /// Returns a [TickerFuture] that completes when the animation is complete. /// /// If [from] is non-null, it will be set as the current [value] before running /// the animation. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error. /// /// During the animation, [status] is reported as [AnimationStatus.forward], /// which switches to [AnimationStatus.completed] when [upperBound] is /// reached at the end of the animation.GY GbGaJ2M M /// Starts running this animation in reverse (towards the beginning). /// /// Returns a [TickerFuture] that completes when the animation is dismissed. /// /// If [from] is non-null, it will be set as the current [value] before running /// the animation. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error. /// /// During the animation, [status] is reported as [AnimationStatus.reverse], /// which switches to [AnimationStatus.dismissed] when [lowerBound] is /// reached at the end of the animation.M MMP1RR/// Toggles the direction of this animation, based on whether it [isForwardOrCompleted]. /// /// Specifically, this function acts the same way as [reverse] if the [status] is /// either [AnimationStatus.forward] or [AnimationStatus.completed], and acts as /// [forward] for [AnimationStatus.reverse] or [AnimationStatus.dismissed]. /// /// If [from] is non-null, it will be set as the current [value] before running /// the animation. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error.S S S WZkZk-/// Drives the animation from its current value to the given target, "forward". /// /// Returns a [TickerFuture] that completes when the animation is complete. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error. /// /// During the animation, [status] is reported as [AnimationStatus.forward] /// regardless of whether `target` > [value] or not. At the end of the /// animation, when `target` is reached, [status] is reported as /// [AnimationStatus.completed]. /// /// If the `target` argument is the same as the current [value] of the /// animation, then this won't animate, and the returned [TickerFuture] will /// be already complete.Zu Z}Z|ZZZZZZZZZ^Halal./// Drives the animation from its current value to the given target, "backward". /// /// Returns a [TickerFuture] that completes when the animation is complete. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error. /// /// During the animation, [status] is reported as [AnimationStatus.reverse] /// regardless of whether `target` < [value] or not. At the end of the /// animation, when `target` is reached, [status] is reported as /// [AnimationStatus.dismissed]. /// /// If the `target` argument is the same as the current [value] of the /// animation, then this won't animate, and the returned [TickerFuture] will /// be already complete.ax aaaaaaaaaaaeNe[e[et e|e{eeeeeeeeemssb/// Starts running this animation in the forward direction, and /// restarts the animation when it completes. /// /// Defaults to repeating between the [lowerBound] and [upperBound] of the /// [AnimationController] when no explicit value is set for [min] and [max]. /// /// With [reverse] set to true, instead of always starting over at [min] /// the starting value will alternate between [min] and [max] values on each /// repeat. The [status] will be reported as [AnimationStatus.reverse] when /// the animation runs from [max] to [min]. /// /// Each run of the animation will have a duration of `period`. If `period` is not /// provided, [duration] will be used instead, which has to be set before [repeat] is /// called either in the constructor or later by using the [duration] setter. /// /// If a value is passed to [count], the animation will perform that many /// iterations before stopping. Otherwise, the animation repeats indefinitely. /// /// Returns a [TickerFuture] that never completes, unless a [count] is specified. /// The [TickerFuture.orCancel] future completes with an error when the animation is /// stopped (e.g. with [stop]). /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error.s sss ssssstt t t ttswwwwwwxf}Q}Q}/// Drives the animation with a spring (within [lowerBound] and [upperBound]) /// and initial velocity. /// /// If velocity is positive, the animation will complete, otherwise it will /// dismiss. The velocity is specified in units per second. If the /// [SemanticsBinding.disableAnimations] flag is set, the velocity is somewhat /// arbitrarily multiplied by 200. /// /// The [springDescription] parameter can be used to specify a custom /// [SpringType.criticallyDamped] or [SpringType.overDamped] spring with which /// to drive the animation. By default, a [SpringType.criticallyDamped] spring /// is used. See [SpringDescription.withDampingRatio] for how to create a /// suitable [SpringDescription]. /// /// The resulting spring simulation cannot be of type [SpringType.underDamped]; /// such a spring would oscillate rather than fling. /// /// Returns a [TickerFuture] that completes when the animation is complete. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error.}^}f}e}z$}}}$}}}p5/// Drives the animation according to the given simulation. /// /// {@template flutter.animation.AnimationController.animateWith} /// The values from the simulation are clamped to the [lowerBound] and /// [upperBound]. To avoid this, consider creating the [AnimationController] /// using the [AnimationController.unbounded] constructor. /// /// Returns a [TickerFuture] that completes when the animation is complete. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error. /// {@endtemplate} /// /// The [status] is always [AnimationStatus.forward] for the entire duration /// of the simulation. /// /// See also: /// /// * [animateBackWith], which is like this method but the status is always /// [AnimationStatus.reverse].+2/// Drives the animation according to the given simulation with a [status] of /// [AnimationStatus.reverse]. /// /// {@macro flutter.animation.AnimationController.animateWith} /// /// The [status] is always [AnimationStatus.reverse] for the entire duration /// of the simulation. /// /// See also: /// /// * [animateWith], which is like this method but the status is always /// [AnimationStatus.forward].cpp4zZZ/// Stops running this animation. /// /// This does not trigger any notifications. The animation stops in its /// current state. /// /// By default, the most recently returned [TickerFuture] is marked as having /// been canceled, meaning the future never completes and its /// [TickerFuture.orCancel] derivative future completes with a [TickerCanceled] /// error. By passing the `canceled` argument with the value false, this is /// reversed, and the futures complete successfully. /// /// See also: /// /// * [reset], which stops the animation and resets it to the [lowerBound], /// and which does send notifications. /// * [forward], [reverse], [animateTo], [animateWith], [fling], and [repeat], /// which restart the animation controller.`fepR++R/// Release the resources used by this object. The object is no longer usable /// after this method is called. /// /// The most recently returned [TickerFuture], if any, is marked as having been /// canceled, meaning the future never completes and its [TickerFuture.orCancel] /// derivative future completes with a [TickerCanceled] error.PUU+L006@?}}~`ff     <)`>^W?GHYbjk ! Uf=ll`  0 65;CIdXPJSa[cf%c'aT(RM)4K5CHOV`[W]vw}~  !!)44@KKU&llN0**,43LO``ckjLM//3/// The direction in which an animation is running.H>3/// The animation is running from beginning to end.I>/// The animation is running backwards, from end to beginning.{mm/// Configures how an [AnimationController] behaves when animations are /// disabled. /// /// When [AccessibilityFeatures.disableAnimations] is true, the device is asking /// Flutter to reduce or disable animations as much as possible. To honor this, /// we reduce the duration and the corresponding number of frames for /// animations. This enum is used to allow certain [AnimationController]s to opt /// out of this behavior. /// /// For example, the [AnimationController] which controls the physics simulation /// for a scrollable list will have [AnimationBehavior.preserve], so that when /// a user attempts to scroll it does not jump to the end/beginning too quickly.r/// The [AnimationController] will reduce its duration when /// [AccessibilityFeatures.disableAnimations] is true. (**/// The [AnimationController] will preserve its behavior. /// /// This is the default for repeating animations in order to prevent them from /// flashing rapidly on the screen if the widget does not take the /// [AccessibilityFeatures.disableAnimations] flag into account.H""CXW| "#3Y<8>OFQ_Woo package:flutter/widgets.dart&package:flutter_test/flutter_test.dart*=فHJuǁ $EGނ<>W̃*F}̈́ل܄ޅ6DY]_jTotƈhEL(58:^c\#(zˍO66ЏՐ^ Z;@sxēd+0&u SdivזܖBINɗΗߗAИ(Ybgxʙәؙ9BIRcx}ś(Zgݛ;U4v͟ QՠI .3ݡ 4b?F OV>ɥݥ ">Zeè$\c"){ǩFЪ.Re[wyĮ$&{SҰ$^ıg~αղ%9WYmoӲ%LQSoqEĴ۴ݵ%7>9@)0AH2Z?Wsxzɺrƻ 'v_@Wp %'T޿2@g@@R@@@AA:A<AAAB6BBBCCbCCCCD!D#D0DZD{D}DDEEEnEEEF2FtF{FGGAGkG|GGHHfHHHHHHHIAIIIIIIJ)J.J0JyJJJK*K@KGKKL0L7LLLM'M8MrMMNeNNNNNNNO@OOOOOOP(P-P/PPPQ;QQQQRRTRRSS$SOSrSSSST+TTTTTTTUUdUUV V9VNVUVVVVVVWQWXWWXXUXXXY7Y{YYYZ@Z\ZZ[[ [[\G\w\\\\\\]&]v]~]]]]^R^Y^^__V___`8`|```aAa]aab!b>bc ccccccdddtdddeEeJeLepeeeeffdfg grggh4h<hjhhhiiTi{iijjDjjjkk7kckkkkkl/lKlTllllm%m,m]mxmmmmmn;nlnsnooodopp2p9ppq9q@qqqr;rrrssdssssstt&t.tGt`tztttu1uuvv#v,v@vKvdvvvwwwwwwwwxx;x_x{xxxxxyFyyzz zTzz{E{j{q{{||R|Y|}}B}Z}v}}}~ ~g~~~Ky)ow(5gS-4yQXU%6= d"')z<V]nu,D0Z_aFy+02W^X29JQ!Sz@Ha'.$8IgK'4=Q\ Nn"')Kp]9@Xty{BZk-V[^`#!r 2^df,= f'>S~!EhjDFn<CHJW'Y_AnimationDirection_kFlingSpringDescription_kFlingToleranceAnimationBehaviorAnimationController_InterpolationSimulation_RepeatingSimulation1flutter.animation.AnimationController.animateWithThe values from the simulation are clamped to the [lowerBound] and [upperBound]. To avoid this, consider creating the [AnimationController] using the [AnimationController.unbounded] constructor. Returns a [TickerFuture] that completes when the animation is complete. The most recently returned [TickerFuture], if any, is marked as having been canceled, meaning the future never completes and its [TickerFuture.orCancel] derivative future completes with a [TickerCanceled] error.*