/copyWithbundledevicePixelRatiolocale textDirectionsizeplatformempty==hashCodetoStringresolve createStreamobtainCacheStatus_createErrorHandlerAndKeyresolveStreamForKeyevict obtainKey loadBuffer loadImagenamescale _loadAsync_providerCacheKey_policy_width_height_allowUpscalingexactfit imageProviderwidthheightpolicyallowUpscalingresizeIfNeeded_configureErrorListenerurlheadersfilebytes assetNamekeyNamepackage statusCode_messageuri_KeyAndErrorHandlerCallback_AsyncKeyErrorHandlerImageConfigurationDecoderBufferCallback_SimpleDecoderCallbackImageDecoderCallback ImageProvider_AbstractImageStreamCompleterAssetBundleImageKeyAssetBundleImageProviderResizeImageKeyResizeImagePolicy ResizeImage NetworkImage FileImage MemoryImageExactAssetImage_ErrorImageCompleterNetworkImageLoadExceptiondartlibraryjs_util_createErrorHandlerAndKeyvoidTImageErrorListenerFutureObject StackTraceresolvecreateLocalImageConfigurationWidget immutable AssetBundledoubleLocale TextDirectionSizeTargetPlatformbundledevicePixelRatiolocale textDirectionsizeplatformoverridebool runtimeTypeinthashString StringBufferwritetoStringAsFixednametoString loadBuffer DeprecatedCodecImmutableBuffer loadImageTargetImageSizeCallback ImageStream imageCache==hashCode ImageCache nonVirtualwidgetsImageoptionalTypeArgskey errorHandlerInformationCollectorDiagnosticsNodeDiagnosticsProperty defaultValue completer setCompleter reportError exceptionstackcontextErrorDescriptionsilentinformationCollector protectedImageCacheStatus untracked FlutterErroronError Completer configurationcompletePaintingBindinginstance statusForKey handleErrorFlutterErrorDetailsfutureerror stackTracethen catchErrorZone putIfAbsentImageStreamCompleter identicalinstantiateImageCodecWithSizeinstantiateImageCodecFromBuffercacheemptyevictSynchronousFutureobjectRuntimeType AssetImageload ImageInfoscale obtainKeyMultiFrameImageStreamCompletercodecdecode debugLabel_providerCacheKey_policy_width_height_allowUpscalingpolicywidthheightBoxFitfillfitWidth fitHeightallowUpscalingexactcontainfit FlutterView cacheWidth cacheHeight kReleaseMode getTargetSize targetWidthintrinsicWidth targetHeightintrinsicHeightTargetImageSizemaxWidth aspectRatio maxHeightfloorminaddEphemeralErrorListenerscheduleMicrotask_networkMap HttpClientgetFilefilepathlength StateError fromFilePath fromUint8List readAsBytes Uint8ListmemorydescribeIdentitybytesasset rootBundlekeyName ExceptionUriImageStreamCompleter ImageProviderAssetBundleImageProvider Exception^-s $3Q4$f  dart:async+dart:io=OmathR dart:mathYiuildart:uiqpackage:flutter/foundation.dartpackage:flutter/services.dartdart.library.js_util_network_image_web.dart network_image_network_image_io.dart, binding.dartCimage_cache.dart^image_stream.dartF<ۀ܁ *msPAfm߽)| I_@7@@@@@AKAxAAAAAAABBBBlBBBCCLCyCCCCDDD&D=DVDDDDDDDEE&E4E:EWEpE|EEEEFFF F`FfFGGXGGGHHaHHHIIkIIIJRJJK:K^KKKL LLHLVL\LLLM=MMN1NNNOJOTOkOtOOOOOOOPPPcPrPxPQQ'Q-QsQyQQQQQR?RRRRRRSS"S(SBSHSZSSSSSTTJTeTTTTTTTULUfUUUUV V=VCVVW(WxWWWX<XXYYYPY]YcYYYZZZZZlZyZZZZ[<[h[l[m[[[\!\p\\\]A]N]T]d]j]^^^c^^^^^^^_@___```Y`d```aaa2a8a9aqawaabb bTbbbbbbbccJc^cdcccccccd6d7dCdddeeeUeefHffffgg?gOgzgh hh*h4h_hhhhhhhiAiNiZiiijjYjjjjjkk4kPkwk~kkkkkl&l3lRlqlllmm\mfmmmmmnnn n!nKnOnnnooMoooppp/pMpNpZp}ppppqqBqdqqqqqr/r1r2rarerrssGs{ssttbttuuRuuv vv_vwwPwwwwwx:xxxxxxxyy yyy*yCyjy~yyyyyyyz=zCzOz[zfzqzwzzzzzzzz{{{{{{{{{{{| |!|)|3|9|E|P|V|||||}}}}-}T}h}}}}}}}}~'~-~9~E~P~[~a~o~~~~~~~~~nt #/:@>Rg.4@LWbhv /MU_eq| $-.}?A .DP[flz ".9?:au}$0<GRXf:Ncku{ )4?ESlw}&;CMS_jp ,El  0Dbjtz (3>DRk!48y}Lsw Qpt<IO+1n :;lTZ'IJcCjpL6osCQ'0 $27@'(KN^lm-g-S1?@bDj QJT^deGMz?g&P]|(08Rhn5RVXYF-pt.j Y2w#56w+OP\ _jn al7JK $%1‚­IyÂÉÍÎÚç!OgĈĽ!6boň$AyƬ.zǀǦ9=>Jmșȭȳ+`am4EIʔ1ˀ˪ˮ˼V̝S͚͠ͰͶ JP`fδ-^bco4LЍДИЙХ!OgѨѯѳѴ#<~҂҃ҏҲ8Y]^jӤӥӱ578ԉԍ mչO֜$(4AOiqu׺׾/3MQؠ/;ىّ١٥ `ڭ<ۅ-U}܁RZ^ݩݭݻݿ0;t޿dߏߕ5Oh~AnU["(xNghtCXltxy6Vy}~acd'^ TU#DF./// @docImport 'package:flutter/widgets.dart'; *s/// The preferred [AssetBundle] to use if the [ImageProvider] needs one and /// does not have one already selected.IZ9/// The device pixel ratio where the image will be shown.T:/// The language and region for which to select the image.maH/// The reading direction of the language for which to select the image.sD1/// The size at which the image will be rendered.р/// The [TargetPlatform] for which assets should be used. This allows images /// to be specified in a platform-neutral fashion yet use different assets on /// different platforms, to match local conventions e.g. for color matching or /// shadows.ހ̍/// An image configuration that provides no additional information. /// /// Useful when resolving an [ImageProvider] without any context.?^S?@Çŀ/// Creates an object holding the configuration information for an [ImageProvider]. /// /// All the arguments are optional. Configuration information is merely /// advisory and best-effort. "2D KTe cd8E/// Identifies an image without committing to the precise final asset. This /// allows a set of images to be identified and for the precise image to later /// be resolved based on the environment, e.g. the device pixel ratio. /// /// To obtain an [ImageStream] from an [ImageProvider], call [resolve], /// passing it an [ImageConfiguration] object. /// /// [ImageProvider] uses the global [imageCache] to cache images. /// /// The type argument `T` is the type of the object used to represent a resolved /// configuration. This is also the type used for the key in the image cache. It /// should be immutable and implement the [==] operator and the [hashCode] /// getter. Subclasses should subclass a variant of [ImageProvider] with an /// explicit `T` type argument. /// /// The type argument does not have to be specified when using the type as an /// argument (where any image provider is acceptable). /// /// The following image formats are supported: {@macro dart.ui.imageFormats} /// /// ## Lifecycle of resolving an image /// /// The [ImageProvider] goes through the following lifecycle to resolve an /// image, once the [resolve] method is called: /// /// 1. Create an [ImageStream] using [createStream] to return to the caller. /// This stream will be used to communicate back to the caller when the /// image is decoded and ready to display, or when an error occurs. /// 2. Obtain the key for the image using [obtainKey]. /// Calling this method can throw exceptions into the zone asynchronously /// or into the call stack synchronously. To handle that, an error handler /// is created that catches both synchronous and asynchronous errors, to /// make sure errors can be routed to the correct consumers. /// The error handler is passed on to [resolveStreamForKey] and the /// [ImageCache]. /// 3. If the key is successfully obtained, schedule resolution of the image /// using that key. This is handled by [resolveStreamForKey]. That method /// may fizzle if it determines the image is no longer necessary, use the /// provided [ImageErrorListener] to report an error, set the completer /// from the cache if possible, or call [loadImage] to fetch the encoded image /// bytes and schedule decoding. /// 4. The [loadImage] method is responsible for both fetching the encoded bytes /// and decoding them using the provided [ImageDecoderCallback]. It is called /// in a context that uses the [ImageErrorListener] to report errors back. /// /// Subclasses normally only have to implement the [loadImage] and [obtainKey] /// methods. A subclass that needs finer grained control over the [ImageStream] /// type must override [createStream]. A subclass that needs finer grained /// control over the resolution, such as delaying calling [loadImage], must override /// [resolveStreamForKey]. /// /// The [resolve] method is marked as [nonVirtual] so that [ImageProvider]s can /// be properly composed, and so that the base class can properly set up error /// handling for subsequent methods. /// /// ## Using an [ImageProvider] /// /// {@tool snippet} /// /// The following shows the code required to write a widget that fully conforms /// to the [ImageProvider] and [Widget] protocols. (It is essentially a /// bare-bones version of the [widgets.Image] widget.) /// /// ```dart /// class MyImage extends StatefulWidget { /// const MyImage({ /// super.key, /// required this.imageProvider, /// }); /// /// final ImageProvider imageProvider; /// /// @override /// State createState() => _MyImageState(); /// } /// /// class _MyImageState extends State { /// ImageStream? _imageStream; /// ImageInfo? _imageInfo; /// /// @override /// void didChangeDependencies() { /// super.didChangeDependencies(); /// // We call _getImage here because createLocalImageConfiguration() needs to /// // be called again if the dependencies changed, in case the changes relate /// // to the DefaultAssetBundle, MediaQuery, etc, which that method uses. /// _getImage(); /// } /// /// @override /// void didUpdateWidget(MyImage oldWidget) { /// super.didUpdateWidget(oldWidget); /// if (widget.imageProvider != oldWidget.imageProvider) { /// _getImage(); /// } /// } /// /// void _getImage() { /// final ImageStream? oldImageStream = _imageStream; /// _imageStream = widget.imageProvider.resolve(createLocalImageConfiguration(context)); /// if (_imageStream!.key != oldImageStream?.key) { /// // If the keys are the same, then we got the same image back, and so we don't /// // need to update the listeners. If the key changed, though, we must make sure /// // to switch our listeners to the new image stream. /// final ImageStreamListener listener = ImageStreamListener(_updateImage); /// oldImageStream?.removeListener(listener); /// _imageStream!.addListener(listener); /// } /// } /// /// void _updateImage(ImageInfo imageInfo, bool synchronousCall) { /// setState(() { /// // Trigger a build whenever the image changes. /// _imageInfo?.dispose(); /// _imageInfo = imageInfo; /// }); /// } /// /// @override /// void dispose() { /// _imageStream?.removeListener(ImageStreamListener(_updateImage)); /// _imageInfo?.dispose(); /// _imageInfo = null; /// super.dispose(); /// } /// /// @override /// Widget build(BuildContext context) { /// return RawImage( /// image: _imageInfo?.image, // this is a dart:ui Image object /// scale: _imageInfo?.scale ?? 1.0, /// ); /// } /// } /// ``` /// {@end-tool} /// /// ## Creating an [ImageProvider] /// /// {@tool dartpad} /// In this example, a variant of [NetworkImage] is created that passes all the /// [ImageConfiguration] information (locale, platform, size, etc) to the server /// using query arguments in the image URL. /// /// ** See code in examples/api/lib/painting/image_provider/image_provider.0.dart ** /// {@end-tool},˱؀/// Abstract const constructor. This constructor enables subclasses to provide /// const constructors so that they can be used in const expressions. ߇ʴJ:/// Resolves this image provider using the given `configuration`, returning /// an [ImageStream]. /// /// This is the public entry-point of the [ImageProvider] class hierarchy. /// /// Subclasses should implement [obtainKey] and [loadImage], which are used by /// this method. If they need to change the implementation of [ImageStream] /// used, they should override [createStream]. If they need to manage the /// actual resolution of the image, they should override [resolveStreamForKey]. /// /// See the Lifecycle documentation on [ImageProvider] for more information.R f01ǹ/// Called by [resolve] to create the [ImageStream] it returns. /// /// Subclasses should override this instead of [resolve] if they need to /// return some subclass of [ImageStream]. The stream created here will be /// passed to [resolveStreamForKey]. /// Returns the cache location for the key that this [ImageProvider] creates. /// /// The location may be [ImageCacheStatus.untracked], indicating that this /// image provider's key is not available in the [ImageCache]. /// /// If the `handleError` parameter is null, errors will be reported to /// [FlutterError.onError], and the method will return null. /// /// A completed return value of null indicates that an error has occurred.)3EZB B׀/// This method is used by both [resolve] and [obtainCacheStatus] to ensure /// that errors thrown during key creation are handled whether synchronous or /// asynchronous.B C C.C<CP'CkF"I߃/// Called by [resolve] with the key returned by [obtainKey]. /// /// Subclasses should override this method rather than calling [obtainKey] if /// they need to use a key directly. The [resolve] method installs appropriate /// error handling guards so that errors will bubble up to the right places in /// the framework, and passes those guards along to this method via the /// [handleError] parameter. /// /// It is safe for the implementation of this method to call [handleError] /// multiple times if multiple errors occur, or if an error is thrown both /// synchronously into the current part of the stack and thrown into the /// enclosing [Zone]. /// /// The default implementation uses the key to interact with the [ImageCache], /// calling [ImageCache.putIfAbsent] and notifying listeners of the [stream]. /// Implementers that do not call super are expected to correctly use the /// [ImageCache].I JJJ"J)J,J0JDIIOTꄝ/// Evicts an entry from the image cache. /// /// Returns a [Future] which indicates whether the value was successfully /// removed. /// /// The [ImageProvider] used does not need to be the same instance that was /// passed to an [Image] widget, but it does need to create a key which is /// equal to one. /// /// The [cache] is optional and defaults to the global image cache. /// /// The [configuration] is optional and defaults to /// [ImageConfiguration.empty]. /// /// {@tool snippet} /// /// The following sample code shows how an image loaded using the [Image] /// widget can be evicted using a [NetworkImage] with a matching URL. /// /// ```dart /// class MyWidget extends StatelessWidget { /// const MyWidget({ /// super.key, /// this.url = ' ... ', /// }); /// /// final String url; /// /// @override /// Widget build(BuildContext context) { /// return Image.network(url); /// } /// /// void evictImage() { /// final NetworkImage provider = NetworkImage(url); /// provider.evict().then((bool success) { /// if (success) { /// debugPrint('removed image!'); /// } /// }); /// } /// } /// ``` /// {@end-tool}TTU;UU(U:U;UEXՂ/// Converts an [ImageProvider]'s settings plus an [ImageConfiguration] to a key /// that describes the precise image to load. /// /// The type of the key is determined by the subclass. It is a value that /// unambiguously identifies the image (_including its scale_) that the /// [loadImage] method will fetch. Different [ImageProvider]s given the same /// constructor arguments and [ImageConfiguration] objects should return keys /// that are '==' to each other (possibly by using a class for the key that /// itself implements [==]). /// /// If the result can be determined synchronously, this function should return /// a [SynchronousFuture]. This allows image resolution to progress /// synchronously during a frame rather than delaying image loading.X XYf[ R/// Converts a key into an [ImageStreamCompleter], and begins fetching the /// image. /// /// This method is deprecated. Implement [loadImage] instead. /// /// The [decode] callback provides the logic to obtain the codec for the /// image. /// /// See also: /// /// * [ResizeImage], for modifying the key to account for cache dimensions.[[[[3ZnZoZ{Z|ZZZZ[o#^3//// Converts a key into an [ImageStreamCompleter], and begins fetching the /// image. /// /// For backwards-compatibility the default implementation of this method returns /// an object that will cause [resolveStreamForKey] to consult [loadBuffer]. /// However, implementors of this interface should only override this method /// and not [loadBuffer], which is deprecated. /// /// The [decode] callback provides the logic to obtain the codec for the /// image. /// /// See also: /// /// * [ResizeImage], for modifying the key to account for cache dimensions.^=^@^D^Z^^^V^^^^_/// A class that exists to facilitate backwards compatibility in the transition /// from [ImageProvider.loadBuffer] to [ImageProvider.loadImage]_Ƅ`j/// Key for the image obtained by an [AssetImage] or [ExactAssetImage]. /// /// This is used to identify the precise resource in the [imageCache].```F/// Creates the key for an [AssetImage] or [AssetBundleImageProvider].``aaaa,a;b/// The bundle from which the image will be obtained. /// /// The image is obtained by calling [AssetBundle.load] on the given [bundle] /// using the key given by [name].b bs/// The key to use to obtain the resource from the [bundle]. This is the /// argument passed to [AssetBundle.load].bSb>/// The scale to place in the [ImageInfo] object of the image.cAdccbc c cbbd9dLd9d:`Y`Zd^e/// A subclass of [ImageProvider] that knows about [AssetBundle]s. /// /// This factors out the common logic of [AssetBundle]-based [ImageProvider] /// classes, simplifying what subclasses must implement to just [obtainKey].eff/// Abstract const constructor. This constructor enables subclasses to provide /// const constructors so that they can be used in const expressions.f;ffffgffhiqU/// Converts a key into an [ImageStreamCompleter], and begins fetching the /// image.i|iiiiPiQklF/// Fetches the image from the asset bundle, decodes it, and returns a /// corresponding [ImageInfo] object. /// /// This function is used by [loadImage].lVlklu&ll(l)n!nt/// Key used internally by [ResizeImage]. /// /// This is used to identify the precise resource in the [imageCache].oOnocodoeofolo~ oo oo ooooooopppp&p1p<qjqqqpPppjpm pupPpQnnˡȃ/// Instructs Flutter to decode the image at the specified dimensions /// instead of at its native size. /// /// The [width] and [height] parameters refer to logical pixels. /// /// Logical pixels have roughly the same visual size across devices, whereas /// physical pixels correspond to actual device hardware. /// The number of physical pixels per logical pixel is described by the /// [ui.FlutterView.devicePixelRatio]. /// /// This allows finer control of the size of the image in [ImageCache] and is /// generally used to reduce the memory footprint of [ImageCache]. /// /// The decoded image may still be displayed at sizes other than the /// cached size provided here. /// /// {@tool snippet} /// This example shows how to size the image to half of the screen's width. /// /// ```dart /// Image( /// image: ResizeImage( /// FileImage(File('path/to/image')), /// width: MediaQuery.sizeOf(context).width ~/ 2, // Half of the screen's width. /// ), /// ); /// ``` /// {@end-tool};vc/// Creates an ImageProvider that decodes the image to the specified size. /// /// The cached image will be directly decoded and stored at the resolution /// defined by `width` and `height`. The image will lose detail and /// use less memory if resized to a size smaller than the native size. /// /// At least one of `width` and `height` must be non-null. %7&!0)3=R./// The [ImageProvider] that this class wraps.o/// The width the image should decode to and cache. /// /// At least one of this and [height] must be non-null.o/// The height the image should decode to and cache. /// /// At least one of this and [width] must be non-null.Aw/// The policy that determines how [width] and [height] are interpreted. /// /// Defaults to [ResizeImagePolicy.exact].L恀/// Whether the [width] and [height] parameters should be clamped to the /// intrinsic width and height of the image. /// /// In general, it is better for memory usage to avoid scaling the image /// beyond its intrinsic dimensions when decoding it. If there is a need to /// scale an image larger, it is better to apply a scale to the canvas, or /// to use an appropriate [Image.fit]./// Composes the `provider` in a [ResizeImage] only when `cacheWidth` and /// `cacheHeight` are not both null. /// /// When `cacheWidth` and `cacheHeight` are both null, this will return the /// `provider` directly. *Aq :Ԋ):Մ Yh/// Fetches the given URL from the network, associating it with the given scale. /// /// The image will be cached regardless of cache headers from the server. /// /// When a network image is used on the Web platform, the `getTargetSize` /// parameter of the [ImageDecoderCallback] is only supported when the /// application is running with the CanvasKit renderer. When the application is /// using the HTML renderer, the web engine delegates image decoding of network /// images to the Web, which does not support custom decode sizes. /// /// See also: /// /// * [Image.network] for a shorthand of an [Image] widget backed by [NetworkImage]. /// * The example at [ImageProvider], which shows a custom variant of this class /// that applies different logic for fetching the image.P/// Creates an object that fetches the image at the given URL. /// /// The [scale] argument is the linear scale factor for drawing this image at /// its intended size. See [ImageInfo.scale] for more information. C01/// The URL from which the image will be fetched.8R>/// The scale to place in the [ImageInfo] object of the image.F/// The HTTP headers that will be used with [HttpClient.get] to fetch image from network. /// /// When running Flutter on the web, headers are not used.R\s~RSZrP/// Decodes the given [File] object as an image, associating it with the given /// scale. /// /// The provider does not monitor the file for changes. If you expect the /// underlying data to change, you should call the [evict] method. /// /// See also: /// /// * [Image.file] for a shorthand of an [Image] widget backed by [FileImage].l8/// Creates an object that decodes a [File] as an image. 7D%/// The file to decode into an image.MS>/// The scale to place in the [ImageInfo] object of the image.!>5!"~ 'eHS ^by'(Ðpþ ÐÑÜÝ8% 0:&[@Z] e@AcvcdabP%-/// Decodes the given [Uint8List] buffer as an image, associating it with the /// given scale. /// /// The provided [bytes] buffer should not be changed after it is provided /// to a [MemoryImage]. To provide an [ImageStream] that represents an image /// that changes over time, consider creating a new subclass of [ImageProvider] /// whose [loadImage] method returns a subclass of [ImageStreamCompleter] that /// can handle providing multiple images. /// /// See also: /// /// * [Image.memory] for a shorthand of an [Image] widget backed by [MemoryImage].X{̥̰D/// Creates an object that decodes a [Uint8List] buffer as an image.̱ ̷ׁ̿/ /// The bytes to decode into an image. /// /// The bytes represent encoded image bytes and can be encoded in any of the /// following supported image formats: {@macro dart.ui.imageFormats} /// /// See also: /// /// * [PaintingBinding.instantiateImageCodecWithSize] Հ/// The scale to place in the [ImageInfo] object of the image. /// /// See also: /// /// * [ImageInfo.scale], which gives more information on how this scale is /// applied.`Ct`a߀ e2φϑϞϢϹefЛмЛМѶ&҅ҟҢ Ҫ҅҆ӧӺӧӨ8*A/// Fetches an image from an [AssetBundle], associating it with the given scale. /// /// This implementation requires an explicit final [assetName] and [scale] on /// construction, and ignores the device pixel ratio and size in the /// configuration passed into [resolve]. For a resolution-aware variant that /// uses the configuration to pick an appropriate image based on the device /// pixel ratio and size, see [AssetImage]. /// /// ## Fetching assets /// /// When fetching an image provided by the app itself, use the [assetName] /// argument to name the asset to choose. For instance, consider a directory /// `icons` with an image `heart.png`. First, the `pubspec.yaml` of the project /// should specify its assets in the `flutter` section: /// /// ```yaml /// flutter: /// assets: /// - icons/heart.png /// ``` /// /// Then, to fetch the image and associate it with scale `1.5`, use: /// /// {@tool snippet} /// ```dart /// const ExactAssetImage('icons/heart.png', scale: 1.5) /// ``` /// {@end-tool} /// /// ## Assets in packages /// /// To fetch an asset from a package, the [package] argument must be provided. /// For instance, suppose the structure above is inside a package called /// `my_icons`. Then to fetch the image, use: /// /// {@tool snippet} /// ```dart /// const ExactAssetImage('icons/heart.png', scale: 1.5, package: 'my_icons') /// ``` /// {@end-tool} /// /// Assets used by the package itself should also be fetched using the [package] /// argument as above. /// /// If the desired asset is specified in the `pubspec.yaml` of the package, it /// is bundled automatically with the app. In particular, assets used by the /// package itself must be specified in its `pubspec.yaml`. /// /// A package can also choose to have assets in its 'lib/' folder that are not /// specified in its `pubspec.yaml`. In this case for those images to be /// bundled, the app has to specify which ones to include. For instance a /// package named `fancy_backgrounds` could have: /// /// lib/backgrounds/background1.png /// lib/backgrounds/background2.png /// lib/backgrounds/background3.png /// /// To include, say the first image, the `pubspec.yaml` of the app should specify /// it in the `assets` section: /// /// ```yaml /// assets: /// - packages/fancy_backgrounds/backgrounds/background1.png /// ``` /// /// The `lib/` is implied, so it should not be included in the asset path. /// /// See also: /// /// * [Image.asset] for a shorthand of an [Image] widget backed by /// [ExactAssetImage] when using a scale.vFWf/// Creates an object that fetches the given image from an asset bundle. /// /// The [scale] argument defaults to 1. The [bundle] argument may be null, in /// which case the bundle provided in the [ImageConfiguration] passed to the /// [resolve] call will be used instead. /// /// The [package] argument must be non-null when fetching an asset that is /// included in a package. See the documentation for the [ExactAssetImage] class /// itself for details.lr 3/// The name of the asset.S>/// The scale to place in the [ImageInfo] object of the image.㵁r/// The bundle from which the image will be obtained. /// /// If the provided [bundle] is null, the bundle provided in the /// [ImageConfiguration] passed to the [resolve] call will be used instead. If /// that is also null, the [rootBundle] is used. /// /// The image is obtained by calling [AssetBundle.load] on the given [bundle] /// using the key given by [keyName].^/// The name of the package from which the image is included. See the /// documentation for the [ExactAssetImage] class itself for details.{s/// The key to use to obtain the resource from the [bundle]. This is the /// argument passed to [AssetBundle.load].Dj  jk{ {|Ȁ01;قl-M/// The exception thrown when the HTTP request to load a network image fails.`]/// Creates a [NetworkImageLoadException] with the specified http [statusCode] /// and [uri]. @AKMNQW@)/// The HTTP status code from the server.;#/// A human-readable error message.8(/// Resolved URL of the requested image.*,r2r/// Configures the behavior for [ResizeImage]. /// /// This is used in [ResizeImage.policy] to affect how the [ResizeImage.width] /// and [ResizeImage.height] properties are interpreted.s#&/// Sizes the image to the exact width and height specified by /// [ResizeImage.width] and [ResizeImage.height]. /// /// If [ResizeImage.width] and [ResizeImage.height] are both non-null, the /// output image will have the specified width and height (with the /// corresponding aspect ratio) regardless of whether it matches the source /// image's intrinsic aspect ratio. This case is similar to [BoxFit.fill]. /// /// If only one of `width` and `height` is non-null, then the output image /// will be scaled to the associated width or height, and the other dimension /// will take whatever value is needed to maintain the image's original aspect /// ratio. These cases are similar to [BoxFit.fitWidth] and /// [BoxFit.fitHeight], respectively. /// /// If [ResizeImage.allowUpscaling] is false (the default), the width and the /// height of the output image will each be clamped to the intrinsic width and /// height of the image. This may result in a different aspect ratio than the /// aspect ratio specified by the target width and height (e.g. if the height /// gets clamped downwards but the width does not). /// /// ## Examples /// /// The examples below show how [ResizeImagePolicy.exact] works in various /// scenarios. In each example, the source image has a size of 300x200 /// (landscape orientation), the red box is a 150x150 square, and the green /// box is a 400x400 square. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
ScenarioOutput
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// width: 150, /// height: 150, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_150x150_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// width: 150, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_150xnull_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// height: 150, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_nullx150_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// width: 400, /// height: 400, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_400x400_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// width: 400, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_400xnull_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// height: 400, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_nullx400_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// width: 400, /// height: 400, /// allowUpscaling: true, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_400x400_true.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// width: 400, /// allowUpscaling: true, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_400xnull_true.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// height: 400, /// allowUpscaling: true, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_exact_nullx400_true.png) /// ///
0Ï/// Scales the image as necessary to ensure that it fits within the bounding /// box specified by [ResizeImage.width] and [ResizeImage.height] while /// maintaining its aspect ratio. /// /// If [ResizeImage.allowUpscaling] is true, the image will be scaled up or /// down to best fit the bounding box; otherwise it will only ever be scaled /// down. /// /// This is conceptually similar to [BoxFit.contain]. /// /// ## Examples /// /// The examples below show how [ResizeImagePolicy.fit] works in various /// scenarios. In each example, the source image has a size of 300x200 /// (landscape orientation), the red box is a 150x150 square, and the green /// box is a 400x400 square. /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// /// ///
ScenarioOutput
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// width: 150, /// height: 150, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_150x150_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// width: 150, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_150xnull_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// height: 150, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_nullx150_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// width: 400, /// height: 400, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_400x400_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// width: 400, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_400xnull_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// height: 400, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_nullx400_false.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// width: 400, /// height: 400, /// allowUpscaling: true, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_400x400_true.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// width: 400, /// allowUpscaling: true, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_400xnull_true.png) /// ///
/// /// ```dart /// const ResizeImage( /// AssetImage('dragon_cake.jpg'), /// policy: ResizeImagePolicy.fit, /// height: 400, /// allowUpscaling: true, /// ) /// ``` /// /// /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/painting/resize_image_policy_fit_nullx400_true.png) /// ///
zR/// Signature for the callback taken by [ImageProvider._createErrorHandlerAndKey]. -S/// Signature used for error handling by [ImageProvider._createErrorHandlerAndKey].Hg/// Performs the decode process for use in [ImageProvider.loadBuffer]. /// /// This callback allows decoupling of the `cacheWidth`, `cacheHeight`, and /// `allowUpscaling` parameters from implementations of [ImageProvider] that do /// not expose them. /// /// See also: /// /// * [ResizeImage], which uses this to override the `cacheWidth`, /// `cacheHeight`, and `allowUpscaling` parameters.Օ֕](%V-`t}//// Performs the decode process for use in [ImageProvider.loadImage]. /// /// This callback allows decoupling of the `getTargetSize` parameter from /// implementations of [ImageProvider] that do not expose it. /// /// See also: /// /// * [ResizeImage], which uses this to load images at specific sizes.)%package:flutter/widgets.dart<ۀ܁ *msPAfm߽)| I_@7@@@@@AKAxAAAAAAABBBBlBBBCCLCyCCCCDDD&D=DVDDDDDDDEE&E4E:EWEpE|EEEEFFF F`FfFGGXGGGHHaHHHIIkIIIJRJJK:K^KKKL LLHLVL\LLLM=MMN1NNNOJOTOkOtOOOOOOOPPPcPrPxPQQ'Q-QsQyQQQQQR?RRRRRRSS"S(SBSHSZSSSSSTTJTeTTTTTTTULUfUUUUV V=VCVVW(WxWWWX<XXYYYPY]YcYYYZZZZZlZyZZZZ[<[h[l[m[[[\!\p\\\]A]N]T]d]j]^^^c^^^^^^^_@___```Y`d```aaa2a8a9aqawaabb bTbbbbbbbccJc^cdcccccccd6d7dCdddeeeUeefHffffgg?gOgzgh hh*h4h_hhhhhhhiAiNiZiiijjYjjjjjkk4kPkwk~kkkkkl&l3lRlqlllmm\mfmmmmmnnn n!nKnOnnnooMoooppp/pMpNpZp}ppppqqBqdqqqqqr/r1r2rarerrssGs{ssttbttuuRuuv vv_vwwPwwwwwx:xxxxxxxyy yyy*yCyjy~yyyyyyyz=zCzOz[zfzqzwzzzzzzzz{{{{{{{{{{{| |!|)|3|9|E|P|V|||||}}}}-}T}h}}}}}}}}~'~-~9~E~P~[~a~o~~~~~~~~~nt #/:@>Rg.4@LWbhv /MU_eq| $-.}?A .DP[flz ".9?:au}$0<GRXf:Ncku{ )4?ESlw}&;CMS_jp ,El  0Dbjtz (3>DRk!48y}Lsw Qpt<IO+1n :;lTZ'IJcCjpL6osCQ'0 $27@'(KN^lm-g-S1?@bDj QJT^deGMz?g&P]|(08Rhn5RVXYF-pt.j Y2w#56w+OP\ _jn al7JK $%1‚­IyÂÉÍÎÚç!OgĈĽ!6boň$AyƬ.zǀǦ9=>Jmșȭȳ+`am4EIʔ1ˀ˪ˮ˼V̝S͚͠ͰͶ JP`fδ-^bco4LЍДИЙХ!OgѨѯѳѴ#<~҂҃ҏҲ8Y]^jӤӥӱ578ԉԍ mչO֜$(4AOiqu׺׾/3MQؠ/;ىّ١٥ `ڭ<ۅ-U}܁RZ^ݩݭݻݿ0;t޿dߏߕ5Oh~AnU["(xNghtCXltxy6Vy}~acd'^ TU#DFImageConfiguration ImageProvider_AbstractImageStreamCompleterAssetBundleImageKeyAssetBundleImageProviderResizeImageKeyResizeImagePolicy ResizeImage NetworkImage FileImage MemoryImageExactAssetImage_ErrorImageCompleterNetworkImageLoadException