first commit

node_modules/expo-image/build/ExpoImage.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { NativeSyntheticEvent } from 'react-native';
+import { ImageErrorEventData, ImageLoadEventData, ImageNativeProps, ImageProgressEventData } from './Image.types';
+declare class ExpoImage extends React.PureComponent<ImageNativeProps> {
+    startAnimating: () => Promise<unknown> | unknown;
+    stopAnimating: () => Promise<unknown> | unknown;
+    lockResourceAsync: () => Promise<void>;
+    unlockResourceAsync: () => Promise<void>;
+    reloadAsync: () => Promise<void>;
+    onLoadStart: () => void;
+    onLoad: (event: NativeSyntheticEvent<ImageLoadEventData>) => void;
+    onProgress: (event: NativeSyntheticEvent<ImageProgressEventData>) => void;
+    onError: (event: NativeSyntheticEvent<ImageErrorEventData>) => void;
+    onLoadEnd: () => void;
+    render(): React.JSX.Element;
+}
+export default ExpoImage;
+//# sourceMappingURL=ExpoImage.d.ts.map

node_modules/expo-image/build/ExpoImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoImage.d.ts","sourceRoot":"","sources":["../src/ExpoImage.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,oBAAoB,EAAsC,MAAM,cAAc,CAAC;AAExF,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,eAAe,CAAC;AAkBvB,cAAM,SAAU,SAAQ,KAAK,CAAC,aAAa,CAAC,gBAAgB,CAAC;IAE3D,cAAc,EAAG,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAClD,aAAa,EAAG,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACjD,iBAAiB,EAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,mBAAmB,EAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,WAAW,EAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAElC,WAAW,aAET;IAEF,MAAM,GAAI,OAAO,oBAAoB,CAAC,kBAAkB,CAAC,UAGvD;IAEF,UAAU,GAAI,OAAO,oBAAoB,CAAC,sBAAsB,CAAC,UAE/D;IAEF,OAAO,GAAI,OAAO,oBAAoB,CAAC,mBAAmB,CAAC,UAGzD;IAEF,SAAS,aAEP;IAEF,MAAM;CAgEP;AAED,eAAe,SAAS,CAAC"}

node_modules/expo-image/build/ExpoImage.web.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { ImageNativeProps } from './Image.types';
+export default function ExpoImage({ source, placeholder, contentFit, contentPosition, placeholderContentFit, cachePolicy, onLoad, transition, onError, responsivePolicy, onLoadEnd, onDisplay, priority, loading, blurRadius, recyclingKey, style, nativeViewRef, accessibilityLabel, alt, tintColor, containerViewRef, draggable, ...props }: ImageNativeProps): React.JSX.Element;
+//# sourceMappingURL=ExpoImage.web.d.ts.map

node_modules/expo-image/build/ExpoImage.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoImage.web.d.ts","sourceRoot":"","sources":["../src/ExpoImage.web.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,KAAK,EAAE,gBAAgB,EAA6C,MAAM,eAAe,CAAC;AAsDjG,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,EAChC,MAAM,EACN,WAAW,EACX,UAAU,EACV,eAAe,EACf,qBAAqB,EACrB,WAAW,EACX,MAAM,EACN,UAAU,EACV,OAAO,EACP,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,QAAQ,EACR,OAAO,EACP,UAAU,EACV,YAAY,EACZ,KAAK,EACL,aAAa,EACb,kBAAkB,EAClB,GAAG,EACH,SAAS,EACT,gBAAgB,EAChB,SAAS,EACT,GAAG,KAAK,EACT,EAAE,gBAAgB,qBA8FlB"}

node_modules/expo-image/build/Image.d.ts

@@ -0,0 +1,134 @@
+import React from 'react';
+import { type View } from 'react-native';
+import ExpoImage from './ExpoImage';
+import { ImageCacheConfig, ImageLoadOptions, ImagePrefetchOptions, ImageProps, ImageRef, ImageSource } from './Image.types';
+export declare class Image extends React.PureComponent<ImageProps> {
+    nativeViewRef: React.RefObject<ExpoImage | null>;
+    containerViewRef: React.RefObject<View | null>;
+    constructor(props: ImageProps);
+    getAnimatableRef: () => View | this | null;
+    /**
+     * @hidden
+     */
+    static Image: typeof ImageRef;
+    /**
+     * Preloads images at the given URLs that can be later used in the image view.
+     * Preloaded images are cached to the memory and disk by default, so make sure
+     * to use `disk` (default) or `memory-disk` [cache policy](#cachepolicy).
+     * @param urls - A URL string or an array of URLs of images to prefetch.
+     * @param {ImagePrefetchOptions['cachePolicy']} cachePolicy - The cache policy for prefetched images.
+     * @return A promise resolving to `true` as soon as all images have been
+     * successfully prefetched. If an image fails to be prefetched, the promise
+     * will immediately resolve to `false` regardless of whether other images have
+     * finished prefetching.
+     */
+    static prefetch(urls: string | string[], cachePolicy?: ImagePrefetchOptions['cachePolicy']): Promise<boolean>;
+    /**
+     * Preloads images at the given URLs that can be later used in the image view.
+     * Preloaded images are cached to the memory and disk by default, so make sure
+     * to use `disk` (default) or `memory-disk` [cache policy](#cachepolicy).
+     * @param urls - A URL string or an array of URLs of images to prefetch.
+     * @param options - Options for prefetching images.
+     * @return A promise resolving to `true` as soon as all images have been
+     * successfully prefetched. If an image fails to be prefetched, the promise
+     * will immediately resolve to `false` regardless of whether other images have
+     * finished prefetching.
+     */
+    static prefetch(urls: string | string[], options?: ImagePrefetchOptions): Promise<boolean>;
+    /**
+     * Asynchronously clears all images stored in memory.
+     * @platform android
+     * @platform ios
+     * @return A promise resolving to `true` when the operation succeeds.
+     * It may resolve to `false` on Android when the activity is no longer available.
+     * Resolves to `false` on Web.
+     */
+    static clearMemoryCache(): Promise<boolean>;
+    /**
+     * Asynchronously clears all images from the disk cache.
+     * @platform android
+     * @platform ios
+     * @return A promise resolving to `true` when the operation succeeds.
+     * It may resolve to `false` on Android when the activity is no longer available.
+     * Resolves to `false` on Web.
+     */
+    static clearDiskCache(): Promise<boolean>;
+    /**
+     * Asynchronously checks if an image exists in the disk cache and resolves to
+     * the path of the cached image if it does.
+     * @param cacheKey - The cache key for the requested image. Unless you have set
+     * a custom cache key, this will be the source URL of the image.
+     * @platform android
+     * @platform ios
+     * @return A promise resolving to the path of the cached image. It will resolve
+     * to `null` if the image does not exist in the cache.
+     */
+    static getCachePathAsync(cacheKey: string): Promise<string | null>;
+    /**
+     * Configures the image cache. This allows you to manage the cache eviction policy.
+     * @param config - The cache configuration.
+     * @platform ios
+     */
+    static configureCache(config: ImageCacheConfig): void;
+    /**
+     * Asynchronously generates a [Blurhash](https://blurha.sh) from an image.
+     * @param source - The image source, either a URL (string) or an ImageRef
+     * @param numberOfComponents - The number of components to encode the blurhash with.
+     * Must be between 1 and 9. Defaults to `[4, 3]`.
+     * @platform android
+     * @platform ios
+     * @return A promise resolving to the blurhash string.
+     */
+    static generateBlurhashAsync(source: string | ImageRef, numberOfComponents: [number, number] | {
+        width: number;
+        height: number;
+    }): Promise<string | null>;
+    /**
+     * Asynchronously generates a [Thumbhash](https://evanw.github.io/thumbhash/) from an image.
+     * @param source - The image source, either a URL (string) or an ImageRef
+     * @platform android
+     * @platform ios
+     * @return A promise resolving to the thumbhash string.
+     */
+    static generateThumbhashAsync(source: string | ImageRef): Promise<string>;
+    /**
+     * Asynchronously starts playback of the view's image if it is animated.
+     * @platform android
+     * @platform ios
+     */
+    startAnimating(): Promise<void>;
+    /**
+     * Asynchronously stops the playback of the view's image if it is animated.
+     * @platform android
+     * @platform ios
+     */
+    stopAnimating(): Promise<void>;
+    /**
+     * Prevents the resource from being reloaded by locking it.
+     * @platform android
+     * @platform ios
+     */
+    lockResourceAsync(): Promise<void>;
+    /**
+     * Releases the lock on the resource, allowing it to be reloaded.
+     * @platform android
+     * @platform ios
+     */
+    unlockResourceAsync(): Promise<void>;
+    /**
+     * Reloads the resource, ignoring lock.
+     * @platform android
+     * @platform ios
+     */
+    reloadAsync(): Promise<void>;
+    /**
+     * Loads an image from the given source to memory and resolves to
+     * an object that references the native image instance.
+     * @platform android
+     * @platform ios
+     * @platform web
+     */
+    static loadAsync(source: ImageSource | string | number, options?: ImageLoadOptions): Promise<ImageRef>;
+    render(): React.JSX.Element;
+}
+//# sourceMappingURL=Image.d.ts.map

node_modules/expo-image/build/Image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["../src/Image.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAA+C,KAAK,IAAI,EAAE,MAAM,cAAc,CAAC;AAEtF,OAAO,SAAS,MAAM,aAAa,CAAC;AACpC,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,EACV,QAAQ,EACR,WAAW,EAGZ,MAAM,eAAe,CAAC;AA+BvB,qBAAa,KAAM,SAAQ,KAAK,CAAC,aAAa,CAAC,UAAU,CAAC;IACxD,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IACjD,gBAAgB,EAAE,KAAK,CAAC,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;gBAEnC,KAAK,EAAE,UAAU;IAO7B,gBAAgB,2BAMd;IAEF;;OAEG;IACH,MAAM,CAAC,KAAK,kBAAqB;IAEjC;;;;;;;;;;OAUG;WACU,QAAQ,CACnB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,WAAW,CAAC,EAAE,oBAAoB,CAAC,aAAa,CAAC,GAChD,OAAO,CAAC,OAAO,CAAC;IACnB;;;;;;;;;;OAUG;WACU,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;IAoBhG;;;;;;;OAOG;WACU,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjD;;;;;;;OAOG;WACU,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IAI/C;;;;;;;;;OASG;WACU,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIxE;;;;OAIG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAIrD;;;;;;;;OAQG;WACU,qBAAqB,CAChC,MAAM,EAAE,MAAM,GAAG,QAAQ,EACzB,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GACvE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIzB;;;;;;OAMG;WACU,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAI/E;;;;OAIG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrC;;;;OAIG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAIpC;;;;OAIG;IACG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxC;;;;OAIG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1C;;;;OAIG;IACG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlC;;;;;;OAMG;WACU,SAAS,CACpB,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,EACrC,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,QAAQ,CAAC;IAKpB,MAAM;CA6EP"}

node_modules/expo-image/build/Image.types.d.ts

@@ -0,0 +1,707 @@
+import type { NativeModule, SharedRef, SharedRefType } from 'expo';
+import { ImageStyle as RNImageStyle, TextStyle, StyleProp, View, ViewProps, ViewStyle, ColorValue } from 'react-native';
+import type { SFSymbol } from 'sf-symbols-typescript';
+import ExpoImage from './ExpoImage';
+export type ImageSource = {
+    /**
+     * A string representing the resource identifier for the image,
+     * which could be an HTTPS address, a local file path, or the name of a static image resource.
+     */
+    uri?: string;
+    /**
+     * An object representing the HTTP headers to send along with the request for a remote image.
+     * On web requires the `Access-Control-Allow-Origin` header returned by the server to include the current domain.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Can be specified if known at build time, in which case the value
+     * will be used to set the default `<Image/>` component dimension.
+     */
+    width?: number | null;
+    /**
+     * Can be specified if known at build time, in which case the value
+     * will be used to set the default `<Image/>` component dimension.
+     */
+    height?: number | null;
+    /**
+     * A string used to generate the image [`placeholder`](#placeholder). For example,
+     * `placeholder={blurhash}`.  If `uri` is provided as the value of the `source` prop,
+     * this is ignored since the `source` can only have `blurhash` or `uri`.
+     *
+     * When using the blurhash, you should also provide `width` and `height` (higher values reduce performance),
+     * otherwise their default value is `16`.
+     * For more information, see [`woltapp/blurhash`](https://github.com/woltapp/blurhash) repository.
+     */
+    blurhash?: string;
+    /**
+     * A string used to generate the image [`placeholder`](#placeholder). For example,
+     * `placeholder={thumbhash}`.  If `uri` is provided as the value of the `source` prop,
+     * this is ignored since the `source` can only have `thumbhash` or `uri`.
+     *
+     * For more information, see [`thumbhash website`](https://evanw.github.io/thumbhash/).
+     */
+    thumbhash?: string;
+    /**
+     * The cache key used to query and store this specific image.
+     * If not provided, the `uri` is used also as the cache key.
+     */
+    cacheKey?: string;
+    /**
+     * The max width of the viewport for which this source should be selected.
+     * Has no effect if `source` prop is not an array or has only 1 element.
+     * Has no effect if `responsivePolicy` is not set to `static`.
+     * Ignored if `blurhash` or `thumbhash` is provided (image hashes are never selected if passed in an array).
+     * @platform web
+     */
+    webMaxViewportWidth?: number;
+    /**
+     * Whether the image is animated (an animated GIF or WebP for example).
+     * @platform android
+     * @platform ios
+     */
+    isAnimated?: boolean;
+};
+/**
+ * @hidden
+ */
+export type ImageStyle = RNImageStyle;
+/**
+ * Determines how the image should be resized to fit its container.
+ * @hidden Described in the {@link ImageProps['contentFit']}
+ */
+export type ImageContentFit = 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+/**
+ * Determines which format should be used to decode the image.
+ * It's suggestion for the platform to use the specified format, but it's not guaranteed.
+ * @hidden Described in the {@link ImageProps['decodeFormat']}
+ */
+export type ImageDecodeFormat = 'argb' | 'rgb';
+/**
+ * Some props are from React Native Image that Expo Image supports (more or less) for easier migration,
+ * but all of them are deprecated and might be removed in the future.
+ */
+export interface ImageProps extends Omit<ViewProps, 'style' | 'children'> {
+    /** @hidden */
+    style?: StyleProp<RNImageStyle & {
+        /**
+         * Specifies stroke weight for SF symbols.
+         * @platform ios
+         */
+        fontWeight?: TextStyle['fontWeight'];
+        /**
+         * Sets the tint color of SF symbols. This is an alias for `tintColor` that can be used in styles.
+         * @platform ios
+         */
+        color?: TextStyle['color'];
+        /**
+         * Sets the size (width and height) of SF symbols.
+         * @platform ios
+         */
+        fontSize?: TextStyle['fontSize'];
+    }>;
+    /**
+     * The image source, either a remote URL, a local file resource or a number that is the result of the `require()` function.
+     * When provided as an array of sources, the source that fits best into the container size and is closest to the screen scale
+     * will be chosen. In this case it is important to provide `width`, `height` and `scale` properties.
+     *
+     * For SF Symbols (iOS), use the `sf:` prefix followed by the symbol name, for example, `sf:star.fill`.
+     *
+     * > **Note**: For the complete list of SF Symbols, see [Apple's SF Symbols catalog](https://developer.apple.com/sf-symbols/) or the [`sf-symbols-typescript`](https://github.com/nandorojo/sf-symbols-typescript) library documentation.
+     */
+    source?: ImageSource | `sf:${SFSymbol}` | (string & {}) | number | ImageSource[] | string[] | SharedRefType<'image'> | null;
+    /**
+     * An image to display while loading the proper image and no image has been displayed yet or the source is unset.
+     *
+     * > **Note**: The default value for placeholder's content fit is 'scale-down', which differs from the source image's default value.
+     * > Using a lower-resolution placeholder may cause flickering due to scaling differences between it and the final image.
+     * > To prevent this, you can set the [`placeholderContentFit`](#placeholdercontentfit) to match the [`contentFit`](#contentfit) value.
+     */
+    placeholder?: ImageSource | string | number | ImageSource[] | string[] | SharedRefType<'image'> | null;
+    /**
+     * Determines how the image should be resized to fit its container. This property tells the image to fill the container
+     * in a variety of ways; such as "preserve that aspect ratio" or "stretch up and take up as much space as possible".
+     * It mirrors the CSS [`object-fit`](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit) property.
+     *
+     * - `'cover'` - The image is sized to maintain its aspect ratio while filling the container box.
+     * If the image's aspect ratio does not match the aspect ratio of its box, then the object will be clipped to fit.
+     *
+     * - `'contain'` - The image is scaled down or up to maintain its aspect ratio while fitting within the container box.
+     *
+     * - `'fill'` - The image is sized to entirely fill the container box. If necessary, the image will be stretched or squished to fit.
+     *
+     * - `'none'` - The image is not resized and is centered by default.
+     * When specified, the exact position can be controlled with [`contentPosition`](#contentposition) prop.
+     *
+     * - `'scale-down'` - The image is sized as if `none` or `contain` were specified, whichever would result in a smaller concrete image size.
+     *
+     * @default 'cover'
+     */
+    contentFit?: ImageContentFit;
+    /**
+     * Determines how the placeholder should be resized to fit its container. Available resize modes are the same as for the [`contentFit`](#contentfit) prop.
+     * @default 'scale-down'
+     */
+    placeholderContentFit?: ImageContentFit;
+    /**
+     * It is used together with [`contentFit`](#contentfit) to specify how the image should be positioned with x/y coordinates inside its own container.
+     * An equivalent of the CSS [`object-position`](https://developer.mozilla.org/en-US/docs/Web/CSS/object-position) property.
+     * @default 'center'
+     */
+    contentPosition?: ImageContentPosition;
+    /**
+     * Describes how the image view should transition the contents when switching the image source.\
+     * If provided as a number, it is the duration in milliseconds of the `'cross-dissolve'` effect.
+     */
+    transition?: ImageTransition | number | null;
+    /**
+     * The radius of the blur in points, `0` means no blur effect.
+     * This effect is not applied to placeholders.
+     * @default 0
+     */
+    blurRadius?: number;
+    /**
+     * A color used to tint template images (a bitmap image where only the opacity matters).
+     * The color is applied to every non-transparent pixel, causing the image's shape to adopt that color.
+     * This effect is not applied to placeholders.
+     *
+     * Note that `useImage` options parameter also has a `tintColor` field.
+     * When you have a `useImage` as a `source` use its `tintColor` instead.
+     * @default null
+     */
+    tintColor?: string | null;
+    /**
+     * Priorities for completing loads. If more than one load is queued at a time,
+     * the load with the higher priority will be started first.
+     * Priorities are considered best effort, there are no guarantees about the order in which loads will start or finish.
+     * @default 'normal'
+     */
+    priority?: 'low' | 'normal' | 'high' | null;
+    /**
+     * Sets the HTML [`loading`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/img#loading) attribute on the `<img>` element.
+     * Has no effect on native platforms.
+     *
+     * - `'lazy'` - Defers loading until the image is near the viewport.
+     * - `'eager'` - Loads the image immediately.
+     *
+     * @default 'eager'
+     * @platform web
+     */
+    loading?: 'lazy' | 'eager';
+    /**
+     * Determines whether to cache the image and where: on the disk, in the memory or both.
+     *
+     * - `'none'` - Image is not cached at all.
+     *
+     * - `'disk'` - Image is queried from the disk cache if exists, otherwise it's downloaded and then stored on the disk.
+     *
+     * - `'memory'` - Image is cached in memory. Might be useful when you render a high-resolution picture many times.
+     * Memory cache may be purged very quickly to prevent high memory usage and the risk of out of memory exceptions.
+     *
+     * - `'memory-disk'` - Image is cached in memory, but with a fallback to the disk cache.
+     *
+     * @default 'disk'
+     */
+    cachePolicy?: 'none' | 'disk' | 'memory' | 'memory-disk' | /** @hidden */ null;
+    /**
+     * Controls the selection of the image source based on the container or viewport size on the web.
+     *
+     * If set to `'static'`, the browser selects the correct source based on user's viewport width. Works with static rendering.
+     * Make sure to set the `'webMaxViewportWidth'` property on each source for best results.
+     * For example, if an image occupies 1/3 of the screen width, set the `'webMaxViewportWidth'` to 3x the image width.
+     * The source with the largest `'webMaxViewportWidth'` is used even for larger viewports.
+     *
+     * If set to `'initial'`, the component will select the correct source during mount based on container size. Does not work with static rendering.
+     *
+     * If set to `'live'`, the component will select the correct source on every resize based on container size. Does not work with static rendering.
+     *
+     * @default 'static'
+     * @platform web
+     */
+    responsivePolicy?: 'live' | 'initial' | 'static';
+    /**
+     * Changing this prop resets the image view content to blank or a placeholder before loading and rendering the final image.
+     * This is especially useful for any kinds of recycling views like [FlashList](https://github.com/shopify/flash-list)
+     * to prevent showing the previous source before the new one fully loads.
+     * @default null
+     * @platform android
+     * @platform ios
+     */
+    recyclingKey?: string | null;
+    /**
+     * Determines if an image should automatically begin playing if it is an
+     * animated image.
+     * @default true
+     * @platform android
+     * @platform ios
+     */
+    autoplay?: boolean;
+    /**
+     * SF Symbol effect animations. Can be a single effect string, an effect object,
+     * or an array of effect strings and/or objects.
+     *
+     * @example
+     * ```tsx
+     * // Single effect as string
+     * sfEffect="bounce"
+     *
+     * // Single effect as object with options
+     * sfEffect={{ effect: "bounce", repeat: -1, scope: "by-layer" }}
+     *
+     * // Array of mixed strings and objects
+     * sfEffect={["bounce", { effect: "pulse", repeat: -1 }]}
+     * ```
+     *
+     * @platform ios 17.0+
+     */
+    sfEffect?: SFSymbolEffect | null;
+    /**
+     * Called when the image starts to load.
+     */
+    onLoadStart?: () => void;
+    /**
+     * Called when the image load completes successfully.
+     */
+    onLoad?: (event: ImageLoadEventData) => void;
+    /**
+     * Called when the image is loading. Can be called multiple times before the image has finished loading.
+     * The event object provides details on how many bytes were loaded so far and what's the expected total size.
+     */
+    onProgress?: (event: ImageProgressEventData) => void;
+    /**
+     * Called on an image fetching error.
+     */
+    onError?: (event: ImageErrorEventData) => void;
+    /**
+     * Called when the image load either succeeds or fails.
+     */
+    onLoadEnd?: () => void;
+    /**
+     * Called when the image view successfully rendered the source image.
+     */
+    onDisplay?: () => void;
+    /**
+     * @deprecated Provides compatibility for [`defaultSource` from React Native Image](https://reactnative.dev/docs/image#defaultsource).
+     * Use [`placeholder`](#placeholder) prop instead.
+     */
+    defaultSource?: ImageSource | null;
+    /**
+     * @deprecated Provides compatibility for [`loadingIndicatorSource` from React Native Image](https://reactnative.dev/docs/image#loadingindicatorsource).
+     * Use [`placeholder`](#placeholder) prop instead.
+     */
+    loadingIndicatorSource?: ImageSource | null;
+    /**
+     * @deprecated Provides compatibility for [`resizeMode` from React Native Image](https://reactnative.dev/docs/image#resizemode).
+     * Note that `"repeat"` option is not supported at all.
+     * Use the more powerful [`contentFit`](#contentfit) and [`contentPosition`](#contentposition) props instead.
+     */
+    resizeMode?: 'cover' | 'contain' | 'stretch' | 'repeat' | 'center';
+    /**
+     * @deprecated Provides compatibility for [`fadeDuration` from React Native Image](https://reactnative.dev/docs/image#fadeduration-android).
+     * Instead use [`transition`](#transition) with the provided duration.
+     */
+    fadeDuration?: number;
+    /**
+     * Whether this View should be focusable with a non-touch input device and receive focus with a hardware keyboard.
+     * @default false
+     * @platform android
+     */
+    focusable?: boolean;
+    /**
+     * When true, indicates that the view is an accessibility element.
+     * When a view is an accessibility element, it groups its children into a single selectable component.
+     *
+     * On Android, the `accessible` property will be translated into the native `isScreenReaderFocusable`,
+     * so it's only affecting the screen readers behaviour.
+     * @default false
+     * @platform android
+     * @platform ios
+     */
+    accessible?: boolean;
+    /**
+     * The text that's read by the screen reader when the user interacts with the image. Sets the `alt` tag on web which is used for web crawlers and link traversal.
+     * @default undefined
+     */
+    accessibilityLabel?: string;
+    /**
+     * The text that's read by the screen reader when the user interacts with the image. Sets the `alt` tag on web which is used for web crawlers and link traversal. Is an alias for `accessibilityLabel`.
+     *
+     * @alias accessibilityLabel
+     * @default undefined
+     */
+    alt?: string;
+    /**
+     * Enables Live Text interaction with the image. Check official [Apple documentation](https://developer.apple.com/documentation/visionkit/enabling_live_text_interactions_with_images) for more details.
+     * @default false
+     * @platform ios 16.0+
+     */
+    enableLiveTextInteraction?: boolean;
+    /**
+     * Whether the image should be downscaled to match the size of the view container.
+     * Turning off this functionality could negatively impact the application's performance, particularly when working with large assets.
+     * However, it would result in smoother image resizing, and end-users would always have access to the highest possible asset quality.
+     *
+     * Downscaling is never used when the `contentFit` prop is set to `none` or `fill`.
+     * @default true
+     */
+    allowDownscaling?: boolean;
+    /**
+     * The format in which the image data should be decoded.
+     * It's not guaranteed that the platform will use the specified format.
+     *
+     * - `'argb'` - The image is decoded into a 32-bit color space with alpha channel (https://developer.android.com/reference/android/graphics/Bitmap.Config#ARGB_8888).
+     *
+     * - `'rgb'` - The image is decoded into a 16-bit color space without alpha channel (https://developer.android.com/reference/android/graphics/Bitmap.Config#RGB_565).
+     *
+     * @default 'argb'
+     * @platform android
+     */
+    decodeFormat?: ImageDecodeFormat;
+    /**
+     * Whether to use the Apple's default WebP codec.
+     *
+     * Set this prop to `false` to use the official standard-compliant [libwebp](https://github.com/webmproject/libwebp) codec for WebP images.
+     * The default implementation from Apple is faster and uses less memory but may render animated images with incorrect blending or play them at the wrong framerate.
+     * @see https://github.com/SDWebImage/SDWebImage/wiki/Advanced-Usage#awebp-coder
+     *
+     * @default true
+     * @platform ios
+     */
+    useAppleWebpCodec?: boolean;
+    /**
+     * Force early resizing of the image to match the container size.
+     * This option helps to reduce the memory usage of the image view, especially when the image is larger than the container.
+     * It may affect the `resizeType` and `contentPosition` properties when the image view is resized dynamically.
+     *
+     * @default false
+     * @platform ios
+     */
+    enforceEarlyResizing?: boolean;
+    /**
+     * Controls whether the image view can leverage the extended dynamic range (EDR). Use this prop if you want to support high dynamic range (HDR) images,
+     * otherwise all images are rendered as standard dynamic range (SDR).
+     *
+     * @default false
+     * @platform ios 17.0+
+     * @platform tvos 17.0+
+     */
+    preferHighDynamicRange?: boolean;
+    /**
+     * Whether the `img` element is draggable on web.
+     * @default undefined
+     * @platform web
+     */
+    draggable?: boolean;
+}
+/**
+ * It narrows down some props to types expected by the native/web side.
+ * @hidden
+ */
+export interface ImageNativeProps extends ImageProps {
+    style?: RNImageStyle;
+    source?: ImageSource[] | SharedRefType<'image'>;
+    placeholder?: ImageSource[] | SharedRefType<'image'>;
+    contentPosition?: ImageContentPositionObject;
+    transition?: ImageTransition | null;
+    autoplay?: boolean;
+    sfEffect?: SFSymbolEffectObject[] | null;
+    nativeViewRef?: React.RefObject<ExpoImage | null>;
+    containerViewRef?: React.RefObject<View | null>;
+    symbolWeight?: string | null;
+    symbolSize?: number | null;
+}
+/**
+ * A value that represents the relative position of a single axis.
+ *
+ * If `number`, it is a distance in points (logical pixels) from the respective edge.\
+ * If `string`, it must be a percentage value where `'100%'` is the difference in size between the container and the image along the respective axis,
+ * or `'center'` which is an alias for `'50%'` that is the default value. You can read more regarding percentages on the MDN docs for
+ * [`background-position`](https://developer.mozilla.org/en-US/docs/Web/CSS/background-position#regarding_percentages) that describes this concept well.
+ */
+export type ImageContentPositionValue = number | string | `${number}%` | `${number}` | 'center';
+/**
+ * Specifies the position of the image inside its container. One value controls the x-axis and the second value controls the y-axis.
+ *
+ * Additionally, it supports stringified shorthand form that specifies the edges to which to align the image content:\
+ * `'center'`, `'top'`, `'right'`, `'bottom'`, `'left'`, `'top center'`, `'top right'`, `'top left'`, `'right center'`, `'right top'`,
+ * `'right bottom'`, `'bottom center'`, `'bottom right'`, `'bottom left'`, `'left center'`, `'left top'`, `'left bottom'`.\
+ * If only one keyword is provided, then the other dimension is set to `'center'` (`'50%'`), so the image is placed in the middle of the specified edge.\
+ * As an example, `'top right'` is the same as `{ top: 0, right: 0 }` and `'bottom'` is the same as `{ bottom: 0, left: '50%' }`.
+ */
+export type ImageContentPosition = 
+/**
+ * An object that positions the image relatively to the top-right corner.
+ */
+{
+    top?: ImageContentPositionValue;
+    right?: ImageContentPositionValue;
+}
+/**
+ * An object that positions the image relatively to the top-left corner.
+ */
+ | {
+    top?: ImageContentPositionValue;
+    left?: ImageContentPositionValue;
+}
+/**
+ * An object that positions the image relatively to the bottom-right corner.
+ */
+ | {
+    bottom?: ImageContentPositionValue;
+    right?: ImageContentPositionValue;
+}
+/**
+ * An object that positions the image relatively to the bottom-left corner.
+ */
+ | {
+    bottom?: ImageContentPositionValue;
+    left?: ImageContentPositionValue;
+} | ImageContentPositionString;
+/**
+ * It allows you to use an image as a background while rendering other content on top of it.
+ * It extends all `Image` props but provides separate styling controls for the container and the background image itself.
+ */
+export interface ImageBackgroundProps extends Omit<ImageProps, 'style'> {
+    /** The style of the image container. */
+    style?: StyleProp<ViewStyle> | undefined;
+    /** Style object for the image. */
+    imageStyle?: StyleProp<RNImageStyle> | undefined;
+    /** @hidden */
+    children?: React.ReactNode | undefined;
+}
+/**
+ * @hidden It's described as part of {@link ImageContentPosition}.
+ */
+export type ImageContentPositionString = 'center' | 'top' | 'right' | 'bottom' | 'left' | 'top center' | 'top right' | 'top left' | 'right center' | 'right top' | 'right bottom' | 'bottom center' | 'bottom right' | 'bottom left' | 'left center' | 'left top' | 'left bottom';
+type OnlyObject<T> = T extends object ? T : never;
+/**
+ * @hidden It's a conditional type that matches only objects of {@link ImageContentPosition}.
+ */
+export type ImageContentPositionObject = OnlyObject<ImageContentPosition>;
+/**
+ * The type of SF Symbol effect animation.
+ * @platform ios 17.0+
+ */
+export type SFSymbolEffectType = 'bounce' | 'bounce/up' | 'bounce/down' | 'pulse' | 'variable-color' | 'variable-color/iterative' | 'variable-color/cumulative' | 'scale' | 'scale/up' | 'scale/down' | 'appear' | 'disappear' | 'wiggle' | 'rotate' | 'breathe' | 'draw/on' | 'draw/off';
+/**
+ * An object that describes an SF Symbol effect animation.
+ * @platform ios 17.0+
+ */
+export type SFSymbolEffectObject = {
+    /**
+     * The type of SF Symbol effect animation.
+     *
+     * - `'bounce'` - The symbol bounces.
+     * - `'bounce/up'` / `'bounce/down'` - Directional bounce.
+     * - `'pulse'` - The symbol fades in and out.
+     * - `'variable-color'` - The symbol's color layers animate sequentially.
+     * - `'variable-color/iterative'` / `'variable-color/cumulative'` - Variable color modes.
+     * - `'scale'` - The symbol scales up and down.
+     * - `'scale/up'` / `'scale/down'` - Directional scale.
+     * - `'appear'` - The symbol animates into view.
+     * - `'disappear'` - The symbol animates out of view.
+     *
+     * For iOS 18+:
+     * - `'wiggle'` - The symbol wiggles.
+     * - `'rotate'` - The symbol rotates.
+     * - `'breathe'` - The symbol breathes (pulsing scale effect).
+     *
+     * For iOS 26+:
+     * - `'draw/on'` - The symbol layers animate like being drawn.
+     * - `'draw/off'` - The symbol layers animate like being erased.
+     */
+    effect: SFSymbolEffectType;
+    /**
+     * The number of times to repeat the effect.
+     * - `-1` - Repeat indefinitely
+     * - `0` - No repeat, play once (default)
+     * - `1+` - Repeat the specified number of times
+     *
+     * @default 0
+     */
+    repeat?: number;
+    /**
+     * Controls how the effect animates across symbol layers.
+     * - `'by-layer'` - Animates each layer of the symbol individually.
+     * - `'whole-symbol'` - Animates the entire symbol as one unit.
+     *
+     * @default undefined (uses system default)
+     */
+    scope?: 'by-layer' | 'whole-symbol' | null;
+};
+/**
+ * SF Symbol effect configuration. Can be a single effect string, an effect object,
+ * or an array of effect strings and/or objects.
+ *
+ * @example
+ * ```tsx
+ * // Single effect as string
+ * sfEffect="bounce"
+ *
+ * // Single effect as object with options
+ * sfEffect={{ effect: "bounce", repeat: -1, scope: "by-layer" }}
+ *
+ * // Array of mixed strings and objects
+ * sfEffect={["bounce", { effect: "pulse", repeat: -1 }]}
+ * ```
+ *
+ * @platform ios 17.0+
+ */
+export type SFSymbolEffect = SFSymbolEffectType | SFSymbolEffectObject | (SFSymbolEffectType | SFSymbolEffectObject)[];
+/**
+ * An object that describes the smooth transition when switching the image source.
+ */
+export type ImageTransition = {
+    /**
+     * The duration of the transition in milliseconds.
+     * @default 0
+     */
+    duration?: number;
+    /**
+     * Specifies the speed curve of the transition effect and how intermediate values are calculated.
+     * @default 'ease-in-out'
+     */
+    timing?: 'ease-in-out' | 'ease-in' | 'ease-out' | 'linear';
+    /**
+     * An animation effect used for transition.
+     * @default 'cross-dissolve'
+     *
+     * On Android, only `'cross-dissolve'` is supported.
+     * On Web, `'curl-up'` and `'curl-down'` effects are not supported.
+     *
+     * For SF Symbols (iOS 17+), use the `sf:` effects to animate
+     * when the symbol source changes:
+     * - `'sf:replace'` - The symbol animates when replaced with another symbol.
+     * - `'sf:down-up'` - New symbol slides in from bottom.
+     * - `'sf:up-up'` - New symbol slides in from top.
+     * - `'sf:off-up'` - Cross-dissolve transition between symbols.
+     *
+     * For other SF Symbol animations (bounce, pulse, scale, and so on), use the `sfEffect` prop instead.
+     */
+    effect?: 'cross-dissolve' | 'flip-from-top' | 'flip-from-right' | 'flip-from-bottom' | 'flip-from-left' | 'curl-up' | 'curl-down' | 'sf:replace' | 'sf:down-up' | 'sf:up-up' | 'sf:off-up' | null;
+};
+export type ImageLoadEventData = {
+    cacheType: 'none' | 'disk' | 'memory';
+    source: {
+        url: string;
+        width: number;
+        height: number;
+        mediaType: string | null;
+        isAnimated?: boolean;
+    };
+};
+export type ImageProgressEventData = {
+    loaded: number;
+    total: number;
+};
+export type ImageErrorEventData = {
+    error: string;
+};
+export type ImagePrefetchOptions = {
+    /**
+     * The cache policy for prefetched images.
+     * @default 'memory-disk'
+     */
+    cachePolicy?: 'disk' | 'memory-disk' | 'memory';
+    /**
+     * A map of headers to use when prefetching the images.
+     */
+    headers?: Record<string, string>;
+};
+/**
+ * An object that is a reference to a native image instance – [Drawable](https://developer.android.com/reference/android/graphics/drawable/Drawable)
+ * on Android and [UIImage](https://developer.apple.com/documentation/uikit/uiimage) on iOS.
+ * Instances of this class can be passed as a source to the [Image](#image) component in which case the image is rendered immediately
+ * since its native representation is already available in the memory.
+ */
+export declare class ImageRef extends SharedRef<'image'> {
+    /**
+     * Logical width of the image. Multiply it by the value in the `scale` property to get the width in pixels.
+     */
+    readonly width: number;
+    /**
+     * Logical height of the image. Multiply it by the value in the `scale` property to get the height in pixels.
+     */
+    readonly height: number;
+    /**
+     * On iOS, if you load an image from a file whose name includes the `@2x` modifier, the scale is set to **2.0**. All other images are assumed to have a scale factor of **1.0**.
+     * On Android, it calculates the scale based on the bitmap density divided by screen density.
+     *
+     * On all platforms, if you multiply the logical size of the image by this value, you get the dimensions of the image in pixels.
+     */
+    readonly scale: number;
+    /**
+     * Media type (also known as MIME type) of the image, based on its format.
+     * Returns `null` when the format is unknown or not supported.
+     * @platform ios
+     */
+    readonly mediaType: string | null;
+    /**
+     * Whether the referenced image is an animated image.
+     */
+    readonly isAnimated?: boolean;
+}
+/**
+ * @hidden
+ */
+export declare class ImageNativeModule extends NativeModule {
+    Image: typeof ImageRef;
+    loadAsync(source: ImageSource, options?: ImageLoadOptions): Promise<ImageRef>;
+    prefetch(urls: string[], cachePolicy: ImagePrefetchOptions['cachePolicy'], headers?: Record<string, string>): Promise<boolean>;
+    clearMemoryCache(): Promise<boolean>;
+    clearDiskCache(): Promise<boolean>;
+    configureCache(config: ImageCacheConfig): void;
+    getCachePathAsync(cacheKey: string): Promise<string | null>;
+    generateBlurhashAsync(source: string | ImageRef, numberOfComponents: [number, number] | {
+        width: number;
+        height: number;
+    }): Promise<string | null>;
+    generateThumbhashAsync(source: string | ImageRef): Promise<string>;
+}
+/**
+ * An object with options for the [`useImage`](#useimage) hook.
+ */
+export type ImageLoadOptions = {
+    /**
+     * If provided, the image will be automatically resized to not exceed this width in pixels, preserving its aspect ratio.
+     */
+    maxWidth?: number;
+    /**
+     * If provided, the image will be automatically resized to not exceed this height in pixels, preserving its aspect ratio.
+     */
+    maxHeight?: number;
+    /**
+     * A color used to tint template images (a bitmap image where only the opacity matters).
+     * The color is applied to every non-transparent pixel, causing the image's shape to adopt that color.
+     * @default null
+     */
+    tintColor?: ColorValue | number;
+    /**
+     * Function to call when the image has failed to load. In addition to the error, it also provides a function that retries loading the image.
+     */
+    onError?(error: Error, retry: () => void): void;
+};
+/**
+ * An object containing options for the [`configureCache`](#configurecacheconfig) function.
+ * See [`SDImageCacheConfig`](https://sdwebimage.github.io/documentation/sdwebimage/sdimagecacheconfig) for more information.
+ * @platform ios
+ */
+export type ImageCacheConfig = {
+    /**
+     * The maximum size of the disk cache, in bytes.
+     * Defaults to 0, which means there is no cache size limit.
+     */
+    maxDiskSize?: number;
+    /**
+     * The maximum "total cost" of the in-memory image cache. The cost function is the bytes size held in memory,
+     * not simply the pixel count. For example, a typical ARGB8888 image uses 4 bytes (32 bits) per pixel.
+     * Defaults to 0, which means there is no memory cost limit.
+     */
+    maxMemoryCost?: number;
+    /**
+     * The maximum number of objects the in-memory image cache should hold.
+     * Defaults to 0, which means there is no memory count limit.
+     */
+    maxMemoryCount?: number;
+};
+export {};
+//# sourceMappingURL=Image.types.d.ts.map

node_modules/expo-image/build/ImageBackground.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ImageBackgroundProps } from './Image.types';
+export declare function ImageBackground({ style, imageStyle, children, ...props }: ImageBackgroundProps): React.JSX.Element;
+//# sourceMappingURL=ImageBackground.d.ts.map

node_modules/expo-image/build/ImageBackground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageBackground.d.ts","sourceRoot":"","sources":["../src/ImageBackground.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAErD,wBAAgB,eAAe,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,oBAAoB,qBAO9F"}

node_modules/expo-image/build/ImageModule.d.ts

@@ -0,0 +1,4 @@
+import type { ImageNativeModule } from './Image.types';
+declare const _default: ImageNativeModule;
+export default _default;
+//# sourceMappingURL=ImageModule.d.ts.map

node_modules/expo-image/build/ImageModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageModule.d.ts","sourceRoot":"","sources":["../src/ImageModule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;;AAEvD,wBAAmE"}

node_modules/expo-image/build/ImageModule.web.d.ts

@@ -0,0 +1,19 @@
+import { NativeModule } from 'expo-modules-core';
+import { ImageCacheConfig, type ImageNativeModule, ImageRef, ImageSource } from './Image.types';
+declare class ImageModule extends NativeModule implements ImageNativeModule {
+    Image: typeof ImageRef;
+    prefetch(urls: string | string[], _: unknown, __: unknown): Promise<boolean>;
+    clearMemoryCache(): Promise<boolean>;
+    clearDiskCache(): Promise<boolean>;
+    configureCache(_: ImageCacheConfig): void;
+    loadAsync(source: ImageSource): Promise<ImageRef>;
+    getCachePathAsync(_: string): Promise<string | null>;
+    generateBlurhashAsync(_: string | ImageRef, __: [number, number] | {
+        width: number;
+        height: number;
+    }): Promise<string | null>;
+    generateThumbhashAsync(_: string | ImageRef): Promise<string>;
+}
+declare const _default: typeof ImageModule;
+export default _default;
+//# sourceMappingURL=ImageModule.web.d.ts.map

node_modules/expo-image/build/ImageModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageModule.web.d.ts","sourceRoot":"","sources":["../src/ImageModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAqB,MAAM,mBAAmB,CAAC;AAEpE,OAAO,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGhG,cAAM,WAAY,SAAQ,YAAa,YAAW,iBAAiB;IACjE,KAAK,EAAE,OAAO,QAAQ,CAAe;IAE/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB5E,gBAAgB,IAAI,OAAO,CAAC,OAAO,CAAC;IAIpC,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;IAIxC,cAAc,CAAC,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAEnC,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC;IAwBvD,iBAAiB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIpD,qBAAqB,CACnB,CAAC,EAAE,MAAM,GAAG,QAAQ,EACpB,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GACvD,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIzB,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;CAG9D;;AAeD,wBAA2D"}

node_modules/expo-image/build/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Image.types';
+export { Image } from './Image';
+export { ImageBackground } from './ImageBackground';
+export { useImage } from './useImage';
+//# sourceMappingURL=index.d.ts.map

node_modules/expo-image/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

node_modules/expo-image/build/useImage.d.ts

@@ -0,0 +1,40 @@
+import { DependencyList } from 'react';
+import type { ImageLoadOptions, ImageRef, ImageSource } from './Image.types';
+/**
+ * A hook that loads an image from the given source and returns a reference
+ * to the native image instance, or `null` until the first image is successfully loaded.
+ *
+ * It loads a new image every time the `uri` of the provided source changes.
+ * To trigger reloads in some other scenarios, you can provide an additional dependency list.
+ *
+ * > **warning** Avoid using this hook for large images without specifying size constraints,
+ * > as it may cause crashes due to excessive memory usage. It is recommended to use either
+ * > `maxWidth` or `maxHeight` option to scale down the image appropriately for your use case.
+ *
+ * @platform android
+ * @platform ios
+ * @platform web
+ *
+ * @example
+ * ```ts
+ * import { useImage, Image } from 'expo-image';
+ * import { Text } from 'react-native';
+ *
+ * export default function MyImage() {
+ *   const image = useImage('https://picsum.photos/1000/800', {
+ *     maxWidth: 800,
+ *     onError(error, retry) {
+ *       console.error('Loading failed:', error.message);
+ *     }
+ *   });
+ *
+ *   if (!image) {
+ *     return <Text>Image is loading...</Text>;
+ *   }
+ *
+ *   return <Image source={image} style={{ width: image.width / 2, height: image.height / 2 }} />;
+ * }
+ * ```
+ */
+export declare function useImage(source: ImageSource | string | number, options?: ImageLoadOptions, dependencies?: DependencyList): ImageRef | null;
+//# sourceMappingURL=useImage.d.ts.map

node_modules/expo-image/build/useImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImage.d.ts","sourceRoot":"","sources":["../src/useImage.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAA+B,MAAM,OAAO,CAAC;AAGpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,EACrC,OAAO,GAAE,gBAAqB,EAC9B,YAAY,GAAE,cAAmB,GAChC,QAAQ,GAAG,IAAI,CAgDjB"}

node_modules/expo-image/build/utils.d.ts

@@ -0,0 +1,24 @@
+import type { SharedRefType } from 'expo';
+import { type ImageResizeMode } from 'react-native';
+import { ImageContentFit, ImageContentPosition, ImageContentPositionObject, ImageProps, ImageTransition } from './Image.types';
+/**
+ * If the `contentFit` is not provided, it's resolved from the equivalent `resizeMode` prop
+ * that we support to provide compatibility with React Native Image.
+ * For SF Symbols, the default is `'contain'` instead of `'cover'`.
+ */
+export declare function resolveContentFit(contentFit?: ImageContentFit, resizeMode?: ImageResizeMode, isSFSymbol?: boolean): ImageContentFit;
+/**
+ * It resolves a stringified form of the `contentPosition` prop to an object,
+ * which is the only form supported in the native code.
+ */
+export declare function resolveContentPosition(contentPosition?: ImageContentPosition): ImageContentPositionObject;
+/**
+ * If `transition` or `fadeDuration` is a number, it's resolved to a cross dissolve transition with the given duration.
+ * When `fadeDuration` is used, it logs an appropriate deprecation warning.
+ */
+export declare function resolveTransition(transition?: ImageProps['transition'], fadeDuration?: ImageProps['fadeDuration']): ImageTransition | null;
+/**
+ * Checks whether the given value is an instance of the `SharedRef<'image'>` class.
+ */
+export declare function isImageRef(value: any): value is SharedRefType<'image'>;
+//# sourceMappingURL=utils.d.ts.map

node_modules/expo-image/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,0BAA0B,EAE1B,UAAU,EACV,eAAe,EAChB,MAAM,eAAe,CAAC;AAMvB;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,CAAC,EAAE,eAAe,EAC5B,UAAU,CAAC,EAAE,eAAe,EAC5B,UAAU,CAAC,EAAE,OAAO,GACnB,eAAe,CAiCjB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,eAAe,CAAC,EAAE,oBAAoB,GACrC,0BAA0B,CAiC5B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,EACrC,YAAY,CAAC,EAAE,UAAU,CAAC,cAAc,CAAC,GACxC,eAAe,GAAG,IAAI,CAYxB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAEtE"}

node_modules/expo-image/build/utils/AssetSourceResolver.web.d.ts

@@ -0,0 +1,24 @@
+import { PackagerAsset } from '@react-native/assets-registry/registry';
+export type ResolvedAssetSource = {
+    __packager_asset: boolean;
+    width?: number;
+    height?: number;
+    uri: string;
+    scale: number;
+};
+export default class AssetSourceResolver {
+    serverUrl: string;
+    jsbundleUrl?: string | null;
+    asset: PackagerAsset;
+    constructor(serverUrl: string | undefined | null, jsbundleUrl: string | undefined | null, asset: PackagerAsset);
+    isLoadedFromServer(): boolean;
+    isLoadedFromFileSystem(): boolean;
+    defaultAsset(): ResolvedAssetSource;
+    /**
+     * @returns absolute remote URL for the hosted asset.
+     */
+    assetServerURL(): ResolvedAssetSource;
+    fromSource(source: string): ResolvedAssetSource;
+    static pickScale(scales: number[], deviceScale: number): number;
+}
+//# sourceMappingURL=AssetSourceResolver.web.d.ts.map

node_modules/expo-image/build/utils/AssetSourceResolver.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssetSourceResolver.web.d.ts","sourceRoot":"","sources":["../../src/utils/AssetSourceResolver.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAIvE,MAAM,MAAM,mBAAmB,GAAG;IAChC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAcF,MAAM,CAAC,OAAO,OAAO,mBAAmB;IACtC,SAAS,EAAE,MAAM,CAAC;IAGlB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B,KAAK,EAAE,aAAa,CAAC;gBAGnB,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EACpC,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EACtC,KAAK,EAAE,aAAa;IAQtB,kBAAkB,IAAI,OAAO;IAK7B,sBAAsB,IAAI,OAAO;IAIjC,YAAY,IAAI,mBAAmB;IAInC;;OAEG;IACH,cAAc,IAAI,mBAAmB;IAUrC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB;IAU/C,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM;CAQhE"}

node_modules/expo-image/build/utils/blurhash/base83.d.ts

@@ -0,0 +1,3 @@
+export declare const decode83: (str: string) => number;
+export declare const encode83: (n: number, length: number) => string;
+//# sourceMappingURL=base83.d.ts.map

node_modules/expo-image/build/utils/blurhash/base83.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base83.d.ts","sourceRoot":"","sources":["../../../src/utils/blurhash/base83.ts"],"names":[],"mappings":"AAsFA,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,WAQnC,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,EAAE,QAAQ,MAAM,KAAG,MAOpD,CAAC"}

node_modules/expo-image/build/utils/blurhash/decode.d.ts

@@ -0,0 +1,7 @@
+export declare const isBlurhashValid: (blurhash: string) => {
+    result: boolean;
+    errorReason?: string;
+};
+declare const decode: (blurhash: string, width: number, height: number, punch?: number) => Uint8ClampedArray<ArrayBuffer>;
+export default decode;
+//# sourceMappingURL=decode.d.ts.map

node_modules/expo-image/build/utils/blurhash/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../src/utils/blurhash/decode.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAQzF,CAAC;AAuBF,QAAA,MAAM,MAAM,GAAI,UAAU,MAAM,EAAE,OAAO,MAAM,EAAE,QAAQ,MAAM,EAAE,QAAQ,MAAM,mCAsD9E,CAAC;AAEF,eAAe,MAAM,CAAC"}

node_modules/expo-image/build/utils/blurhash/error.d.ts

@@ -0,0 +1,4 @@
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=error.d.ts.map

node_modules/expo-image/build/utils/blurhash/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/utils/blurhash/error.ts"],"names":[],"mappings":"AAAA,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAK5B"}

node_modules/expo-image/build/utils/blurhash/useBlurhash.d.ts

@@ -0,0 +1,8 @@
+export declare function useBlurhash(blurhash: {
+    uri?: string;
+    width?: number | null;
+    height?: number | null;
+} | undefined | null, punch?: number): readonly [{
+    uri: string;
+} | null, boolean | ""];
+//# sourceMappingURL=useBlurhash.d.ts.map

node_modules/expo-image/build/utils/blurhash/useBlurhash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBlurhash.d.ts","sourceRoot":"","sources":["../../../src/utils/blurhash/useBlurhash.tsx"],"names":[],"mappings":"AAiBA,wBAAgB,WAAW,CACzB,QAAQ,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,SAAS,GAAG,IAAI,EAC5F,KAAK,GAAE,MAAU;;wBAiElB"}

node_modules/expo-image/build/utils/blurhash/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const sRGBToLinear: (value: number) => number;
+export declare const linearTosRGB: (value: number) => number;
+export declare const sign: (n: number) => 1 | -1;
+export declare const signPow: (val: number, exp: number) => number;
+//# sourceMappingURL=utils.d.ts.map

node_modules/expo-image/build/utils/blurhash/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/utils/blurhash/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,WAOzC,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,WAOzC,CAAC;AAEF,eAAO,MAAM,IAAI,GAAI,GAAG,MAAM,WAAqB,CAAC;AAEpD,eAAO,MAAM,OAAO,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,WAA6C,CAAC"}

node_modules/expo-image/build/utils/resolveAssetSource.d.ts

@@ -0,0 +1,3 @@
+import resolveAssetSource from 'react-native/Libraries/Image/resolveAssetSource';
+export default resolveAssetSource;
+//# sourceMappingURL=resolveAssetSource.d.ts.map

node_modules/expo-image/build/utils/resolveAssetSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveAssetSource.d.ts","sourceRoot":"","sources":["../../src/utils/resolveAssetSource.tsx"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,MAAM,iDAAiD,CAAC;AAEjF,eAAe,kBAAkB,CAAC"}

node_modules/expo-image/build/utils/resolveAssetSource.web.d.ts

@@ -0,0 +1,9 @@
+import AssetSourceResolver, { ResolvedAssetSource } from './AssetSourceResolver.web';
+export declare function setCustomSourceTransformer(transformer: (resolver: AssetSourceResolver) => ResolvedAssetSource): void;
+/**
+ * `source` is either a number (opaque type returned by require('./foo.png'))
+ * or an `ImageSource` like { uri: '<http location || file path>' }
+ */
+export default function resolveAssetSource(source: any): ResolvedAssetSource | undefined;
+export declare const pickScale: typeof AssetSourceResolver.pickScale;
+//# sourceMappingURL=resolveAssetSource.web.d.ts.map

node_modules/expo-image/build/utils/resolveAssetSource.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveAssetSource.web.d.ts","sourceRoot":"","sources":["../../src/utils/resolveAssetSource.web.ts"],"names":[],"mappings":"AAEA,OAAO,mBAAmB,EAAE,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIrF,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,mBAAmB,GAClE,IAAI,CAEN;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,MAAM,EAAE,GAAG,GAAG,mBAAmB,GAAG,SAAS,CAevF;AAQD,eAAO,MAAQ,SAAS,sCAAwB,CAAC"}

node_modules/expo-image/build/utils/resolveHashString.d.ts

@@ -0,0 +1,14 @@
+import { ImageSource } from '../Image.types';
+/**
+ * Converts a blurhash string (`blurhash:/<hash>/<width>/<height>` or <hash>/<width>/<height>) into an `ImageSource`.
+ *
+ * @return An ImageSource representing the provided blurhash.
+ * */
+export declare function resolveBlurhashString(str: string): ImageSource;
+/**
+ * Converts a thumbhash string (`thumbhash:/<hash>` or `<hash>`) into an `ImageSource`.
+ *
+ * @return An ImageSource representing the provided thumbhash.
+ * */
+export declare function resolveThumbhashString(str: string): ImageSource;
+//# sourceMappingURL=resolveHashString.d.ts.map

node_modules/expo-image/build/utils/resolveHashString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHashString.d.ts","sourceRoot":"","sources":["../../src/utils/resolveHashString.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAS7C;;;;KAIK;AACL,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAO9D;AAED;;;;KAIK;AACL,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAO/D"}

node_modules/expo-image/build/utils/resolveHashString.web.d.ts

@@ -0,0 +1,18 @@
+import { ImageSource } from '../Image.types';
+/**
+ * Converts a string in blurhash format (`blurhash:/<hash>/<width>/<height>`
+ * or <hash>/<width>/<height>) into an `ImageSource`.
+ *
+ * @return An ImageSource representing the provided blurhash.
+ * */
+export declare function resolveBlurhashString(str: string): ImageSource;
+/**
+ * Converts a string in thumbhash format (`thumbhash:/<hash>` or `<hash>`)
+ * into an `ImageSource`.
+ * Note: Unlike the `resolveBlurhashString` the `thumbhash:/` scheme has to be present,
+ * as the scheme has to be explicitly stated to be interpreted a `thumbhash` source.
+ *
+ * @return An ImageSource representing the provided thumbhash.
+ * */
+export declare function resolveThumbhashString(str: string): ImageSource;
+//# sourceMappingURL=resolveHashString.web.d.ts.map

node_modules/expo-image/build/utils/resolveHashString.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHashString.web.d.ts","sourceRoot":"","sources":["../../src/utils/resolveHashString.web.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;;;;KAKK;AACL,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAO9D;AAED;;;;;;;KAOK;AACL,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAK/D"}

node_modules/expo-image/build/utils/resolveSources.d.ts

@@ -0,0 +1,11 @@
+import { ImageNativeProps, ImageProps, ImageSource } from '../Image.types';
+export declare function isBlurhashString(str: string): boolean;
+export declare function isThumbhashString(str: string): boolean;
+export declare function isSFSymbolString(str: string): boolean;
+export declare function resolveSFSymbolString(str: string): ImageSource;
+export declare function resolveSource(source?: ImageSource | string | number | null): ImageSource | null;
+/**
+ * Resolves provided `source` prop to an array of objects expected by the native implementation.
+ */
+export declare function resolveSources(sources?: ImageProps['source']): ImageNativeProps['source'];
+//# sourceMappingURL=resolveSources.d.ts.map

node_modules/expo-image/build/utils/resolveSources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveSources.d.ts","sourceRoot":"","sources":["../../src/utils/resolveSources.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG3E,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAErD;AAID,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEtD;AAGD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAI9D;AAED,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,WAAW,GAAG,IAAI,CAyB/F;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAYzF"}

node_modules/expo-image/build/utils/thumbhash/thumbhash.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Encodes an RGBA image to a ThumbHash. RGB should not be premultiplied by A.
+ *
+ * @param w The width of the input image. Must be ≤100px.
+ * @param h The height of the input image. Must be ≤100px.
+ * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.
+ * @returns The ThumbHash as a Uint8Array.
+ */
+export declare function rgbaToThumbHash(w: number, h: number, rgba: Uint8Array): Uint8Array<ArrayBuffer>;
+/**
+ * Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns The width, height, and pixels of the rendered placeholder image.
+ */
+export declare function thumbHashToRGBA(hash: Uint8Array): {
+    w: number;
+    h: number;
+    rgba: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Extracts the average color from a ThumbHash. RGB is not be premultiplied by A.
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns The RGBA values for the average color. Each value ranges from 0 to 1.
+ */
+export declare function thumbHashToAverageRGBA(hash: Uint8Array): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ * Extracts the approximate aspect ratio of the original image.
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns The approximate aspect ratio (i.e. width / height).
+ */
+export declare function thumbHashToApproximateAspectRatio(hash: Uint8Array): number;
+/**
+ * Encodes an RGBA image to a PNG data URL. RGB should not be premultiplied by
+ * A. This is optimized for speed and simplicity and does not optimize for size
+ * at all. This doesn't do any compression (all values are stored uncompressed).
+ *
+ * @param w The width of the input image. Must be ≤100px.
+ * @param h The height of the input image. Must be ≤100px.
+ * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.
+ * @returns A data URL containing a PNG for the input image.
+ */
+export declare function rgbaToDataURL(w: number, h: number, rgba: Uint8Array): string;
+/**
+ * Decodes a ThumbHash to a PNG data URL. This is a convenience function that
+ * just calls "thumbHashToRGBA" followed by "rgbaToDataURL".
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns A data URL containing a PNG for the rendered ThumbHash.
+ */
+export declare function thumbHashToDataURL(hash: Uint8Array): string;
+/**
+ * Convenience function added to the original thumbhash code, allows generating a thumbhash image directly from
+ * thumbhash string.
+ * @param thumbhash string from which thumbhashDataURL should be generated
+ * @returns A data URL containing a PNG for the rendered ThumbHash
+ */
+export declare function thumbHashStringToDataURL(thumbhash: string): string;
+//# sourceMappingURL=thumbhash.d.ts.map

node_modules/expo-image/build/utils/thumbhash/thumbhash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thumbhash.d.ts","sourceRoot":"","sources":["../../../src/utils/thumbhash/thumbhash.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,2BAuGrE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU;;;;EAuF/C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,UAAU;;;;;EAiBtD;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,UAAU,UAOjE;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,UAsGnE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAG3D;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAGlE"}

node_modules/expo-image/build/web/AnimationManager.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { ImageTransition } from '../Image.types';
+type Callbacks = {
+    onReady?: (() => void) | null;
+    onAnimationFinished?: (() => void) | null;
+    onMount?: (() => void) | null;
+    onError?: (() => void) | null;
+};
+export type AnimationManagerNode = [
+    key: string,
+    renderFunction: (renderProps: NonNullable<Callbacks>) => (className: string, style: React.CSSProperties) => React.ReactElement
+];
+export declare function getAnimatorFromTransition(transition: ImageTransition | null | undefined): {
+    startingClass: string;
+    animateInClass: string;
+    animateOutClass: string;
+    containerClass: string;
+    timingFunction: string;
+    animationClass: string;
+    duration: number;
+} | {
+    startingClass: string;
+    animateInClass: string;
+    animateOutClass: string;
+    containerClass: string;
+    timingFunction: "ease-in-out" | "ease-in" | "ease-out" | "linear" | null;
+    animationClass: "cross-dissolve" | "flip-from-top" | "flip-from-right" | "flip-from-bottom" | "flip-from-left" | "curl-up" | "curl-down" | "sf:replace" | "sf:down-up" | "sf:up-up" | "sf:off-up";
+    duration: number;
+} | null;
+export default function AnimationManager({ children: renderFunction, initial, transition, recyclingKey, }: {
+    children: AnimationManagerNode;
+    initial: AnimationManagerNode | null;
+    transition: ImageTransition | null | undefined;
+    recyclingKey?: string | null | undefined;
+}): React.JSX.Element;
+export {};
+//# sourceMappingURL=AnimationManager.d.ts.map

node_modules/expo-image/build/web/AnimationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnimationManager.d.ts","sourceRoot":"","sources":["../../src/web/AnimationManager.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,KAAK,SAAS,GAAG;IACf,OAAO,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9B,mBAAmB,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;IAC1C,OAAO,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM;IACX,cAAc,EAAE,CACd,WAAW,EAAE,WAAW,CAAC,SAAS,CAAC,KAChC,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,aAAa,KAAK,KAAK,CAAC,YAAY;CAC3E,CAAC;AAgDF,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS;;;;;;;;;;;;;;;;SA+BvF;AAUD,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,EACvC,QAAQ,EAAE,cAAc,EACxB,OAAO,EACP,UAAU,EACV,YAAY,GACb,EAAE;IACD,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACrC,UAAU,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAC1C,qBAmHA"}

node_modules/expo-image/build/web/ColorTintFilter.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export declare function getTintColorStyle(tintId: string, tintColor?: string | null): {
+    filter?: undefined;
+} | {
+    filter: string;
+};
+type TintColorFilterProps = {
+    id: string;
+    tintColor?: string | null;
+};
+export default function TintColorFilter({ id, tintColor }: TintColorFilterProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=ColorTintFilter.d.ts.map

node_modules/expo-image/build/web/ColorTintFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColorTintFilter.d.ts","sourceRoot":"","sources":["../../src/web/ColorTintFilter.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;;;;EAO1E;AAED,KAAK,oBAAoB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAEtE,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,oBAAoB,4BAc9E"}

node_modules/expo-image/build/web/ImageRef.d.ts

@@ -0,0 +1,13 @@
+import { SharedRef } from 'expo';
+import { ImageRef } from '../Image.types';
+export default class ImageRefWeb extends SharedRef<'image'> implements ImageRef {
+    nativeRefType: string;
+    uri: string | null;
+    width: number;
+    height: number;
+    mediaType: string | null;
+    scale: number;
+    isAnimated: boolean;
+    static init(uri: string, width: number, height: number, mediaType: string | null): ImageRefWeb;
+}
+//# sourceMappingURL=ImageRef.d.ts.map

node_modules/expo-image/build/web/ImageRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageRef.d.ts","sourceRoot":"","sources":["../../src/web/ImageRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,SAAS,CAAC,OAAO,CAAE,YAAW,QAAQ;IACpE,aAAa,SAAW;IAEjC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAQ;IAC1B,KAAK,EAAE,MAAM,CAAK;IAClB,MAAM,EAAE,MAAM,CAAK;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAQ;IAChC,KAAK,EAAE,MAAM,CAAK;IAClB,UAAU,EAAE,OAAO,CAAS;IAE5B,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,WAAW;CAS/F"}

node_modules/expo-image/build/web/ImageWrapper.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { ImageWrapperProps } from './ImageWrapper.types';
+declare const ImageWrapper: React.ForwardRefExoticComponent<ImageWrapperProps & React.RefAttributes<HTMLImageElement>>;
+export default ImageWrapper;
+//# sourceMappingURL=ImageWrapper.d.ts.map

node_modules/expo-image/build/web/ImageWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageWrapper.d.ts","sourceRoot":"","sources":["../../src/web/ImageWrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AAGrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAqBzD,QAAA,MAAM,YAAY,4FAuEjB,CAAC;AAEF,eAAe,YAAY,CAAC"}

node_modules/expo-image/build/web/ImageWrapper.types.d.ts

@@ -0,0 +1,33 @@
+import { CSSProperties, SyntheticEvent } from 'react';
+import { SrcSetSource } from './useSourceSelection';
+import { ImageContentPositionObject, ImageProps, ImageSource } from '../Image.types';
+export type OnErrorEvent = (({ source }: {
+    source: ImageSource | null;
+}) => void) | undefined | null;
+export type OnLoadEvent = ((event: SyntheticEvent<HTMLImageElement, Event>) => void) | undefined | null;
+export type OnTransitionEndEvent = (() => void) | undefined | null;
+export type OnMountEvent = (() => void) | undefined | null;
+export type OnDisplayEvent = (() => void) | undefined | null;
+export type ImageWrapperEvents = {
+    onLoad?: OnLoadEvent[];
+    onError?: OnErrorEvent[];
+    onTransitionEnd?: OnTransitionEndEvent[];
+    onMount?: OnMountEvent[];
+    onDisplay?: OnDisplayEvent[];
+};
+export type ImageWrapperProps = {
+    source?: ImageSource | SrcSetSource | null;
+    events?: ImageWrapperEvents;
+    contentPosition?: ImageContentPositionObject;
+    hashPlaceholderContentPosition?: ImageContentPositionObject;
+    priority?: string | null;
+    loading?: ImageProps['loading'];
+    style: CSSProperties;
+    tintColor?: string | null;
+    hashPlaceholderStyle?: CSSProperties;
+    className?: string;
+    accessibilityLabel?: string;
+    cachePolicy?: ImageProps['cachePolicy'];
+    draggable?: boolean;
+};
+//# sourceMappingURL=ImageWrapper.types.d.ts.map

node_modules/expo-image/build/web/ImageWrapper.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageWrapper.types.d.ts","sourceRoot":"","sources":["../../src/web/ImageWrapper.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,0BAA0B,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAErF,MAAM,MAAM,YAAY,GACpB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAAA;CAAE,KAAK,IAAI,CAAC,GACtD,SAAS,GACT,IAAI,CAAC;AACT,MAAM,MAAM,WAAW,GACnB,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,gBAAgB,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,GAC1D,SAAS,GACT,IAAI,CAAC;AACT,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;AACnE,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC;AAE7D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;IACvB,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,eAAe,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACzC,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,CAAC,EAAE,WAAW,GAAG,YAAY,GAAG,IAAI,CAAC;IAC3C,MAAM,CAAC,EAAE,kBAAkB,CAAC;IAC5B,eAAe,CAAC,EAAE,0BAA0B,CAAC;IAC7C,8BAA8B,CAAC,EAAE,0BAA0B,CAAC;IAC5D,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;IAChC,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,oBAAoB,CAAC,EAAE,aAAa,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC;IACxC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC"}

node_modules/expo-image/build/web/getImageWrapperEventHandler.d.ts

@@ -0,0 +1,9 @@
+import type { SyntheticEvent } from 'react';
+import type { ImageWrapperEvents } from './ImageWrapper.types';
+import type { ImageSource } from '../Image.types';
+export declare function getImageWrapperEventHandler(events: ImageWrapperEvents | undefined, source: ImageSource): {
+    onLoad: (event: SyntheticEvent<HTMLImageElement, Event>) => void;
+    onTransitionEnd: () => void | undefined;
+    onError: () => void;
+};
+//# sourceMappingURL=getImageWrapperEventHandler.d.ts.map

node_modules/expo-image/build/web/getImageWrapperEventHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getImageWrapperEventHandler.d.ts","sourceRoot":"","sources":["../../src/web/getImageWrapperEventHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAGlD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,MAAM,EAAE,WAAW;oBAGD,cAAc,CAAC,gBAAgB,EAAE,KAAK,CAAC;;;EAmB1D"}

node_modules/expo-image/build/web/hooks.d.ts

@@ -0,0 +1,16 @@
+import { OnErrorEvent } from './ImageWrapper.types';
+import { ImageNativeProps, ImageSource } from '../Image.types';
+export declare function useThumbhash(source: ImageSource | null | undefined): readonly [{
+    uri: string;
+} | null, boolean];
+export declare function useImageHashes(source: ImageSource | null | undefined): {
+    resolvedSource: ImageSource | null | undefined;
+    isImageHash: boolean;
+} | {
+    resolvedSource: {
+        uri: string;
+    } | null;
+    isImageHash: boolean;
+};
+export declare function useHeaders(source: ImageSource | null | undefined, cachePolicy: ImageNativeProps['cachePolicy'], onError?: OnErrorEvent[]): ImageSource | null | undefined;
+//# sourceMappingURL=hooks.d.ts.map

node_modules/expo-image/build/web/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/web/hooks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAK/D,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS;;mBAQlE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS;;;;;;;;EAepE;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,EACtC,WAAW,EAAE,gBAAgB,CAAC,aAAa,CAAC,EAC5C,OAAO,CAAC,EAAE,YAAY,EAAE,GACvB,WAAW,GAAG,IAAI,GAAG,SAAS,CAoChC"}

node_modules/expo-image/build/web/imageStyles.d.ts

@@ -0,0 +1,2 @@
+export default function loadStyle(): void;
+//# sourceMappingURL=imageStyles.d.ts.map

node_modules/expo-image/build/web/imageStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageStyles.d.ts","sourceRoot":"","sources":["../../src/web/imageStyles.tsx"],"names":[],"mappings":"AAgIA,MAAM,CAAC,OAAO,UAAU,SAAS,SAOhC"}

node_modules/expo-image/build/web/positioning.d.ts

@@ -0,0 +1,11 @@
+import { ImageContentPositionObject } from '../Image.types';
+export declare function ensureValueIsWebUnits(value: string | number): string;
+export declare const absoluteFilledPosition: {
+    readonly width: "100%";
+    readonly height: "100%";
+    readonly position: "absolute";
+    readonly left: 0;
+    readonly top: 0;
+};
+export declare function getObjectPositionFromContentPositionObject(contentPosition?: ImageContentPositionObject): string;
+//# sourceMappingURL=positioning.d.ts.map

node_modules/expo-image/build/web/positioning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positioning.d.ts","sourceRoot":"","sources":["../../src/web/positioning.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAA6B,MAAM,gBAAgB,CAAC;AAEvF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,UAM3D;AAID,eAAO,MAAM,sBAAsB;;;;;;CAMzB,CAAC;AAEX,wBAAgB,0CAA0C,CACxD,eAAe,CAAC,EAAE,0BAA0B,GAC3C,MAAM,CAyBR"}

node_modules/expo-image/build/web/useSourceSelection.d.ts

@@ -0,0 +1,11 @@
+import type { SharedRefType } from 'expo';
+import React from 'react';
+import { ImageProps, ImageSource } from '../Image.types';
+export interface SrcSetSource extends ImageSource {
+    srcset: string;
+    sizes: string;
+    uri: string;
+    type: 'srcset';
+}
+export default function useSourceSelection(sources: ImageSource[] | SharedRefType<'image'> | undefined, responsivePolicy: ImageProps['responsivePolicy'], containerRef: React.RefObject<HTMLDivElement | null>, measurementCallback?: ((target: HTMLElement, size: DOMRect) => void) | null): ImageSource | SrcSetSource | SharedRefType<'image'> | null;
+//# sourceMappingURL=useSourceSelection.d.ts.map

node_modules/expo-image/build/web/useSourceSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSourceSelection.d.ts","sourceRoot":"","sources":["../../src/web/useSourceSelection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAmB,MAAM,OAAO,CAAC;AAExC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAqCzD,MAAM,WAAW,YAAa,SAAQ,WAAW;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IAEd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,QAAQ,CAAC;CAChB;AAmDD,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,OAAO,EAAE,WAAW,EAAE,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,SAAS,EAC3D,gBAAgB,EAAE,UAAU,CAAC,kBAAkB,CAAY,EAC3D,YAAY,EAAE,KAAK,CAAC,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,EACpD,mBAAmB,GAAE,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,IAAW,GAChF,WAAW,GAAG,YAAY,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,IAAI,CA+B5D"}