X_attachedController_animationControllerssizepixels sizeToPixels isAttached pixelsToSize animateTojumpToreset_assertAttached_attach_onExtentReplaced_detach_disposeAnimationControllersinitialChildSize minChildSize maxChildSizeexpandsnap snapSizessnapAnimationDuration controllershouldCloseOnMinExtentbuilder createStateextent minExtent maxExtent initialExtentcontextdebugFillDescription_cancelActivityminSizemaxSize initialSize _currentSizeavailablePixels hasDragged hasChangedisAtMinisAtMax currentSize currentPixelspixelSnapSizes startActivity addPixelDelta updateSizedisposecopyWith_scrollController_extent initState_impliedSnapSizesdidUpdateWidgetdidChangeDependenciesbuild_replaceExtent_snapSizeErrorMessageonPositionDetachedcreateScrollPositionpositiondetach_dragCancelCallback getExtent_ballisticControllerslistShouldScrollabsorb beginActivityapplyUserOffset_getCurrentSnapSize _isAtSnapSize _shouldSnap goBallisticdragchild _notifier _wasCalled sendReset _sendReset shouldResetvelocity minimumSpeed_pixelSnapSizedxisDonex _getSnapSize ScrollableWidgetBuilderDraggableScrollableControllerDraggableScrollableSheetDraggableScrollableNotification_DraggableSheetExtent_DraggableScrollableSheetState)_DraggableScrollableSheetScrollController'_DraggableScrollableSheetScrollPositionDraggableScrollableActuator!_DraggableScrollableActuatorState_ResetNotifier_InheritedResetNotifier_SnappingSimulation BuildContextScrollControllerAxisscrollController ScrollViewSingleChildScrollViewListViewGridViewWidgetStatebuild ListenableChangeNotifier kFlutterMemoryAllocationsEnabledmaybeDispatchObjectCreationSetAnimationControllerdoubleextent currentSize currentPixels sizeToPixelsScrollPositionbool hasClients pixelsToSizesnapFuture WidgetTester pumpAndSettlevoidDurationCurvedurationzero unboundedvsyncpositioncontextvalueaddgoIdle hasDragged hasChanged startActivity onCanceled isAnimatingstop addListener updateSizenotificationContext animateTo clampDoubleminSizemaxSizecurveinitialChildSizereset _currentSizenotifyListenersonPositionDetached disposeExtentdisposeremoveListeneranimationControllerclear ScrollablejumpToListTileScaffoldScrollBehaviorPointerDeviceKindmouse dragDevicesStatefulWidgetCenterListoverride NotificationNotificationListenerdepthsetStateFloatingActionButtonViewportNotificationMixinStringdebugFillDescription ValueNotifierinfinitydebugMaybeDispatchCreated VoidCallbackmaptoListcall minExtent maxExtent initialExtentshouldCloseOnMinExtentdispatchdebugMaybeDispatchDisposed snapSizessnapAnimationDuration initialSize initStatewidget minChildSize maxChildSize controller_attachintindexlengthisEmptyfirstlastdidUpdateWidget_detachdidChangeDependencies shouldResetValueListenableBuildervalueListenablebuilder LayoutBuilderBoxConstraintsavailablePixels constraintsbiggestheightFractionallySizedBox heightFactor alignment Alignment bottomCenterchildexpandSizedBoxcopyWith_onExtentReplacedWidgetsBindinginstanceaddPostFrameCallback positions elementAt goBallistic debugLabelasMapkeystoStringPrimaryScrollController ScrollPhysics ScrollContextphysicsapplyToAlwaysScrollableScrollPhysics oldPosition getExtent_cancelActivityoffset millisecondsCurveslineardetachScrollActivityViewportScrollPositionWithSingleContextpixelsabsorb_dragCancelCallbackballisticController beginActivityisAtMinisAtMax addPixelDeltaapplyUserOffsetfirstWhereOrNullsnapSizeabs toleranceFordistance SimulationinitialVelocity pixelSnapSizepixelSnapSizes toleranceClampingScrollSimulationvelocityobjectRuntimeTypesign isCompleted animateWithwhenCompleteOrCancelcontainsremoveDragDragStartDetailsdrag"dependOnInheritedWidgetOfExactType _sendResetnotifier hasListenersInheritedNotifier sendResetInheritedWidget _wasCalledinMillisecondsminmax indexWheresize ChangeNotifierStatefulWidget NotificationViewportNotificationMixinStateScrollControllerScrollPositionWithSingleContextInheritedNotifier SimulationcZ¸f 03math3 dart:math="package:collection/collection.dartkpackage:flutter/foundation.dartpackage:flutter/gestures.dart basic.dart binding.dartframework.dart inherited_notifier.dart,layout_builder.dartKnotification_listener.dartqscroll_activity.dartscroll_context.dartscroll_controller.dartscroll_notification.dartscroll_physics.dartscroll_position.dart5(scroll_position_with_single_context.dartiscroll_simulation.dartvalue_listenable_builder.dartdK=ځKx:H@@>@E@@A3AUAWAAABB@BBBBBCC;CBCCCCD<DDDDDE/E2E4EEEEF2F{FG GYGGGH"HrHII]IIJ;JJJKKSKKKLL LBL^LLLLMMAMmMoMMMN N&N(NNNiNkNNNOO O\OOOOPOPPPQQQQKQyQQQRRRRER{RRRSMSRSSST"TAT\TxTTTTU U5ULUcUUUUVVbVVVW4W9W;W]W_WxWWWWX X3X`X{X}XXXY*Y9YYYZ,Z|ZZ[[[>[t[v[[[\6\8\\\]]g]x]]]]]^G^^^__Z___``3`K`c``````a)aIaPaaab<bjbybbbbcccBc[cccccd ddd8dfdkdmddddddee4eMeseeeeff3fLf_f|ffg#gAglgggh hBhJhOhRhThhiiii5iMisiiiij:jgjjkk6k;k=kckkklHlllm mbmlmsmnnEnLnbnnoo&o+o-o:ooopp=pDpdpipkpxpppqq q%q'q4q\qqqrrhrrs)s]s|sssst3t;t@tBtOtctttttuu(u-u/uvuuuv#v=vdvvw wwawwx-xOxxxyyAyyz(zzzz{M{{| |0|;|s|z||||} }n}}}}~ ~k~~~~~i j.z Xt6Op<ACP&F]d38;=wM h (@^egCEy{3BIKy*[<Z+9^ejlPgiv /EJLY4CJ !jM}6d#*,+-^q*}>R~!VJk!\#%2|27:<cG4S~Jcj b#%2F`v{~1Gt(DFx+=BEGU6OVFav}K-W}7Do;=*CT[qvx5q #(*t'V"@PjszCHK^/// @docImport 'package:flutter/material.dart'; /// @docImport 'package:flutter_test/flutter_test.dart'; /// /// @docImport 'primary_scroll_controller.dart'; /// @docImport 'scroll_configuration.dart'; /// @docImport 'scroll_view.dart'; /// @docImport 'scrollable.dart'; /// @docImport 'single_child_scroll_view.dart'; /// @docImport 'viewport.dart';43<j+Jp4h qq/// Controls a [DraggableScrollableSheet]. /// /// Draggable scrollable controllers are typically stored as member variables in /// [State] objects and are reused in each [State.build]. Controllers can only /// be used to control one sheet at a time. A controller can be reused with a /// new sheet if the previous sheet has been disposed. /// /// The controller's methods cannot be used until after the controller has been /// passed into a [DraggableScrollableSheet] and the sheet has run initState. /// /// A [DraggableScrollableController] is a [Listenable]. It notifies its /// listeners whenever an attached sheet changes sizes. It does not notify its /// listeners when a sheet is first attached or when an attached sheet's /// parameters change without affecting the sheet's current size. It does not /// fire when [pixels] changes without [size] changing. For example, if the /// constraints provided to an attached sheet change.ϊ8/// Creates a controller for [DraggableScrollableSheet].>N{{T/// Get the current size (as a fraction of the parent height) of the attached sheet.ـ7/// Get the current pixel height of the attached sheet.Y&/// Returns Whether any [DraggableScrollableController] objects have attached themselves to the /// [DraggableScrollableSheet]. /// /// If this is false, then members that interact with the [ScrollPosition], /// such as [sizeToPixels], [size], [animateTo], and [jumpTo], must not be /// called. ҍS/// Convert a sheet's size (fractional value of parent container height) to pixels. ܐRRY/// Convert a sheet's pixel height to size (fractional value of parent container height)._ gfЉ&& /// Animates the attached sheet from its current size to the given [size], a /// fractional value of the parent container's height. /// /// Any active sheet animation is canceled. If the sheet's internal scrollable /// is currently animating (e.g. responding to a user fling), that animation is /// canceled as well. /// /// An animation will be interrupted whenever the user attempts to scroll /// manually, whenever another activity is started, or when the sheet hits its /// max or min size (e.g. if you animate to 1 but the max size is .8, the /// animation will stop playing when it reaches .8). /// /// The duration must not be zero. To jump to a particular value without an /// animation, use [jumpTo]. /// /// The sheet will not snap after calling [animateTo] even if [DraggableScrollableSheet.snap] /// is true. Snapping only occurs after user drags. /// /// When calling [animateTo] in widget tests, `await`ing the returned /// [Future] may cause the test to hang and timeout. Instead, use /// [WidgetTester.pumpAndSettle].0 87>QPZji  [/// Jumps the attached sheet from its current size to the given [size], a /// fractional value of the parent container's height. /// /// If [size] is outside of a the attached sheet's min or max child size, /// [jumpTo] will jump the sheet to the nearest valid size instead. /// /// Any active sheet animation is canceled. If the sheet's inner scrollable /// is currently animating (e.g. responding to a user fling), that animation is /// canceled as well. /// /// The sheet will not snap after calling [jumpTo] even if [DraggableScrollableSheet.snap] /// is true. Snapping only occurs after user drags.  zzd/// Reset the attached sheet to its initial size (see: [DraggableScrollableSheet.initialChildSize]).ɁӁ:  q?vv$%٥ϥy/// A container for a [Scrollable] that responds to drag gestures by resizing /// the scrollable until a limit is reached, and then scrolling. /// /// {@youtube 560 315 https://www.youtube.com/watch?v=Hgw819mL_78} /// /// This widget can be dragged along the vertical axis between its /// [minChildSize], which defaults to `0.25` and [maxChildSize], which defaults /// to `1.0`. These sizes are percentages of the height of the parent container. /// /// The widget coordinates resizing and scrolling of the widget returned by /// builder as the user drags along the horizontal axis. /// /// The widget will initially be displayed at its initialChildSize which /// defaults to `0.5`, meaning half the height of its parent. Dragging will work /// between the range of minChildSize and maxChildSize (as percentages of the /// parent container's height) as long as the builder creates a widget which /// uses the provided [ScrollController]. If the widget created by the /// [ScrollableWidgetBuilder] does not use the provided [ScrollController], the /// sheet will remain at the initialChildSize. /// /// By default, the widget will stay at whatever size the user drags it to. To /// make the widget snap to specific sizes whenever they lift their finger /// during a drag, set [snap] to `true`. The sheet will snap between /// [minChildSize] and [maxChildSize]. Use [snapSizes] to add more sizes for /// the sheet to snap between. /// /// The snapping effect is only applied on user drags. Programmatically /// manipulating the sheet size via [DraggableScrollableController.animateTo] or /// [DraggableScrollableController.jumpTo] will ignore [snap] and [snapSizes]. /// /// By default, the widget will expand its non-occupied area to fill available /// space in the parent. If this is not desired, e.g. because the parent wants /// to position sheet based on the space it is taking, the [expand] property /// may be set to false. /// /// {@tool dartpad} /// /// This is a sample widget which shows a [ListView] that has 25 [ListTile]s. /// It starts out as taking up half the body of the [Scaffold], and can be /// dragged up to the full height of the scaffold or down to 25% of the height /// of the scaffold. Upon reaching full height, the list contents will be /// scrolled up or down, until they reach the top of the list again and the user /// drags the sheet back down. /// /// On desktop and web running on desktop platforms, dragging to scroll with a mouse is disabled by default /// to align with the natural behavior found in other desktop applications. /// /// This behavior is dictated by the [ScrollBehavior], and can be changed by adding /// [PointerDeviceKind.mouse] to [ScrollBehavior.dragDevices]. /// For more info on this, please refer to https://docs.flutter.dev/release/breaking-changes/default-scroll-behavior-drag /// /// Alternatively, this example illustrates how to add a drag handle for desktop applications. /// /// ** See code in examples/api/lib/widgets/draggable_scrollable_sheet/draggable_scrollable_sheet.0.dart ** /// {@end-tool} ttJ/// Creates a widget that can be dragged and scrolled in a single gesture.  "!4:9IONjpo"*ڳ(ȴδܴϴߴ9&)DJk\K_v|õ} ˁhhw/// The initial fractional value of the parent container's height to use when /// displaying the widget. /// /// Rebuilding the sheet with a new [initialChildSize] will only move /// the sheet to the new value if the sheet has not yet been dragged since it /// was first built or since the last call to [DraggableScrollableActuator.reset]. /// /// The default value is `0.5`.&&/// The minimum fractional value of the parent container's height to use when /// displaying the widget. /// /// The default value is `0.25`.9߀/// The maximum fractional value of the parent container's height to use when /// displaying the widget. /// /// The default value is `1.0`.lXXB/// Whether the widget should expand to fill the available space in its parent /// or not. /// /// In most cases, this should be true. However, in the case of a parent /// widget that will position this one based on its desired size (such as a /// [Center]), this should be set to false. /// /// The default value is true.e@/// Whether the widget should snap between [snapSizes] when the user lifts /// their finger during a drag. /// /// If the user's finger was still moving when they lifted it, the widget will /// snap to the next snap size (see [snapSizes]) in the direction of the drag. /// If their finger was still, the widget will snap to the nearest snap size. /// /// Snapping is not applied when the sheet is programmatically moved by /// calling [DraggableScrollableController.animateTo] or [DraggableScrollableController.jumpTo]. /// /// Rebuilding the sheet with snap newly enabled will immediately trigger a /// snap unless the sheet has not yet been dragged away from /// [initialChildSize] since first being built or since the last call to /// [DraggableScrollableActuator.reset].AIAIU/// A list of target sizes that the widget should snap to. /// /// Snap sizes are fractional values of the parent container's height. They /// must be listed in increasing order and be between [minChildSize] and /// [maxChildSize]. /// /// The [minChildSize] and [maxChildSize] are implicitly included in snap /// sizes and do not need to be specified here. For example, `snapSizes = [.5]` /// will result in a sheet that snaps between [minChildSize], `.5`, and /// [maxChildSize]. /// /// Any modifications to the [snapSizes] list will not take effect until the /// `build` function containing this widget is run again. /// /// Rebuilding with a modified or new list will trigger a snap unless the /// sheet has not yet been dragged away from [initialChildSize] since first /// being built or since the last call to [DraggableScrollableActuator.reset].AYB(B(/// Defines a duration for the snap animations. /// /// If it's not set, then the animation duration is the distance to the snap /// target divided by the velocity of the widget.BD|BBI/// A controller that can be used to programmatically control this sheet.Bǁ"CCӀ/// Whether the sheet, when dragged (or flung) to its minimum size, should /// cause its parent sheet to close. /// /// Set on emitted [DraggableScrollableNotification]s. It is up to parent /// classes to properly read and handle this value.CDD/// The builder that creates a child to display in this widget, which will /// use the provided [ScrollController] to enable dragging and scrolling /// of the contents.D_DDDDE4JAJA/// A [Notification] related to the extent, which is the size, and scroll /// offset, which is the position of the child list, of the /// [DraggableScrollableSheet]. /// /// [DraggableScrollableSheet] widgets notify their ancestors when the size of /// the sheet changes. When the extent of the sheet changes via a drag, /// this notification bubbles up through the tree, which means a given /// [NotificationListener] will receive notifications for all descendant /// [DraggableScrollableSheet] widgets. To focus on notifications from the /// nearest [DraggableScrollableSheet] descendant, check that the [depth] /// property of the notification is zero. /// /// When an extent notification is received by a [NotificationListener], the /// listener will already have completed build and layout, and it is therefore /// too late for that widget to call [State.setState]. Any attempt to adjust the /// build or layout based on an extent notification would result in a layout /// that lagged one frame behind, which is a poor user experience. Extent /// notifications are used primarily to drive animations. The [Scaffold] widget /// listens for extent notifications and responds by driving animations for the /// [FloatingActionButton] as the bottom sheet scrolls up.JKKK/// Creates a notification that the extent of a [DraggableScrollableSheet] has /// changed. /// /// All parameters are required. The [minExtent] must be >= 0. The [maxExtent] /// must be <= 1.0. The [extent] must be between [minExtent] and [maxExtent].KKKKKKLLLL$L3L2LFLULTLb"LhLg%LLLLLLLLLLLLLLLLLLLLLMMLM M#M)M=M1M*M4MHMNMiM]MOM`Mq`MMI/// The current value of the extent, between [minExtent] and [maxExtent].MKNN1/// The minimum value of [extent], which is >= 0.N*<N]N]"/// The maximum value of [extent].NmMNN//// The initially requested value for [extent].N9OO/// The build context of the widget that fired this notification. /// /// This can be used to find the sheet's render objects to determine the size /// of the viewport, for instance. A listener can only assume this context /// is live when it first gets the notification.PPP/// Whether the widget that fired this notification, when dragged (or flung) /// to minExtent, should cause its parent sheet to close. /// /// It is up to parent classes to properly read and handle this value.QQQQ.Q<Q;QQRHT(T(/// Manages state between [_DraggableScrollableSheetState], /// [_DraggableScrollableSheetScrollController], and /// [_DraggableScrollableSheetScrollPosition]. /// /// The State knows the pixels available along the axis the widget wants to /// scroll, but expects to get a fraction of those pixels to render the sheet. /// /// The ScrollPosition knows the number of pixels a user wants to move the sheet. /// /// The [currentSize] will never be null. /// The [availablePixels] will never be null, but may be `double.infinity`.TCTCTCTX T`ToTnT|TTTTTTTTTTTTTTU"U(U'U9U@U?UPUWUVUg"UmUl3UUUUUUUUUUUUUUUUUUUUUVV UV V,VV:V.V=VJVQVKVRV^VSVyViV{VVVVVVVVVVVV W=WKWKWaWnWnWzWWWWWWWWW%WWWWWX!XXX5(XQXQXbXiXiXXXZZZ[ 2[[[@2[I[I[x-[[[=[[[H[[\:]]-/// Start an activity that affects the sheet and register a cancel call back /// that will be called if another activity starts. /// /// The `onCanceled` callback will get called even if the subsequent activity /// started after this one finished, so `onCanceled` must be safe to call at /// any time.] ]]]_%_%/// The scroll position gets inputs in terms of pixels, but the size is /// expected to be expressed as a number between 0..1. /// /// This should only be called to respond to a user drag. To update the /// size in response to a programmatic call, use [updateSize] directly._3 _;_:_A_O_N`aa/// Set the size to the new value. [newSize] should be a number between /// [minSize] and [maxSize]. /// /// This can be triggered by a programmatic (e.g. controller triggered) change /// or a user drag.aaaaaacYccc ccdUddd( d0d/doadtdtdփwddde e ee+e*e8eGeFeQehegeweee(eee$eehTChZhZh@hhh"iii%i&i&iik?kLkLo/8oAoAoQ,ouoto/o0pmpppmpnq)q=q=qCqQqPq)q*tDtVtVtDtEu1Lu6u6uE,uiuh||||||~44/// A [ScrollController] suitable for use in a [ScrollableWidgetBuilder] created /// by a [DraggableScrollableSheet]. /// /// If a [DraggableScrollableSheet] contains content that is exceeds the height /// of its container, this controller will allow the sheet to both be dragged to /// fill the container and then scroll the child content. /// /// See also: /// /// * [_DraggableScrollableSheetScrollPosition], which manages the positioning logic for /// this controller. /// * [PrimaryScrollController], which can be used to establish a /// [_DraggableScrollableSheetScrollController] as the primary controller for /// descendants.|B|| E~~EF AA\kjx сv=nn/// A scroll position that manages scroll activities for /// [_DraggableScrollableSheetScrollController]. /// /// This class is a concrete subclass of [ScrollPosition] logic that handles a /// single [ScrollContext], such as a [Scrollable]. An instance of this class /// manages [ScrollActivity] instances, which changes the /// [_DraggableSheetExtent.currentSize] or visible content offset in the /// [Scrollable]'s [Viewport] /// /// See also: /// /// * [_DraggableScrollableSheetScrollController], which uses this as its [ScrollPosition].À,32DSRi!ww0N*  G0aa }g}~  _+ 32 6Kk}}klN``ltsNO'99>POXfe'(<΃}/// A widget that can notify a descendent [DraggableScrollableSheet] that it /// should reset its position to the initial state. /// /// The [Scaffold] uses this widget to notify a persistent bottom sheet that /// the user has tapped back if the sheet has started to cover more of the body /// than when at its initial position. This is important for users of assistive /// technology, where dragging may be difficult to communicate. /// /// This is just a wrapper on top of [DraggableScrollableController]. It is /// primarily useful for controlling a sheet in a part of the widget tree that /// the current code does not control (e.g. library code trying to affect a sheet /// in library users' code). Generally, it's easier to control the sheet /// directly by creating a controller and passing the controller to the sheet in /// its constructor (see [DraggableScrollableSheet.controller])./// Creates a widget that can notify descendent [DraggableScrollableSheet]s /// to reset to their initial position. /// /// The [child] parameter is required. /// This child's [DraggableScrollableSheet] descendant will be reset when the /// [reset] method is applied to a context that includes it.́/// Notifies any descendant [DraggableScrollableSheet] that it should reset /// to its initial position. /// /// Returns `true` if a [DraggableScrollableActuator] is available and /// some [DraggableScrollableSheet] is listening for updates, `false` /// otherwise.e pd1yy'R99'(/// A [ChangeNotifier] to use with [_InheritedResetNotifier] to notify /// descendants that they should reset to initial state.333A//c/// Whether someone called [sendReset] or not. /// /// This flag should be reset after checking it.<H_/// Fires a reset notification to descendants. /// /// Returns false if there are no listeners.GVMM!]]t/// Creates an [InheritedNotifier] that the [DraggableScrollableSheet] will /// listen to for an indication that it should reset itself back to [DraggableScrollableSheet.initialChildSize].v&+삮/// Specifies whether the [DraggableScrollableSheet] should reset to its /// initial position. /// /// Returns true if the notifier requested a reset, false otherwise.Ӄ+ 1#HG[fe00) q "!zS z{ӁS ۃkDD/// The signature of a method that provides a [BuildContext] and /// [ScrollController] for building a widget that may overflow the draggable /// [Axis] of the containing [DraggableScrollableSheet]. /// /// Users should apply the [scrollController] to a [ScrollView] subclass, such /// as a [SingleChildScrollView], [ListView] or [GridView], to have the whole /// sheet be draggable.s!package:flutter/material.dart&package:flutter_test/flutter_test.dart"primary_scroll_controller.dartTscroll_configuration.dartscroll_view.dartscrollable.dartsingle_child_scroll_view.dart viewport.dart=ځKx:H@@>@E@@A3AUAWAAABB@BBBBBCC;CBCCCCD<DDDDDE/E2E4EEEEF2F{FG GYGGGH"HrHII]IIJ;JJJKKSKKKLL LBL^LLLLMMAMmMoMMMN N&N(NNNiNkNNNOO O\OOOOPOPPPQQQQKQyQQQRRRRER{RRRSMSRSSST"TAT\TxTTTTU U5ULUcUUUUVVbVVVW4W9W;W]W_WxWWWWX X3X`X{X}XXXY*Y9YYYZ,Z|ZZ[[[>[t[v[[[\6\8\\\]]g]x]]]]]^G^^^__Z___``3`K`c``````a)aIaPaaab<bjbybbbbcccBc[cccccd ddd8dfdkdmddddddee4eMeseeeeff3fLf_f|ffg#gAglgggh hBhJhOhRhThhiiii5iMisiiiij:jgjjkk6k;k=kckkklHlllm mbmlmsmnnEnLnbnnoo&o+o-o:ooopp=pDpdpipkpxpppqq q%q'q4q\qqqrrhrrs)s]s|sssst3t;t@tBtOtctttttuu(u-u/uvuuuv#v=vdvvw wwawwx-xOxxxyyAyyz(zzzz{M{{| |0|;|s|z||||} }n}}}}~ ~k~~~~~i j.z Xt6Op<ACP&F]d38;=wM h (@^egCEy{3BIKy*[<Z+9^ejlPgiv /EJLY4CJ !jM}6d#*,+-^q*}>R~!VJk!\#%2|27:<cG4S~Jcj b#%2F`v{~1Gt(DFx+=BEGU6OVFav}K-W}7Do;=*CT[qvx5q #(*t'V"@PjszCHK DraggableScrollableControllerDraggableScrollableSheetDraggableScrollableNotification_DraggableSheetExtent_DraggableScrollableSheetState)_DraggableScrollableSheetScrollController'_DraggableScrollableSheetScrollPositionDraggableScrollableActuator!_DraggableScrollableActuatorState_ResetNotifier_InheritedResetNotifier_SnappingSimulation\