initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/Image/AssetRegistry.js

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AssetRegistry
+ * @flow
+ * @format
+ */
+'use strict';
+
+export type PackagerAsset = {
+  +__packager_asset: boolean,
+  +fileSystemLocation: string,
+  +httpServerLocation: string,
+  +width: ?number,
+  +height: ?number,
+  +scales: Array<number>,
+  +hash: string,
+  +name: string,
+  +type: string,
+};
+
+var assets: Array<PackagerAsset> = [];
+
+function registerAsset(asset: PackagerAsset): number {
+  // `push` returns new array length, so the first asset will
+  // get id 1 (not 0) to make the value truthy
+  return assets.push(asset);
+}
+
+function getAssetByID(assetId: number): PackagerAsset {
+  return assets[assetId - 1];
+}
+
+module.exports = {registerAsset, getAssetByID};

node_modules/react-native/Libraries/Image/AssetSourceResolver.js

@@ -0,0 +1,168 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule AssetSourceResolver
+ * @flow
+ * @format
+ */
+'use strict';
+
+export type ResolvedAssetSource = {|
+  +__packager_asset: boolean,
+  +width: ?number,
+  +height: ?number,
+  +uri: string,
+  +scale: number,
+|};
+
+import type {PackagerAsset} from 'AssetRegistry';
+
+const PixelRatio = require('PixelRatio');
+const Platform = require('Platform');
+
+const assetPathUtils = require('../../local-cli/bundle/assetPathUtils');
+const invariant = require('fbjs/lib/invariant');
+
+/**
+ * Returns a path like 'assets/AwesomeModule/icon@2x.png'
+ */
+function getScaledAssetPath(asset): string {
+  var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
+  var scaleSuffix = scale === 1 ? '' : '@' + scale + 'x';
+  var assetDir = assetPathUtils.getBasePath(asset);
+  return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;
+}
+
+/**
+ * Returns a path like 'drawable-mdpi/icon.png'
+ */
+function getAssetPathInDrawableFolder(asset): string {
+  var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
+  var drawbleFolder = assetPathUtils.getAndroidResourceFolderName(asset, scale);
+  var fileName = assetPathUtils.getAndroidResourceIdentifier(asset);
+  return drawbleFolder + '/' + fileName + '.' + asset.type;
+}
+
+class AssetSourceResolver {
+  serverUrl: ?string;
+  // where the jsbundle is being run from
+  jsbundleUrl: ?string;
+  // the asset to resolve
+  asset: PackagerAsset;
+
+  constructor(serverUrl: ?string, jsbundleUrl: ?string, asset: PackagerAsset) {
+    this.serverUrl = serverUrl;
+    this.jsbundleUrl = jsbundleUrl;
+    this.asset = asset;
+  }
+
+  isLoadedFromServer(): boolean {
+    return !!this.serverUrl;
+  }
+
+  isLoadedFromFileSystem(): boolean {
+    return !!(this.jsbundleUrl && this.jsbundleUrl.startsWith('file://'));
+  }
+
+  defaultAsset(): ResolvedAssetSource {
+    if (this.isLoadedFromServer()) {
+      return this.assetServerURL();
+    }
+
+    if (Platform.OS === 'android') {
+      return this.isLoadedFromFileSystem()
+        ? this.drawableFolderInBundle()
+        : this.resourceIdentifierWithoutScale();
+    } else {
+      return this.scaledAssetURLNearBundle();
+    }
+  }
+
+  /**
+   * Returns an absolute URL which can be used to fetch the asset
+   * from the devserver
+   */
+  assetServerURL(): ResolvedAssetSource {
+    invariant(!!this.serverUrl, 'need server to load from');
+    return this.fromSource(
+      this.serverUrl +
+        getScaledAssetPath(this.asset) +
+        '?platform=' +
+        Platform.OS +
+        '&hash=' +
+        this.asset.hash,
+    );
+  }
+
+  /**
+   * Resolves to just the scaled asset filename
+   * E.g. 'assets/AwesomeModule/icon@2x.png'
+   */
+  scaledAssetPath(): ResolvedAssetSource {
+    return this.fromSource(getScaledAssetPath(this.asset));
+  }
+
+  /**
+   * Resolves to where the bundle is running from, with a scaled asset filename
+   * E.g. 'file:///sdcard/bundle/assets/AwesomeModule/icon@2x.png'
+   */
+  scaledAssetURLNearBundle(): ResolvedAssetSource {
+    const path = this.jsbundleUrl || 'file://';
+    return this.fromSource(path + getScaledAssetPath(this.asset));
+  }
+
+  /**
+   * The default location of assets bundled with the app, located by
+   * resource identifier
+   * The Android resource system picks the correct scale.
+   * E.g. 'assets_awesomemodule_icon'
+   */
+  resourceIdentifierWithoutScale(): ResolvedAssetSource {
+    invariant(
+      Platform.OS === 'android',
+      'resource identifiers work on Android',
+    );
+    return this.fromSource(
+      assetPathUtils.getAndroidResourceIdentifier(this.asset),
+    );
+  }
+
+  /**
+   * If the jsbundle is running from a sideload location, this resolves assets
+   * relative to its location
+   * E.g. 'file:///sdcard/AwesomeModule/drawable-mdpi/icon.png'
+   */
+  drawableFolderInBundle(): ResolvedAssetSource {
+    const path = this.jsbundleUrl || 'file://';
+    return this.fromSource(path + getAssetPathInDrawableFolder(this.asset));
+  }
+
+  fromSource(source: string): ResolvedAssetSource {
+    return {
+      __packager_asset: true,
+      width: this.asset.width,
+      height: this.asset.height,
+      uri: source,
+      scale: AssetSourceResolver.pickScale(this.asset.scales, PixelRatio.get()),
+    };
+  }
+
+  static pickScale(scales: Array<number>, deviceScale: number): number {
+    // Packager guarantees that `scales` array is sorted
+    for (var i = 0; i < scales.length; i++) {
+      if (scales[i] >= deviceScale) {
+        return scales[i];
+      }
+    }
+
+    // If nothing matches, device scale is larger than any available
+    // scales, so we return the biggest one. Unless the array is empty,
+    // in which case we default to 1
+    return scales[scales.length - 1] || 1;
+  }
+}
+
+module.exports = AssetSourceResolver;

node_modules/react-native/Libraries/Image/Image.android.js

@@ -0,0 +1,282 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Image
+ * @flow
+ * @format
+ */
+'use strict';
+
+var ImageResizeMode = require('ImageResizeMode');
+var ImageStylePropTypes = require('ImageStylePropTypes');
+var NativeMethodsMixin = require('NativeMethodsMixin');
+var NativeModules = require('NativeModules');
+var React = require('React');
+var PropTypes = require('prop-types');
+var ReactNativeViewAttributes = require('ReactNativeViewAttributes');
+var StyleSheet = require('StyleSheet');
+var StyleSheetPropType = require('StyleSheetPropType');
+var ViewPropTypes = require('ViewPropTypes');
+
+var createReactClass = require('create-react-class');
+var flattenStyle = require('flattenStyle');
+var merge = require('merge');
+var requireNativeComponent = require('requireNativeComponent');
+var resolveAssetSource = require('resolveAssetSource');
+
+const {ViewContextTypes} = require('ViewContext');
+
+var {ImageLoader} = NativeModules;
+
+let _requestId = 1;
+function generateRequestId() {
+  return _requestId++;
+}
+
+/**
+ * A React component for displaying different types of images,
+ * including network images, static resources, temporary local images, and
+ * images from local disk, such as the camera roll.
+ *
+ * See https://facebook.github.io/react-native/docs/image.html
+ */
+var Image = createReactClass({
+  displayName: 'Image',
+  propTypes: {
+    ...ViewPropTypes,
+    style: StyleSheetPropType(ImageStylePropTypes),
+    /**
+     * See https://facebook.github.io/react-native/docs/image.html#source
+     */
+    source: PropTypes.oneOfType([
+      PropTypes.shape({
+        uri: PropTypes.string,
+        headers: PropTypes.objectOf(PropTypes.string),
+      }),
+      // Opaque type returned by require('./image.jpg')
+      PropTypes.number,
+      // Multiple sources
+      PropTypes.arrayOf(
+        PropTypes.shape({
+          uri: PropTypes.string,
+          width: PropTypes.number,
+          height: PropTypes.number,
+          headers: PropTypes.objectOf(PropTypes.string),
+        }),
+      ),
+    ]),
+    /**
+     * blurRadius: the blur radius of the blur filter added to the image
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#blurradius
+     */
+    blurRadius: PropTypes.number,
+    /**
+     * See https://facebook.github.io/react-native/docs/image.html#loadingindicatorsource
+     */
+    loadingIndicatorSource: PropTypes.oneOfType([
+      PropTypes.shape({
+        uri: PropTypes.string,
+      }),
+      // Opaque type returned by require('./image.jpg')
+      PropTypes.number,
+    ]),
+    progressiveRenderingEnabled: PropTypes.bool,
+    fadeDuration: PropTypes.number,
+    /**
+     * Invoked on load start
+     */
+    onLoadStart: PropTypes.func,
+    /**
+     * Invoked on load error
+     */
+    onError: PropTypes.func,
+    /**
+     * Invoked when load completes successfully
+     */
+    onLoad: PropTypes.func,
+    /**
+     * Invoked when load either succeeds or fails
+     */
+    onLoadEnd: PropTypes.func,
+    /**
+     * Used to locate this view in end-to-end tests.
+     */
+    testID: PropTypes.string,
+    /**
+     * The mechanism that should be used to resize the image when the image's dimensions
+     * differ from the image view's dimensions. Defaults to `auto`.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#resizemethod
+     */
+    resizeMethod: PropTypes.oneOf(['auto', 'resize', 'scale']),
+    /**
+     * Determines how to resize the image when the frame doesn't match the raw
+     * image dimensions.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#resizemode
+     */
+    resizeMode: PropTypes.oneOf(['cover', 'contain', 'stretch', 'center']),
+  },
+
+  statics: {
+    resizeMode: ImageResizeMode,
+
+    getSize(
+      url: string,
+      success: (width: number, height: number) => void,
+      failure?: (error: any) => void,
+    ) {
+      return ImageLoader.getSize(url)
+        .then(function(sizes) {
+          success(sizes.width, sizes.height);
+        })
+        .catch(
+          failure ||
+            function() {
+              console.warn('Failed to get size for image: ' + url);
+            },
+        );
+    },
+
+    /**
+     * Prefetches a remote image for later use by downloading it to the disk
+     * cache
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#prefetch
+     */
+    prefetch(url: string, callback: ?Function) {
+      const requestId = generateRequestId();
+      callback && callback(requestId);
+      return ImageLoader.prefetchImage(url, requestId);
+    },
+
+    /**
+     * Abort prefetch request.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#abortprefetch
+     */
+    abortPrefetch(requestId: number) {
+      ImageLoader.abortRequest(requestId);
+    },
+
+    /**
+     * Perform cache interrogation.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#querycache
+     */
+    async queryCache(
+      urls: Array<string>,
+    ): Promise<Map<string, 'memory' | 'disk'>> {
+      return await ImageLoader.queryCache(urls);
+    },
+
+    /**
+     * Resolves an asset reference into an object.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#resolveassetsource
+     */
+    resolveAssetSource: resolveAssetSource,
+  },
+
+  mixins: [NativeMethodsMixin],
+
+  /**
+   * `NativeMethodsMixin` will look for this when invoking `setNativeProps`. We
+   * make `this` look like an actual native component class.
+   */
+  viewConfig: {
+    uiViewClassName: 'RCTView',
+    validAttributes: ReactNativeViewAttributes.RCTView,
+  },
+
+  contextTypes: ViewContextTypes,
+
+  render: function() {
+    const source = resolveAssetSource(this.props.source);
+    const loadingIndicatorSource = resolveAssetSource(
+      this.props.loadingIndicatorSource,
+    );
+
+    // As opposed to the ios version, here we render `null` when there is no source, source.uri
+    // or source array.
+
+    if (source && source.uri === '') {
+      console.warn('source.uri should not be an empty string');
+    }
+
+    if (this.props.src) {
+      console.warn(
+        'The <Image> component requires a `source` property rather than `src`.',
+      );
+    }
+
+    if (this.props.children) {
+      throw new Error(
+        'The <Image> component cannot contain children. If you want to render content on top of the image, consider using the <ImageBackground> component or absolute positioning.',
+      );
+    }
+
+    if (source && (source.uri || Array.isArray(source))) {
+      let style;
+      let sources;
+      if (source.uri) {
+        const {width, height} = source;
+        style = flattenStyle([{width, height}, styles.base, this.props.style]);
+        sources = [{uri: source.uri}];
+      } else {
+        style = flattenStyle([styles.base, this.props.style]);
+        sources = source;
+      }
+
+      const {onLoadStart, onLoad, onLoadEnd, onError} = this.props;
+      const nativeProps = merge(this.props, {
+        style,
+        shouldNotifyLoadEvents: !!(
+          onLoadStart ||
+          onLoad ||
+          onLoadEnd ||
+          onError
+        ),
+        src: sources,
+        headers: source.headers,
+        loadingIndicatorSrc: loadingIndicatorSource
+          ? loadingIndicatorSource.uri
+          : null,
+      });
+
+      if (this.context.isInAParentText) {
+        return <RCTTextInlineImage {...nativeProps} />;
+      } else {
+        return <RKImage {...nativeProps} />;
+      }
+    }
+    return null;
+  },
+});
+
+var styles = StyleSheet.create({
+  base: {
+    overflow: 'hidden',
+  },
+});
+
+var cfg = {
+  nativeOnly: {
+    src: true,
+    headers: true,
+    loadingIndicatorSrc: true,
+    shouldNotifyLoadEvents: true,
+  },
+};
+var RKImage = requireNativeComponent('RCTImageView', Image, cfg);
+var RCTTextInlineImage = requireNativeComponent(
+  'RCTTextInlineImage',
+  Image,
+  cfg,
+);
+
+module.exports = Image;

node_modules/react-native/Libraries/Image/Image.ios.js

@@ -0,0 +1,266 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Image
+ * @flow
+ * @format
+ */
+'use strict';
+
+const EdgeInsetsPropType = require('EdgeInsetsPropType');
+const ImageResizeMode = require('ImageResizeMode');
+const ImageSourcePropType = require('ImageSourcePropType');
+const ImageStylePropTypes = require('ImageStylePropTypes');
+const NativeMethodsMixin = require('NativeMethodsMixin');
+const NativeModules = require('NativeModules');
+const React = require('React');
+const PropTypes = require('prop-types');
+const ReactNativeViewAttributes = require('ReactNativeViewAttributes');
+const StyleSheet = require('StyleSheet');
+const StyleSheetPropType = require('StyleSheetPropType');
+
+const createReactClass = require('create-react-class');
+const flattenStyle = require('flattenStyle');
+const requireNativeComponent = require('requireNativeComponent');
+const resolveAssetSource = require('resolveAssetSource');
+
+const ImageViewManager = NativeModules.ImageViewManager;
+
+/**
+ * A React component for displaying different types of images,
+ * including network images, static resources, temporary local images, and
+ * images from local disk, such as the camera roll.
+ *
+ * See https://facebook.github.io/react-native/docs/image.html
+ */
+const Image = createReactClass({
+  displayName: 'Image',
+  propTypes: {
+    /**
+     * See https://facebook.github.io/react-native/docs/image.html#style
+     */
+    style: StyleSheetPropType(ImageStylePropTypes),
+    /**
+     * The image source (either a remote URL or a local file resource).
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#source
+     */
+    source: ImageSourcePropType,
+    /**
+     * A static image to display while loading the image source.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#defaultsource
+     */
+    defaultSource: PropTypes.oneOfType([
+      PropTypes.shape({
+        uri: PropTypes.string,
+        width: PropTypes.number,
+        height: PropTypes.number,
+        scale: PropTypes.number,
+      }),
+      PropTypes.number,
+    ]),
+    /**
+     * When true, indicates the image is an accessibility element.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#accessible
+     */
+    accessible: PropTypes.bool,
+    /**
+     * The text that's read by the screen reader when the user interacts with
+     * the image.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#accessibilitylabel
+     */
+    accessibilityLabel: PropTypes.node,
+    /**
+     * blurRadius: the blur radius of the blur filter added to the image
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#blurradius
+     */
+    blurRadius: PropTypes.number,
+    /**
+     * See https://facebook.github.io/react-native/docs/image.html#capinsets
+     */
+    capInsets: EdgeInsetsPropType,
+    /**
+     * See https://facebook.github.io/react-native/docs/image.html#resizemethod
+     */
+    resizeMethod: PropTypes.oneOf(['auto', 'resize', 'scale']),
+    /**
+     * Determines how to resize the image when the frame doesn't match the raw
+     * image dimensions.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#resizemode
+     */
+    resizeMode: PropTypes.oneOf([
+      'cover',
+      'contain',
+      'stretch',
+      'repeat',
+      'center',
+    ]),
+    /**
+     * A unique identifier for this element to be used in UI Automation
+     * testing scripts.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#testid
+     */
+    testID: PropTypes.string,
+    /**
+     * Invoked on mount and layout changes with
+     * `{nativeEvent: {layout: {x, y, width, height}}}`.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#onlayout
+     */
+    onLayout: PropTypes.func,
+    /**
+     * Invoked on load start.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#onloadstart
+     */
+    onLoadStart: PropTypes.func,
+    /**
+     * Invoked on download progress with `{nativeEvent: {loaded, total}}`.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#onprogress
+     */
+    onProgress: PropTypes.func,
+    /**
+     * Invoked on load error with `{nativeEvent: {error}}`.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#onerror
+     */
+    onError: PropTypes.func,
+    /**
+     * Invoked when a partial load of the image is complete.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#onpartialload
+     */
+    onPartialLoad: PropTypes.func,
+    /**
+     * Invoked when load completes successfully.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#onload
+     */
+    onLoad: PropTypes.func,
+    /**
+     * Invoked when load either succeeds or fails.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#onloadend
+     */
+    onLoadEnd: PropTypes.func,
+  },
+
+  statics: {
+    resizeMode: ImageResizeMode,
+    /**
+     * Retrieve the width and height (in pixels) of an image prior to displaying it.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#getsize
+     */
+    getSize: function(
+      uri: string,
+      success: (width: number, height: number) => void,
+      failure?: (error: any) => void,
+    ) {
+      ImageViewManager.getSize(
+        uri,
+        success,
+        failure ||
+          function() {
+            console.warn('Failed to get size for image: ' + uri);
+          },
+      );
+    },
+    /**
+     * Prefetches a remote image for later use by downloading it to the disk
+     * cache.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#prefetch
+     */
+    prefetch(url: string) {
+      return ImageViewManager.prefetchImage(url);
+    },
+    /**
+     * Resolves an asset reference into an object.
+     *
+     * See https://facebook.github.io/react-native/docs/image.html#resolveassetsource
+     */
+    resolveAssetSource: resolveAssetSource,
+  },
+
+  mixins: [NativeMethodsMixin],
+
+  /**
+   * `NativeMethodsMixin` will look for this when invoking `setNativeProps`. We
+   * make `this` look like an actual native component class.
+   */
+  viewConfig: {
+    uiViewClassName: 'UIView',
+    validAttributes: ReactNativeViewAttributes.UIView,
+  },
+
+  render: function() {
+    const source = resolveAssetSource(this.props.source) || {
+      uri: undefined,
+      width: undefined,
+      height: undefined,
+    };
+
+    let sources;
+    let style;
+    if (Array.isArray(source)) {
+      style = flattenStyle([styles.base, this.props.style]) || {};
+      sources = source;
+    } else {
+      const {width, height, uri} = source;
+      style =
+        flattenStyle([{width, height}, styles.base, this.props.style]) || {};
+      sources = [source];
+
+      if (uri === '') {
+        console.warn('source.uri should not be an empty string');
+      }
+    }
+
+    const resizeMode =
+      this.props.resizeMode || (style || {}).resizeMode || 'cover'; // Workaround for flow bug t7737108
+    const tintColor = (style || {}).tintColor; // Workaround for flow bug t7737108
+
+    if (this.props.src) {
+      console.warn(
+        'The <Image> component requires a `source` property rather than `src`.',
+      );
+    }
+
+    if (this.props.children) {
+      throw new Error(
+        'The <Image> component cannot contain children. If you want to render content on top of the image, consider using the <ImageBackground> component or absolute positioning.',
+      );
+    }
+
+    return (
+      <RCTImageView
+        {...this.props}
+        style={style}
+        resizeMode={resizeMode}
+        tintColor={tintColor}
+        source={sources}
+      />
+    );
+  },
+});
+
+const styles = StyleSheet.create({
+  base: {
+    overflow: 'hidden',
+  },
+});
+
+const RCTImageView = requireNativeComponent('RCTImageView', Image);
+
+module.exports = Image;

node_modules/react-native/Libraries/Image/ImageBackground.js

@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImageBackground
+ * @flow
+ * @format
+ */
+'use strict';
+
+const Image = require('Image');
+const React = require('React');
+const StyleSheet = require('StyleSheet');
+const View = require('View');
+
+const ensureComponentIsNative = require('ensureComponentIsNative');
+
+/**
+ * Very simple drop-in replacement for <Image> which supports nesting views.
+ *
+ * ```ReactNativeWebPlayer
+ * import React, { Component } from 'react';
+ * import { AppRegistry, View, ImageBackground, Text } from 'react-native';
+ *
+ * class DisplayAnImageBackground extends Component {
+ *   render() {
+ *     return (
+ *       <ImageBackground
+ *         style={{width: 50, height: 50}}
+ *         source={{uri: 'https://facebook.github.io/react-native/img/opengraph.png'}}
+ *       >
+ *         <Text>React</Text>
+ *       </ImageBackground>
+ *     );
+ *   }
+ * }
+ *
+ * // App registration and rendering
+ * AppRegistry.registerComponent('DisplayAnImageBackground', () => DisplayAnImageBackground);
+ * ```
+ */
+class ImageBackground extends React.Component<$FlowFixMeProps> {
+  setNativeProps(props: Object) {
+    // Work-around flow
+    const viewRef = this._viewRef;
+    if (viewRef) {
+      ensureComponentIsNative(viewRef);
+      viewRef.setNativeProps(props);
+    }
+  }
+
+  _viewRef: ?React.ElementRef<typeof View> = null;
+
+  _captureRef = ref => {
+    this._viewRef = ref;
+  };
+
+  render() {
+    const {children, style, imageStyle, imageRef, ...props} = this.props;
+
+    return (
+      <View style={style} ref={this._captureRef}>
+        <Image
+          {...props}
+          style={[
+            StyleSheet.absoluteFill,
+            {
+              // Temporary Workaround:
+              // Current (imperfect yet) implementation of <Image> overwrites width and height styles
+              // (which is not quite correct), and these styles conflict with explicitly set styles
+              // of <ImageBackground> and with our internal layout model here.
+              // So, we have to proxy/reapply these styles explicitly for actual <Image> component.
+              // This workaround should be removed after implementing proper support of
+              // intrinsic content size of the <Image>.
+              width: style.width,
+              height: style.height,
+            },
+            imageStyle,
+          ]}
+          ref={imageRef}
+        />
+        {children}
+      </View>
+    );
+  }
+}
+
+module.exports = ImageBackground;

node_modules/react-native/Libraries/Image/ImageEditor.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImageEditor
+ * @flow
+ * @format
+ */
+'use strict';
+
+const RCTImageEditingManager = require('NativeModules').ImageEditingManager;
+
+type ImageCropData = {
+  /**
+   * The top-left corner of the cropped image, specified in the original
+   * image's coordinate space.
+   */
+  offset: {
+    x: number,
+    y: number,
+  },
+  /**
+   * The size (dimensions) of the cropped image, specified in the original
+   * image's coordinate space.
+   */
+  size: {
+    width: number,
+    height: number,
+  },
+  /**
+   * (Optional) size to scale the cropped image to.
+   */
+  displaySize?: ?{
+    width: number,
+    height: number,
+  },
+  /**
+   * (Optional) the resizing mode to use when scaling the image. If the
+   * `displaySize` param is not specified, this has no effect.
+   */
+  resizeMode?: ?$Enum<{
+    contain: string,
+    cover: string,
+    stretch: string,
+  }>,
+};
+
+class ImageEditor {
+  /**
+   * Crop the image specified by the URI param. If URI points to a remote
+   * image, it will be downloaded automatically. If the image cannot be
+   * loaded/downloaded, the failure callback will be called.
+   *
+   * If the cropping process is successful, the resultant cropped image
+   * will be stored in the ImageStore, and the URI returned in the success
+   * callback will point to the image in the store. Remember to delete the
+   * cropped image from the ImageStore when you are done with it.
+   */
+  static cropImage(
+    uri: string,
+    cropData: ImageCropData,
+    success: (uri: string) => void,
+    failure: (error: Object) => void,
+  ) {
+    RCTImageEditingManager.cropImage(uri, cropData, success, failure);
+  }
+}
+
+module.exports = ImageEditor;

node_modules/react-native/Libraries/Image/ImageResizeMode.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImageResizeMode
+ * @flow
+ * @format
+ */
+'use strict';
+
+/* $FlowFixMe(>=0.54.0 site=react_native_oss) This comment suppresses an error
+ * found when Flow v0.54 was deployed. To see the error delete this comment and
+ * run Flow. */
+var keyMirror = require('fbjs/lib/keyMirror');
+
+/**
+ * ImageResizeMode - Enum for different image resizing modes, set via
+ * `resizeMode` style property on `<Image>` components.
+ */
+var ImageResizeMode = keyMirror({
+  /**
+   * contain - The image will be resized such that it will be completely
+   * visible, contained within the frame of the View.
+   */
+  contain: null,
+  /**
+   * cover - The image will be resized such that the entire area of the view
+   * is covered by the image, potentially clipping parts of the image.
+   */
+  cover: null,
+  /**
+   * stretch - The image will be stretched to fill the entire frame of the
+   * view without clipping. This may change the aspect ratio of the image,
+   * distorting it.
+   */
+  stretch: null,
+  /**
+   * center - The image will be scaled down such that it is completely visible,
+   * if bigger than the area of the view.
+   * The image will not be scaled up.
+   */
+  center: null,
+
+  /**
+   * repeat - The image will be repeated to cover the frame of the View. The
+   * image will keep it's size and aspect ratio.
+   */
+  repeat: null,
+});
+
+module.exports = ImageResizeMode;

node_modules/react-native/Libraries/Image/ImageSource.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImageSource
+ * @flow
+ * @format
+ */
+'use strict';
+
+// This is to sync with ImageSourcePropTypes.js.
+
+type ImageURISource = {
+  uri?: string,
+  bundle?: string,
+  method?: string,
+  headers?: Object,
+  body?: string,
+  cache?: 'default' | 'reload' | 'force-cache' | 'only-if-cached',
+  width?: number,
+  height?: number,
+  scale?: number,
+};
+
+export type ImageSource = ImageURISource | number | Array<ImageURISource>;

node_modules/react-native/Libraries/Image/ImageSourcePropType.js

@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImageSourcePropType
+ * @no-flow
+ * @format
+ */
+'use strict';
+
+const PropTypes = require('prop-types');
+
+const ImageURISourcePropType = PropTypes.shape({
+  /**
+   * `uri` is a string representing the resource identifier for the image, which
+   * could be an http address, a local file path, or the name of a static image
+   * resource (which should be wrapped in the `require('./path/to/image.png')`
+   * function).
+   */
+  uri: PropTypes.string,
+  /**
+   * `bundle` is the iOS asset bundle which the image is included in. This
+   * will default to [NSBundle mainBundle] if not set.
+   * @platform ios
+   */
+  bundle: PropTypes.string,
+  /**
+   * `method` is the HTTP Method to use. Defaults to GET if not specified.
+   */
+  method: PropTypes.string,
+  /**
+   * `headers` is an object representing the HTTP headers to send along with the
+   * request for a remote image.
+   */
+  headers: PropTypes.objectOf(PropTypes.string),
+  /**
+   * `body` is the HTTP body to send with the request. This must be a valid
+   * UTF-8 string, and will be sent exactly as specified, with no
+   * additional encoding (e.g. URL-escaping or base64) applied.
+   */
+  body: PropTypes.string,
+  /**
+   * `cache` determines how the requests handles potentially cached
+   * responses.
+   *
+   * - `default`: Use the native platforms default strategy. `useProtocolCachePolicy` on iOS.
+   *
+   * - `reload`: The data for the URL will be loaded from the originating source.
+   * No existing cache data should be used to satisfy a URL load request.
+   *
+   * - `force-cache`: The existing cached data will be used to satisfy the request,
+   * regardless of its age or expiration date. If there is no existing data in the cache
+   * corresponding the request, the data is loaded from the originating source.
+   *
+   * - `only-if-cached`: The existing cache data will be used to satisfy a request, regardless of
+   * its age or expiration date. If there is no existing data in the cache corresponding
+   * to a URL load request, no attempt is made to load the data from the originating source,
+   * and the load is considered to have failed.
+   *
+   * @platform ios
+   */
+  cache: PropTypes.oneOf([
+    'default',
+    'reload',
+    'force-cache',
+    'only-if-cached',
+  ]),
+  /**
+   * `width` and `height` can be specified if known at build time, in which case
+   * these will be used to set the default `<Image/>` component dimensions.
+   */
+  width: PropTypes.number,
+  height: PropTypes.number,
+  /**
+   * `scale` is used to indicate the scale factor of the image. Defaults to 1.0 if
+   * unspecified, meaning that one image pixel equates to one display point / DIP.
+   */
+  scale: PropTypes.number,
+});
+
+const ImageSourcePropType = PropTypes.oneOfType([
+  ImageURISourcePropType,
+  // Opaque type returned by require('./image.jpg')
+  PropTypes.number,
+  // Multiple sources
+  PropTypes.arrayOf(ImageURISourcePropType),
+]);
+
+module.exports = ImageSourcePropType;

node_modules/react-native/Libraries/Image/ImageStore.js

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImageStore
+ * @flow
+ * @format
+ */
+'use strict';
+
+const RCTImageStoreManager = require('NativeModules').ImageStoreManager;
+
+class ImageStore {
+  /**
+   * Check if the ImageStore contains image data for the specified URI.
+   * @platform ios
+   */
+  static hasImageForTag(uri: string, callback: (hasImage: boolean) => void) {
+    if (RCTImageStoreManager.hasImageForTag) {
+      RCTImageStoreManager.hasImageForTag(uri, callback);
+    } else {
+      console.warn('hasImageForTag() not implemented');
+    }
+  }
+
+  /**
+   * Delete an image from the ImageStore. Images are stored in memory and
+   * must be manually removed when you are finished with them, otherwise they
+   * will continue to use up RAM until the app is terminated. It is safe to
+   * call `removeImageForTag()` without first calling `hasImageForTag()`, it
+   * will simply fail silently.
+   * @platform ios
+   */
+  static removeImageForTag(uri: string) {
+    if (RCTImageStoreManager.removeImageForTag) {
+      RCTImageStoreManager.removeImageForTag(uri);
+    } else {
+      console.warn('removeImageForTag() not implemented');
+    }
+  }
+
+  /**
+   * Stores a base64-encoded image in the ImageStore, and returns a URI that
+   * can be used to access or display the image later. Images are stored in
+   * memory only, and must be manually deleted when you are finished with
+   * them by calling `removeImageForTag()`.
+   *
+   * Note that it is very inefficient to transfer large quantities of binary
+   * data between JS and native code, so you should avoid calling this more
+   * than necessary.
+   * @platform ios
+   */
+  static addImageFromBase64(
+    base64ImageData: string,
+    success: (uri: string) => void,
+    failure: (error: any) => void,
+  ) {
+    RCTImageStoreManager.addImageFromBase64(base64ImageData, success, failure);
+  }
+
+  /**
+   * Retrieves the base64-encoded data for an image in the ImageStore. If the
+   * specified URI does not match an image in the store, the failure callback
+   * will be called.
+   *
+   * Note that it is very inefficient to transfer large quantities of binary
+   * data between JS and native code, so you should avoid calling this more
+   * than necessary. To display an image in the ImageStore, you can just pass
+   * the URI to an `<Image/>` component; there is no need to retrieve the
+   * base64 data.
+   */
+  static getBase64ForTag(
+    uri: string,
+    success: (base64ImageData: string) => void,
+    failure: (error: any) => void,
+  ) {
+    RCTImageStoreManager.getBase64ForTag(uri, success, failure);
+  }
+}
+
+module.exports = ImageStore;

node_modules/react-native/Libraries/Image/ImageStylePropTypes.js

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule ImageStylePropTypes
+ * @flow
+ * @format
+ */
+'use strict';
+
+var ColorPropType = require('ColorPropType');
+var ImageResizeMode = require('ImageResizeMode');
+var LayoutPropTypes = require('LayoutPropTypes');
+var ReactPropTypes = require('prop-types');
+var ShadowPropTypesIOS = require('ShadowPropTypesIOS');
+var TransformPropTypes = require('TransformPropTypes');
+
+var ImageStylePropTypes = {
+  ...LayoutPropTypes,
+  ...ShadowPropTypesIOS,
+  ...TransformPropTypes,
+  resizeMode: ReactPropTypes.oneOf(Object.keys(ImageResizeMode)),
+  backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
+  backgroundColor: ColorPropType,
+  borderColor: ColorPropType,
+  borderWidth: ReactPropTypes.number,
+  borderRadius: ReactPropTypes.number,
+  overflow: ReactPropTypes.oneOf(['visible', 'hidden']),
+
+  /**
+   * Changes the color of all the non-transparent pixels to the tintColor.
+   */
+  tintColor: ColorPropType,
+  opacity: ReactPropTypes.number,
+  /**
+   * When the image has rounded corners, specifying an overlayColor will
+   * cause the remaining space in the corners to be filled with a solid color.
+   * This is useful in cases which are not supported by the Android
+   * implementation of rounded corners:
+   *   - Certain resize modes, such as 'contain'
+   *   - Animated GIFs
+   *
+   * A typical way to use this prop is with images displayed on a solid
+   * background and setting the `overlayColor` to the same color
+   * as the background.
+   *
+   * For details of how this works under the hood, see
+   * http://frescolib.org/docs/rounded-corners-and-circles.html
+   *
+   * @platform android
+   */
+  overlayColor: ReactPropTypes.string,
+
+  // Android-Specific styles
+  borderTopLeftRadius: ReactPropTypes.number,
+  borderTopRightRadius: ReactPropTypes.number,
+  borderBottomLeftRadius: ReactPropTypes.number,
+  borderBottomRightRadius: ReactPropTypes.number,
+};
+
+module.exports = ImageStylePropTypes;

node_modules/react-native/Libraries/Image/RCTGIFImageDecoder.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTImageLoader.h>
+
+@interface RCTGIFImageDecoder : NSObject <RCTImageDataDecoder>
+
+@end

node_modules/react-native/Libraries/Image/RCTGIFImageDecoder.m

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTGIFImageDecoder.h"
+
+#import <ImageIO/ImageIO.h>
+#import <QuartzCore/QuartzCore.h>
+
+#import <React/RCTUtils.h>
+
+@implementation RCTGIFImageDecoder
+
+RCT_EXPORT_MODULE()
+
+- (BOOL)canDecodeImageData:(NSData *)imageData
+{
+  char header[7] = {};
+  [imageData getBytes:header length:6];
+
+  return !strcmp(header, "GIF87a") || !strcmp(header, "GIF89a");
+}
+
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler
+{
+  CGImageSourceRef imageSource = CGImageSourceCreateWithData((CFDataRef)imageData, NULL);
+  NSDictionary<NSString *, id> *properties = (__bridge_transfer NSDictionary *)CGImageSourceCopyProperties(imageSource, NULL);
+  NSUInteger loopCount = [properties[(id)kCGImagePropertyGIFDictionary][(id)kCGImagePropertyGIFLoopCount] unsignedIntegerValue];
+
+  UIImage *image = nil;
+  size_t imageCount = CGImageSourceGetCount(imageSource);
+  if (imageCount > 1) {
+
+    NSTimeInterval duration = 0;
+    NSMutableArray<NSNumber *> *delays = [NSMutableArray arrayWithCapacity:imageCount];
+    NSMutableArray<id /* CGIMageRef */> *images = [NSMutableArray arrayWithCapacity:imageCount];
+    for (size_t i = 0; i < imageCount; i++) {
+
+      CGImageRef imageRef = CGImageSourceCreateImageAtIndex(imageSource, i, NULL);
+      if (!image) {
+        image = [UIImage imageWithCGImage:imageRef scale:scale orientation:UIImageOrientationUp];
+      }
+
+      NSDictionary<NSString *, id> *frameProperties = (__bridge_transfer NSDictionary *)CGImageSourceCopyPropertiesAtIndex(imageSource, i, NULL);
+      NSDictionary<NSString *, id> *frameGIFProperties = frameProperties[(id)kCGImagePropertyGIFDictionary];
+
+      const NSTimeInterval kDelayTimeIntervalDefault = 0.1;
+      NSNumber *delayTime = frameGIFProperties[(id)kCGImagePropertyGIFUnclampedDelayTime] ?: frameGIFProperties[(id)kCGImagePropertyGIFDelayTime];
+      if (delayTime == nil) {
+        if (i == 0) {
+          delayTime = @(kDelayTimeIntervalDefault);
+        } else {
+          delayTime = delays[i - 1];
+        }
+      }
+
+      const NSTimeInterval kDelayTimeIntervalMinimum = 0.02;
+      if (delayTime.floatValue < (float)kDelayTimeIntervalMinimum - FLT_EPSILON) {
+        delayTime = @(kDelayTimeIntervalDefault);
+      }
+
+      duration += delayTime.doubleValue;
+      delays[i] = delayTime;
+      images[i] = (__bridge_transfer id)imageRef;
+    }
+    CFRelease(imageSource);
+
+    NSMutableArray<NSNumber *> *keyTimes = [NSMutableArray arrayWithCapacity:delays.count];
+    NSTimeInterval runningDuration = 0;
+    for (NSNumber *delayNumber in delays) {
+      [keyTimes addObject:@(runningDuration / duration)];
+      runningDuration += delayNumber.doubleValue;
+    }
+
+    [keyTimes addObject:@1.0];
+
+    // Create animation
+    CAKeyframeAnimation *animation = [CAKeyframeAnimation animationWithKeyPath:@"contents"];
+    animation.calculationMode = kCAAnimationDiscrete;
+    animation.repeatCount = loopCount == 0 ? HUGE_VALF : loopCount;
+    animation.keyTimes = keyTimes;
+    animation.values = images;
+    animation.duration = duration;
+    animation.removedOnCompletion = NO;
+    image.reactKeyframeAnimation = animation;
+
+  } else {
+
+    // Don't bother creating an animation
+    CGImageRef imageRef = CGImageSourceCreateImageAtIndex(imageSource, 0, NULL);
+    if (imageRef) {
+      image = [UIImage imageWithCGImage:imageRef scale:scale orientation:UIImageOrientationUp];
+      CFRelease(imageRef);
+    }
+    CFRelease(imageSource);
+  }
+
+  completionHandler(nil, image);
+  return ^{};
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTImage.xcodeproj/project.pbxproj

@@ -0,0 +1,514 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		1304D5AB1AA8C4A30002E2BE /* RCTImageView.m in Sources */ = {isa = PBXBuildFile; fileRef = 1304D5A81AA8C4A30002E2BE /* RCTImageView.m */; };
+		1304D5AC1AA8C4A30002E2BE /* RCTImageViewManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 1304D5AA1AA8C4A30002E2BE /* RCTImageViewManager.m */; };
+		1304D5B21AA8C50D0002E2BE /* RCTGIFImageDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 1304D5B11AA8C50D0002E2BE /* RCTGIFImageDecoder.m */; };
+		134B00A21B54232B00EC8DFB /* RCTImageUtils.m in Sources */ = {isa = PBXBuildFile; fileRef = 134B00A11B54232B00EC8DFB /* RCTImageUtils.m */; };
+		139A38841C4D587C00862840 /* RCTResizeMode.m in Sources */ = {isa = PBXBuildFile; fileRef = 139A38831C4D587C00862840 /* RCTResizeMode.m */; };
+		13EF7F7F1BC825B1003F47DD /* RCTLocalAssetImageLoader.m in Sources */ = {isa = PBXBuildFile; fileRef = 13EF7F7E1BC825B1003F47DD /* RCTLocalAssetImageLoader.m */; };
+		143879381AAD32A300F088A5 /* RCTImageLoader.m in Sources */ = {isa = PBXBuildFile; fileRef = 143879371AAD32A300F088A5 /* RCTImageLoader.m */; };
+		2D3B5F1A1D9B0D0400451313 /* RCTImageCache.m in Sources */ = {isa = PBXBuildFile; fileRef = CCD34C261D4B8FE900268922 /* RCTImageCache.m */; };
+		2D3B5F1B1D9B0D0700451313 /* RCTImageBlurUtils.m in Sources */ = {isa = PBXBuildFile; fileRef = EEF314711C9B0DD30049118E /* RCTImageBlurUtils.m */; };
+		2D3B5F1C1D9B0D1300451313 /* RCTResizeMode.m in Sources */ = {isa = PBXBuildFile; fileRef = 139A38831C4D587C00862840 /* RCTResizeMode.m */; };
+		2D3B5F1D1D9B0D1300451313 /* RCTLocalAssetImageLoader.m in Sources */ = {isa = PBXBuildFile; fileRef = 13EF7F7E1BC825B1003F47DD /* RCTLocalAssetImageLoader.m */; };
+		2D3B5F1E1D9B0D1300451313 /* RCTGIFImageDecoder.m in Sources */ = {isa = PBXBuildFile; fileRef = 1304D5B11AA8C50D0002E2BE /* RCTGIFImageDecoder.m */; };
+		2D3B5F1F1D9B0D1300451313 /* RCTImageEditingManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 354631671B69857700AA0B86 /* RCTImageEditingManager.m */; };
+		2D3B5F201D9B0D1300451313 /* RCTImageLoader.m in Sources */ = {isa = PBXBuildFile; fileRef = 143879371AAD32A300F088A5 /* RCTImageLoader.m */; };
+		2D3B5F211D9B0D1300451313 /* RCTImageView.m in Sources */ = {isa = PBXBuildFile; fileRef = 1304D5A81AA8C4A30002E2BE /* RCTImageView.m */; };
+		2D3B5F221D9B0D1300451313 /* RCTImageViewManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 1304D5AA1AA8C4A30002E2BE /* RCTImageViewManager.m */; };
+		2D3B5F231D9B0D1300451313 /* RCTImageStoreManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 35123E6A1B59C99D00EBAD80 /* RCTImageStoreManager.m */; };
+		2D3B5F241D9B0D1300451313 /* RCTImageUtils.m in Sources */ = {isa = PBXBuildFile; fileRef = 134B00A11B54232B00EC8DFB /* RCTImageUtils.m */; };
+		35123E6B1B59C99D00EBAD80 /* RCTImageStoreManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 35123E6A1B59C99D00EBAD80 /* RCTImageStoreManager.m */; };
+		354631681B69857700AA0B86 /* RCTImageEditingManager.m in Sources */ = {isa = PBXBuildFile; fileRef = 354631671B69857700AA0B86 /* RCTImageEditingManager.m */; };
+		3D302E181DF8228100D6DDAE /* RCTImageUtils.h in Copy Headers */ = {isa = PBXBuildFile; fileRef = 134B00A01B54232B00EC8DFB /* RCTImageUtils.h */; };
+		3D302F211DF8269200D6DDAE /* RCTImageUtils.h in Copy Headers */ = {isa = PBXBuildFile; fileRef = 134B00A01B54232B00EC8DFB /* RCTImageUtils.h */; };
+		3DA05A5A1EE0312600805843 /* RCTImageShadowView.h in Headers */ = {isa = PBXBuildFile; fileRef = 59AB09281EDE5DD1009F97B5 /* RCTImageShadowView.h */; };
+		3DA05A5B1EE0312900805843 /* RCTImageShadowView.m in Sources */ = {isa = PBXBuildFile; fileRef = 59AB09291EDE5DD1009F97B5 /* RCTImageShadowView.m */; };
+		3DED3A8A1DE6F79800336DD7 /* RCTGIFImageDecoder.h in Headers */ = {isa = PBXBuildFile; fileRef = 1304D5B01AA8C50D0002E2BE /* RCTGIFImageDecoder.h */; };
+		3DED3A8B1DE6F79800336DD7 /* RCTImageBlurUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = EEF314701C9B0DD30049118E /* RCTImageBlurUtils.h */; };
+		3DED3A8C1DE6F79800336DD7 /* RCTImageCache.h in Headers */ = {isa = PBXBuildFile; fileRef = CCD34C251D4B8FE900268922 /* RCTImageCache.h */; };
+		3DED3A8D1DE6F79800336DD7 /* RCTImageEditingManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 354631661B69857700AA0B86 /* RCTImageEditingManager.h */; };
+		3DED3A8E1DE6F79800336DD7 /* RCTImageLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 3D5FA63C1DE4B44A0058FD77 /* RCTImageLoader.h */; };
+		3DED3A8F1DE6F79800336DD7 /* RCTImageStoreManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 3D5FA63D1DE4B44A0058FD77 /* RCTImageStoreManager.h */; };
+		3DED3A901DE6F79800336DD7 /* RCTImageUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 134B00A01B54232B00EC8DFB /* RCTImageUtils.h */; };
+		3DED3A911DE6F79800336DD7 /* RCTImageView.h in Headers */ = {isa = PBXBuildFile; fileRef = 1304D5A71AA8C4A30002E2BE /* RCTImageView.h */; };
+		3DED3A921DE6F79800336DD7 /* RCTImageViewManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 1304D5A91AA8C4A30002E2BE /* RCTImageViewManager.h */; };
+		3DED3A931DE6F79800336DD7 /* RCTLocalAssetImageLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 13EF7F7D1BC825B1003F47DD /* RCTLocalAssetImageLoader.h */; };
+		3DED3A941DE6F79800336DD7 /* RCTResizeMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 3D5FA63E1DE4B44A0058FD77 /* RCTResizeMode.h */; };
+		3DED3A961DE6F7A400336DD7 /* RCTGIFImageDecoder.h in Headers */ = {isa = PBXBuildFile; fileRef = 1304D5B01AA8C50D0002E2BE /* RCTGIFImageDecoder.h */; };
+		3DED3A971DE6F7A400336DD7 /* RCTImageBlurUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = EEF314701C9B0DD30049118E /* RCTImageBlurUtils.h */; };
+		3DED3A981DE6F7A400336DD7 /* RCTImageCache.h in Headers */ = {isa = PBXBuildFile; fileRef = CCD34C251D4B8FE900268922 /* RCTImageCache.h */; };
+		3DED3A991DE6F7A400336DD7 /* RCTImageEditingManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 354631661B69857700AA0B86 /* RCTImageEditingManager.h */; };
+		3DED3A9A1DE6F7A400336DD7 /* RCTImageLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 3D5FA63C1DE4B44A0058FD77 /* RCTImageLoader.h */; };
+		3DED3A9B1DE6F7A400336DD7 /* RCTImageStoreManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 3D5FA63D1DE4B44A0058FD77 /* RCTImageStoreManager.h */; };
+		3DED3A9C1DE6F7A400336DD7 /* RCTImageUtils.h in Headers */ = {isa = PBXBuildFile; fileRef = 134B00A01B54232B00EC8DFB /* RCTImageUtils.h */; };
+		3DED3A9D1DE6F7A400336DD7 /* RCTImageView.h in Headers */ = {isa = PBXBuildFile; fileRef = 1304D5A71AA8C4A30002E2BE /* RCTImageView.h */; };
+		3DED3A9E1DE6F7A400336DD7 /* RCTImageViewManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 1304D5A91AA8C4A30002E2BE /* RCTImageViewManager.h */; };
+		3DED3A9F1DE6F7A400336DD7 /* RCTLocalAssetImageLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 13EF7F7D1BC825B1003F47DD /* RCTLocalAssetImageLoader.h */; };
+		3DED3AA01DE6F7A400336DD7 /* RCTResizeMode.h in Headers */ = {isa = PBXBuildFile; fileRef = 3D5FA63E1DE4B44A0058FD77 /* RCTResizeMode.h */; };
+		59AB092A1EDE5DD1009F97B5 /* RCTImageShadowView.h in Headers */ = {isa = PBXBuildFile; fileRef = 59AB09281EDE5DD1009F97B5 /* RCTImageShadowView.h */; };
+		59AB092B1EDE5DD1009F97B5 /* RCTImageShadowView.m in Sources */ = {isa = PBXBuildFile; fileRef = 59AB09291EDE5DD1009F97B5 /* RCTImageShadowView.m */; };
+		CCD34C271D4B8FE900268922 /* RCTImageCache.m in Sources */ = {isa = PBXBuildFile; fileRef = CCD34C261D4B8FE900268922 /* RCTImageCache.m */; };
+		EEF314721C9B0DD30049118E /* RCTImageBlurUtils.m in Sources */ = {isa = PBXBuildFile; fileRef = EEF314711C9B0DD30049118E /* RCTImageBlurUtils.m */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		3D302E171DF8225500D6DDAE /* Copy Headers */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = include/RCTImage;
+			dstSubfolderSpec = 16;
+			files = (
+				3D302E181DF8228100D6DDAE /* RCTImageUtils.h in Copy Headers */,
+			);
+			name = "Copy Headers";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		3D302F201DF8268700D6DDAE /* Copy Headers */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = include/RCTImage;
+			dstSubfolderSpec = 16;
+			files = (
+				3D302F211DF8269200D6DDAE /* RCTImageUtils.h in Copy Headers */,
+			);
+			name = "Copy Headers";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		1304D5A71AA8C4A30002E2BE /* RCTImageView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTImageView.h; sourceTree = "<group>"; };
+		1304D5A81AA8C4A30002E2BE /* RCTImageView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageView.m; sourceTree = "<group>"; };
+		1304D5A91AA8C4A30002E2BE /* RCTImageViewManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTImageViewManager.h; sourceTree = "<group>"; };
+		1304D5AA1AA8C4A30002E2BE /* RCTImageViewManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageViewManager.m; sourceTree = "<group>"; };
+		1304D5B01AA8C50D0002E2BE /* RCTGIFImageDecoder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTGIFImageDecoder.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		1304D5B11AA8C50D0002E2BE /* RCTGIFImageDecoder.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTGIFImageDecoder.m; sourceTree = "<group>"; };
+		134B00A01B54232B00EC8DFB /* RCTImageUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTImageUtils.h; sourceTree = "<group>"; };
+		134B00A11B54232B00EC8DFB /* RCTImageUtils.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageUtils.m; sourceTree = "<group>"; };
+		139A38831C4D587C00862840 /* RCTResizeMode.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTResizeMode.m; sourceTree = "<group>"; };
+		13EF7F7D1BC825B1003F47DD /* RCTLocalAssetImageLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTLocalAssetImageLoader.h; sourceTree = "<group>"; };
+		13EF7F7E1BC825B1003F47DD /* RCTLocalAssetImageLoader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTLocalAssetImageLoader.m; sourceTree = "<group>"; };
+		143879371AAD32A300F088A5 /* RCTImageLoader.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageLoader.m; sourceTree = "<group>"; };
+		2D2A283A1D9B042B00D4039D /* libRCTImage-tvOS.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libRCTImage-tvOS.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+		35123E6A1B59C99D00EBAD80 /* RCTImageStoreManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageStoreManager.m; sourceTree = "<group>"; };
+		354631661B69857700AA0B86 /* RCTImageEditingManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTImageEditingManager.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		354631671B69857700AA0B86 /* RCTImageEditingManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageEditingManager.m; sourceTree = "<group>"; };
+		3D5FA63C1DE4B44A0058FD77 /* RCTImageLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTImageLoader.h; sourceTree = "<group>"; };
+		3D5FA63D1DE4B44A0058FD77 /* RCTImageStoreManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTImageStoreManager.h; sourceTree = "<group>"; };
+		3D5FA63E1DE4B44A0058FD77 /* RCTResizeMode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTResizeMode.h; sourceTree = "<group>"; };
+		3D5FA68C1DE4BA290058FD77 /* libRCTNetwork.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libRCTNetwork.a; path = "../Network/build/Debug-iphoneos/libRCTNetwork.a"; sourceTree = "<group>"; };
+		58B5115D1A9E6B3D00147676 /* libRCTImage.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRCTImage.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		59AB09281EDE5DD1009F97B5 /* RCTImageShadowView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RCTImageShadowView.h; sourceTree = "<group>"; };
+		59AB09291EDE5DD1009F97B5 /* RCTImageShadowView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageShadowView.m; sourceTree = "<group>"; };
+		CCD34C251D4B8FE900268922 /* RCTImageCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTImageCache.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		CCD34C261D4B8FE900268922 /* RCTImageCache.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageCache.m; sourceTree = "<group>"; };
+		EEF314701C9B0DD30049118E /* RCTImageBlurUtils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTImageBlurUtils.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		EEF314711C9B0DD30049118E /* RCTImageBlurUtils.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTImageBlurUtils.m; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXGroup section */
+		3D5FA68B1DE4BA290058FD77 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				3D5FA68C1DE4BA290058FD77 /* libRCTNetwork.a */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		58B511541A9E6B3D00147676 = {
+			isa = PBXGroup;
+			children = (
+				3D5FA68B1DE4BA290058FD77 /* Frameworks */,
+				58B5115E1A9E6B3D00147676 /* Products */,
+				1304D5B01AA8C50D0002E2BE /* RCTGIFImageDecoder.h */,
+				1304D5B11AA8C50D0002E2BE /* RCTGIFImageDecoder.m */,
+				EEF314701C9B0DD30049118E /* RCTImageBlurUtils.h */,
+				EEF314711C9B0DD30049118E /* RCTImageBlurUtils.m */,
+				CCD34C251D4B8FE900268922 /* RCTImageCache.h */,
+				CCD34C261D4B8FE900268922 /* RCTImageCache.m */,
+				354631661B69857700AA0B86 /* RCTImageEditingManager.h */,
+				354631671B69857700AA0B86 /* RCTImageEditingManager.m */,
+				3D5FA63C1DE4B44A0058FD77 /* RCTImageLoader.h */,
+				143879371AAD32A300F088A5 /* RCTImageLoader.m */,
+				59AB09281EDE5DD1009F97B5 /* RCTImageShadowView.h */,
+				59AB09291EDE5DD1009F97B5 /* RCTImageShadowView.m */,
+				3D5FA63D1DE4B44A0058FD77 /* RCTImageStoreManager.h */,
+				35123E6A1B59C99D00EBAD80 /* RCTImageStoreManager.m */,
+				134B00A01B54232B00EC8DFB /* RCTImageUtils.h */,
+				134B00A11B54232B00EC8DFB /* RCTImageUtils.m */,
+				1304D5A71AA8C4A30002E2BE /* RCTImageView.h */,
+				1304D5A81AA8C4A30002E2BE /* RCTImageView.m */,
+				1304D5A91AA8C4A30002E2BE /* RCTImageViewManager.h */,
+				1304D5AA1AA8C4A30002E2BE /* RCTImageViewManager.m */,
+				13EF7F7D1BC825B1003F47DD /* RCTLocalAssetImageLoader.h */,
+				13EF7F7E1BC825B1003F47DD /* RCTLocalAssetImageLoader.m */,
+				3D5FA63E1DE4B44A0058FD77 /* RCTResizeMode.h */,
+				139A38831C4D587C00862840 /* RCTResizeMode.m */,
+			);
+			indentWidth = 2;
+			sourceTree = "<group>";
+			tabWidth = 2;
+			usesTabs = 0;
+		};
+		58B5115E1A9E6B3D00147676 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				58B5115D1A9E6B3D00147676 /* libRCTImage.a */,
+				2D2A283A1D9B042B00D4039D /* libRCTImage-tvOS.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		3DED3A891DE6F78800336DD7 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3DED3A8A1DE6F79800336DD7 /* RCTGIFImageDecoder.h in Headers */,
+				3DED3A901DE6F79800336DD7 /* RCTImageUtils.h in Headers */,
+				3DED3A8B1DE6F79800336DD7 /* RCTImageBlurUtils.h in Headers */,
+				3DED3A8C1DE6F79800336DD7 /* RCTImageCache.h in Headers */,
+				3DED3A8D1DE6F79800336DD7 /* RCTImageEditingManager.h in Headers */,
+				3DED3A8E1DE6F79800336DD7 /* RCTImageLoader.h in Headers */,
+				3DED3A8F1DE6F79800336DD7 /* RCTImageStoreManager.h in Headers */,
+				59AB092A1EDE5DD1009F97B5 /* RCTImageShadowView.h in Headers */,
+				3DED3A911DE6F79800336DD7 /* RCTImageView.h in Headers */,
+				3DED3A921DE6F79800336DD7 /* RCTImageViewManager.h in Headers */,
+				3DED3A931DE6F79800336DD7 /* RCTLocalAssetImageLoader.h in Headers */,
+				3DED3A941DE6F79800336DD7 /* RCTResizeMode.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		3DED3A951DE6F79D00336DD7 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3DED3A961DE6F7A400336DD7 /* RCTGIFImageDecoder.h in Headers */,
+				3DED3A971DE6F7A400336DD7 /* RCTImageBlurUtils.h in Headers */,
+				3DED3A981DE6F7A400336DD7 /* RCTImageCache.h in Headers */,
+				3DED3A991DE6F7A400336DD7 /* RCTImageEditingManager.h in Headers */,
+				3DED3A9A1DE6F7A400336DD7 /* RCTImageLoader.h in Headers */,
+				3DED3A9B1DE6F7A400336DD7 /* RCTImageStoreManager.h in Headers */,
+				3DED3A9C1DE6F7A400336DD7 /* RCTImageUtils.h in Headers */,
+				3DA05A5A1EE0312600805843 /* RCTImageShadowView.h in Headers */,
+				3DED3A9D1DE6F7A400336DD7 /* RCTImageView.h in Headers */,
+				3DED3A9E1DE6F7A400336DD7 /* RCTImageViewManager.h in Headers */,
+				3DED3A9F1DE6F7A400336DD7 /* RCTLocalAssetImageLoader.h in Headers */,
+				3DED3AA01DE6F7A400336DD7 /* RCTResizeMode.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		2D2A28391D9B042B00D4039D /* RCTImage-tvOS */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 2D2A28421D9B042B00D4039D /* Build configuration list for PBXNativeTarget "RCTImage-tvOS" */;
+			buildPhases = (
+				3DED3A951DE6F79D00336DD7 /* Headers */,
+				3D302F201DF8268700D6DDAE /* Copy Headers */,
+				2D2A28361D9B042B00D4039D /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "RCTImage-tvOS";
+			productName = "RCTImage-tvOS";
+			productReference = 2D2A283A1D9B042B00D4039D /* libRCTImage-tvOS.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		58B5115C1A9E6B3D00147676 /* RCTImage */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 58B511711A9E6B3D00147676 /* Build configuration list for PBXNativeTarget "RCTImage" */;
+			buildPhases = (
+				3DED3A891DE6F78800336DD7 /* Headers */,
+				3D302E171DF8225500D6DDAE /* Copy Headers */,
+				58B511591A9E6B3D00147676 /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = RCTImage;
+			productName = RCTNetworkImage;
+			productReference = 58B5115D1A9E6B3D00147676 /* libRCTImage.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		58B511551A9E6B3D00147676 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0810;
+				ORGANIZATIONNAME = Facebook;
+				TargetAttributes = {
+					2D2A28391D9B042B00D4039D = {
+						CreatedOnToolsVersion = 8.0;
+						ProvisioningStyle = Automatic;
+					};
+					58B5115C1A9E6B3D00147676 = {
+						CreatedOnToolsVersion = 6.1.1;
+					};
+				};
+			};
+			buildConfigurationList = 58B511581A9E6B3D00147676 /* Build configuration list for PBXProject "RCTImage" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 58B511541A9E6B3D00147676;
+			productRefGroup = 58B5115E1A9E6B3D00147676 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				58B5115C1A9E6B3D00147676 /* RCTImage */,
+				2D2A28391D9B042B00D4039D /* RCTImage-tvOS */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		2D2A28361D9B042B00D4039D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				2D3B5F231D9B0D1300451313 /* RCTImageStoreManager.m in Sources */,
+				2D3B5F1A1D9B0D0400451313 /* RCTImageCache.m in Sources */,
+				2D3B5F1D1D9B0D1300451313 /* RCTLocalAssetImageLoader.m in Sources */,
+				2D3B5F1F1D9B0D1300451313 /* RCTImageEditingManager.m in Sources */,
+				2D3B5F1E1D9B0D1300451313 /* RCTGIFImageDecoder.m in Sources */,
+				2D3B5F1C1D9B0D1300451313 /* RCTResizeMode.m in Sources */,
+				2D3B5F221D9B0D1300451313 /* RCTImageViewManager.m in Sources */,
+				2D3B5F211D9B0D1300451313 /* RCTImageView.m in Sources */,
+				3DA05A5B1EE0312900805843 /* RCTImageShadowView.m in Sources */,
+				2D3B5F201D9B0D1300451313 /* RCTImageLoader.m in Sources */,
+				2D3B5F1B1D9B0D0700451313 /* RCTImageBlurUtils.m in Sources */,
+				2D3B5F241D9B0D1300451313 /* RCTImageUtils.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		58B511591A9E6B3D00147676 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				35123E6B1B59C99D00EBAD80 /* RCTImageStoreManager.m in Sources */,
+				1304D5AC1AA8C4A30002E2BE /* RCTImageViewManager.m in Sources */,
+				1304D5B21AA8C50D0002E2BE /* RCTGIFImageDecoder.m in Sources */,
+				143879381AAD32A300F088A5 /* RCTImageLoader.m in Sources */,
+				354631681B69857700AA0B86 /* RCTImageEditingManager.m in Sources */,
+				139A38841C4D587C00862840 /* RCTResizeMode.m in Sources */,
+				1304D5AB1AA8C4A30002E2BE /* RCTImageView.m in Sources */,
+				EEF314721C9B0DD30049118E /* RCTImageBlurUtils.m in Sources */,
+				59AB092B1EDE5DD1009F97B5 /* RCTImageShadowView.m in Sources */,
+				13EF7F7F1BC825B1003F47DD /* RCTLocalAssetImageLoader.m in Sources */,
+				134B00A21B54232B00EC8DFB /* RCTImageUtils.m in Sources */,
+				CCD34C271D4B8FE900268922 /* RCTImageCache.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		2D2A28401D9B042B00D4039D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_SUSPICIOUS_MOVES = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = /usr/local/include/RCTImage;
+				SDKROOT = appletvos;
+				TVOS_DEPLOYMENT_TARGET = 9.2;
+			};
+			name = Debug;
+		};
+		2D2A28411D9B042B00D4039D /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_SUSPICIOUS_MOVES = YES;
+				COPY_PHASE_STRIP = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = /usr/local/include/RCTImage;
+				SDKROOT = appletvos;
+				TVOS_DEPLOYMENT_TARGET = 9.2;
+			};
+			name = Release;
+		};
+		58B5116F1A9E6B3D00147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Debug;
+		};
+		58B511701A9E6B3D00147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				VALIDATE_PRODUCT = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Release;
+		};
+		58B511721A9E6B3D00147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RCTImage;
+				PUBLIC_HEADERS_FOLDER_PATH = /usr/local/include/RCTImage;
+				RUN_CLANG_STATIC_ANALYZER = YES;
+			};
+			name = Debug;
+		};
+		58B511731A9E6B3D00147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = RCTImage;
+				PUBLIC_HEADERS_FOLDER_PATH = /usr/local/include/RCTImage;
+				RUN_CLANG_STATIC_ANALYZER = NO;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		2D2A28421D9B042B00D4039D /* Build configuration list for PBXNativeTarget "RCTImage-tvOS" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				2D2A28401D9B042B00D4039D /* Debug */,
+				2D2A28411D9B042B00D4039D /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		58B511581A9E6B3D00147676 /* Build configuration list for PBXProject "RCTImage" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B5116F1A9E6B3D00147676 /* Debug */,
+				58B511701A9E6B3D00147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		58B511711A9E6B3D00147676 /* Build configuration list for PBXNativeTarget "RCTImage" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511721A9E6B3D00147676 /* Debug */,
+				58B511731A9E6B3D00147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 58B511551A9E6B3D00147676 /* Project object */;
+}

node_modules/react-native/Libraries/Image/RCTImageBlurUtils.h

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import <Accelerate/Accelerate.h>
+#import <UIKit/UIKit.h>
+
+#import <React/RCTDefines.h>
+
+RCT_EXTERN UIImage *RCTBlurredImageWithRadius(UIImage *inputImage, CGFloat radius);

node_modules/react-native/Libraries/Image/RCTImageBlurUtils.m

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageBlurUtils.h"
+
+UIImage *RCTBlurredImageWithRadius(UIImage *inputImage, CGFloat radius)
+{
+  CGImageRef imageRef = inputImage.CGImage;
+  CGFloat imageScale = inputImage.scale;
+  UIImageOrientation imageOrientation = inputImage.imageOrientation;
+
+  // Image must be nonzero size
+  if (CGImageGetWidth(imageRef) * CGImageGetHeight(imageRef) == 0) {
+    return inputImage;
+  }
+
+  //convert to ARGB if it isn't
+  if (CGImageGetBitsPerPixel(imageRef) != 32 ||
+      CGImageGetBitsPerComponent(imageRef) != 8 ||
+      !((CGImageGetBitmapInfo(imageRef) & kCGBitmapAlphaInfoMask))) {
+    UIGraphicsBeginImageContextWithOptions(inputImage.size, NO, inputImage.scale);
+    [inputImage drawAtPoint:CGPointZero];
+    imageRef = UIGraphicsGetImageFromCurrentImageContext().CGImage;
+    UIGraphicsEndImageContext();
+  }
+
+  vImage_Buffer buffer1, buffer2;
+  buffer1.width = buffer2.width = CGImageGetWidth(imageRef);
+  buffer1.height = buffer2.height = CGImageGetHeight(imageRef);
+  buffer1.rowBytes = buffer2.rowBytes = CGImageGetBytesPerRow(imageRef);
+  size_t bytes = buffer1.rowBytes * buffer1.height;
+  buffer1.data = malloc(bytes);
+  buffer2.data = malloc(bytes);
+
+  // A description of how to compute the box kernel width from the Gaussian
+  // radius (aka standard deviation) appears in the SVG spec:
+  // http://www.w3.org/TR/SVG/filters.html#feGaussianBlurElement
+  uint32_t boxSize = floor((radius * imageScale * 3 * sqrt(2 * M_PI) / 4 + 0.5) / 2);
+  boxSize |= 1; // Ensure boxSize is odd
+
+  //create temp buffer
+  void *tempBuffer = malloc((size_t)vImageBoxConvolve_ARGB8888(&buffer1, &buffer2, NULL, 0, 0, boxSize, boxSize,
+                                                               NULL, kvImageEdgeExtend + kvImageGetTempBufferSize));
+
+  //copy image data
+  CFDataRef dataSource = CGDataProviderCopyData(CGImageGetDataProvider(imageRef));
+  memcpy(buffer1.data, CFDataGetBytePtr(dataSource), bytes);
+  CFRelease(dataSource);
+
+  //perform blur
+  vImageBoxConvolve_ARGB8888(&buffer1, &buffer2, tempBuffer, 0, 0, boxSize, boxSize, NULL, kvImageEdgeExtend);
+  vImageBoxConvolve_ARGB8888(&buffer2, &buffer1, tempBuffer, 0, 0, boxSize, boxSize, NULL, kvImageEdgeExtend);
+  vImageBoxConvolve_ARGB8888(&buffer1, &buffer2, tempBuffer, 0, 0, boxSize, boxSize, NULL, kvImageEdgeExtend);
+
+  //free buffers
+  free(buffer2.data);
+  free(tempBuffer);
+
+  //create image context from buffer
+  CGContextRef ctx = CGBitmapContextCreate(buffer1.data, buffer1.width, buffer1.height,
+                                           8, buffer1.rowBytes, CGImageGetColorSpace(imageRef),
+                                           CGImageGetBitmapInfo(imageRef));
+
+  //create image from context
+  imageRef = CGBitmapContextCreateImage(ctx);
+  UIImage *outputImage = [UIImage imageWithCGImage:imageRef scale:imageScale orientation:imageOrientation];
+  CGImageRelease(imageRef);
+  CGContextRelease(ctx);
+  free(buffer1.data);
+  return outputImage;
+}

node_modules/react-native/Libraries/Image/RCTImageCache.h

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTImageLoader.h>
+
+@interface RCTImageCache : NSObject <RCTImageCache>
+@end

node_modules/react-native/Libraries/Image/RCTImageCache.m

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageCache.h"
+
+#import <objc/runtime.h>
+
+#import <ImageIO/ImageIO.h>
+
+#import <React/RCTConvert.h>
+#import <React/RCTNetworking.h>
+#import <React/RCTUtils.h>
+
+#import "RCTImageUtils.h"
+
+static const NSUInteger RCTMaxCachableDecodedImageSizeInBytes = 1048576; // 1MB
+
+static NSString *RCTCacheKeyForImage(NSString *imageTag, CGSize size, CGFloat scale,
+                                     RCTResizeMode resizeMode, NSString *responseDate)
+{
+    return [NSString stringWithFormat:@"%@|%g|%g|%g|%lld|%@",
+            imageTag, size.width, size.height, scale, (long long)resizeMode, responseDate];
+}
+
+@implementation RCTImageCache
+{
+  NSOperationQueue *_imageDecodeQueue;
+  NSCache *_decodedImageCache;
+}
+
+- (instancetype)init
+{
+  _decodedImageCache = [NSCache new];
+  _decodedImageCache.totalCostLimit = 5 * 1024 * 1024; // 5MB
+
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(clearCache)
+                                               name:UIApplicationDidReceiveMemoryWarningNotification
+                                             object:nil];
+  [[NSNotificationCenter defaultCenter] addObserver:self
+                                           selector:@selector(clearCache)
+                                               name:UIApplicationWillResignActiveNotification
+                                             object:nil];
+
+  return self;
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)clearCache
+{
+  [_decodedImageCache removeAllObjects];
+}
+
+- (void)addImageToCache:(UIImage *)image
+                 forKey:(NSString *)cacheKey
+{
+  if (!image) {
+    return;
+  }
+  CGFloat bytes = image.size.width * image.size.height * image.scale * image.scale * 4;
+  if (bytes <= RCTMaxCachableDecodedImageSizeInBytes) {
+    [self->_decodedImageCache setObject:image
+                                 forKey:cacheKey
+                                   cost:bytes];
+  }
+}
+
+- (UIImage *)imageForUrl:(NSString *)url
+                    size:(CGSize)size
+                   scale:(CGFloat)scale
+              resizeMode:(RCTResizeMode)resizeMode
+            responseDate:(NSString *)responseDate
+{
+  NSString *cacheKey = RCTCacheKeyForImage(url, size, scale, resizeMode, responseDate);
+  return [_decodedImageCache objectForKey:cacheKey];
+}
+
+- (void)addImageToCache:(UIImage *)image
+                    URL:(NSString *)url
+                   size:(CGSize)size
+                  scale:(CGFloat)scale
+             resizeMode:(RCTResizeMode)resizeMode
+           responseDate:(NSString *)responseDate
+{
+  NSString *cacheKey = RCTCacheKeyForImage(url, size, scale, resizeMode, responseDate);
+  return [self addImageToCache:image forKey:cacheKey];
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTImageEditingManager.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCTImageEditingManager : NSObject <RCTBridgeModule>
+
+@end

node_modules/react-native/Libraries/Image/RCTImageEditingManager.m

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageEditingManager.h"
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTConvert.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#import "RCTImageLoader.h"
+#import "RCTImageStoreManager.h"
+#import "RCTImageUtils.h"
+
+@implementation RCTImageEditingManager
+
+RCT_EXPORT_MODULE()
+
+@synthesize bridge = _bridge;
+
+/**
+ * Crops an image and adds the result to the image store.
+ *
+ * @param imageRequest An image URL
+ * @param cropData Dictionary with `offset`, `size` and `displaySize`.
+ *        `offset` and `size` are relative to the full-resolution image size.
+ *        `displaySize` is an optimization - if specified, the image will
+ *        be scaled down to `displaySize` rather than `size`.
+ *        All units are in px (not points).
+ */
+RCT_EXPORT_METHOD(cropImage:(NSURLRequest *)imageRequest
+                  cropData:(NSDictionary *)cropData
+                  successCallback:(RCTResponseSenderBlock)successCallback
+                  errorCallback:(RCTResponseErrorBlock)errorCallback)
+{
+  CGRect rect = {
+    [RCTConvert CGPoint:cropData[@"offset"]],
+    [RCTConvert CGSize:cropData[@"size"]]
+  };
+
+  [_bridge.imageLoader loadImageWithURLRequest:imageRequest callback:^(NSError *error, UIImage *image) {
+    if (error) {
+      errorCallback(error);
+      return;
+    }
+
+    // Crop image
+    CGSize targetSize = rect.size;
+    CGRect targetRect = {{-rect.origin.x, -rect.origin.y}, image.size};
+    CGAffineTransform transform = RCTTransformFromTargetRect(image.size, targetRect);
+    UIImage *croppedImage = RCTTransformImage(image, targetSize, image.scale, transform);
+
+    // Scale image
+    if (cropData[@"displaySize"]) {
+      targetSize = [RCTConvert CGSize:cropData[@"displaySize"]]; // in pixels
+      RCTResizeMode resizeMode = [RCTConvert RCTResizeMode:cropData[@"resizeMode"] ?: @"contain"];
+      targetRect = RCTTargetRect(croppedImage.size, targetSize, 1, resizeMode);
+      transform = RCTTransformFromTargetRect(croppedImage.size, targetRect);
+      croppedImage = RCTTransformImage(croppedImage, targetSize, image.scale, transform);
+    }
+
+    // Store image
+    [self->_bridge.imageStoreManager storeImage:croppedImage withBlock:^(NSString *croppedImageTag) {
+      if (!croppedImageTag) {
+        NSString *errorMessage = @"Error storing cropped image in RCTImageStoreManager";
+        RCTLogWarn(@"%@", errorMessage);
+        errorCallback(RCTErrorWithMessage(errorMessage));
+        return;
+      }
+      successCallback(@[croppedImageTag]);
+    }];
+  }];
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTImageLoader.h

@@ -0,0 +1,246 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTResizeMode.h>
+#import <React/RCTURLRequestHandler.h>
+
+typedef void (^RCTImageLoaderProgressBlock)(int64_t progress, int64_t total);
+typedef void (^RCTImageLoaderPartialLoadBlock)(UIImage *image);
+typedef void (^RCTImageLoaderCompletionBlock)(NSError *error, UIImage *image);
+typedef dispatch_block_t RCTImageLoaderCancellationBlock;
+
+/**
+ * Provides an interface to use for providing a image caching strategy.
+ */
+@protocol RCTImageCache <NSObject>
+
+- (UIImage *)imageForUrl:(NSString *)url
+                    size:(CGSize)size
+                   scale:(CGFloat)scale
+              resizeMode:(RCTResizeMode)resizeMode
+            responseDate:(NSString *)responseDate;
+
+- (void)addImageToCache:(UIImage *)image
+                    URL:(NSString *)url
+                   size:(CGSize)size
+                  scale:(CGFloat)scale
+             resizeMode:(RCTResizeMode)resizeMode
+           responseDate:(NSString *)responseDate;
+
+@end
+
+/**
+ * If available, RCTImageRedirectProtocol is invoked before loading an asset.
+ * Implementation should return either a new URL or nil when redirection is
+ * not needed.
+ */
+
+@protocol RCTImageRedirectProtocol
+
+- (NSURL *)redirectAssetsURL:(NSURL *)URL;
+
+@end
+
+@interface UIImage (React)
+
+@property (nonatomic, copy) CAKeyframeAnimation *reactKeyframeAnimation;
+
+@end
+
+@interface RCTImageLoader : NSObject <RCTBridgeModule, RCTURLRequestHandler>
+
+/**
+ * The maximum number of concurrent image loading tasks. Loading and decoding
+ * images can consume a lot of memory, so setting this to a higher value may
+ * cause memory to spike. If you are seeing out-of-memory crashes, try reducing
+ * this value.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentLoadingTasks;
+
+/**
+ * The maximum number of concurrent image decoding tasks. Decoding large
+ * images can be especially CPU and memory intensive, so if your are decoding a
+ * lot of large images in your app, you may wish to adjust this value.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentDecodingTasks;
+
+/**
+ * Decoding large images can use a lot of memory, and potentially cause the app
+ * to crash. This value allows you to throttle the amount of memory used by the
+ * decoder independently of the number of concurrent threads. This means you can
+ * still decode a lot of small images in parallel, without allowing the decoder
+ * to try to decompress multiple huge images at once. Note that this value is
+ * only a hint, and not an indicator of the total memory used by the app.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentDecodingBytes;
+
+- (instancetype)init;
+- (instancetype)initWithRedirectDelegate:(id<RCTImageRedirectProtocol>)redirectDelegate NS_DESIGNATED_INITIALIZER;
+
+/**
+ * Loads the specified image at the highest available resolution.
+ * Can be called from any thread, will call back on an unspecified thread.
+ */
+- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                  callback:(RCTImageLoaderCompletionBlock)callback;
+
+/**
+ * As above, but includes target `size`, `scale` and `resizeMode`, which are used to
+ * select the optimal dimensions for the loaded image. The `clipped` option
+ * controls whether the image will be clipped to fit the specified size exactly,
+ * or if the original aspect ratio should be retained.
+ * `partialLoadBlock` is meant for custom image loaders that do not ship with the core RN library.
+ * It is meant to be called repeatedly while loading the image as higher quality versions are decoded,
+ * for instance with progressive JPEGs.
+ */
+- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                      size:(CGSize)size
+                                                     scale:(CGFloat)scale
+                                                   clipped:(BOOL)clipped
+                                                resizeMode:(RCTResizeMode)resizeMode
+                                             progressBlock:(RCTImageLoaderProgressBlock)progressBlock
+                                          partialLoadBlock:(RCTImageLoaderPartialLoadBlock)partialLoadBlock
+                                           completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
+
+/**
+ * Finds an appropriate image decoder and passes the target `size`, `scale` and
+ * `resizeMode` for optimal image decoding.  The `clipped` option controls
+ * whether the image will be clipped to fit the specified size exactly, or
+ * if the original aspect ratio should be retained. Can be called from any
+ * thread, will call callback on an unspecified thread.
+ */
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                           clipped:(BOOL)clipped
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                   completionBlock:(RCTImageLoaderCompletionBlock)completionBlock;
+
+/**
+ * Get image size, in pixels. This method will do the least work possible to get
+ * the information, and won't decode the image if it doesn't have to.
+ */
+- (RCTImageLoaderCancellationBlock)getImageSizeForURLRequest:(NSURLRequest *)imageURLRequest
+                                                       block:(void(^)(NSError *error, CGSize size))completionBlock;
+
+/**
+ * Allows developers to set their own caching implementation for
+ * decoded images as long as it conforms to the RCTImageCacheDelegate
+ * protocol. This method should be called in bridgeDidInitializeModule.
+ */
+- (void)setImageCache:(id<RCTImageCache>)cache;
+
+@end
+
+@interface RCTBridge (RCTImageLoader)
+
+/**
+ * The shared image loader instance
+ */
+@property (nonatomic, readonly) RCTImageLoader *imageLoader;
+
+@end
+
+/**
+ * Provides the interface needed to register an image loader. Image data
+ * loaders are also bridge modules, so should be registered using
+ * RCT_EXPORT_MODULE().
+ */
+@protocol RCTImageURLLoader <RCTBridgeModule>
+
+/**
+ * Indicates whether this data loader is capable of processing the specified
+ * request URL. Typically the handler would examine the scheme/protocol of the
+ * URL to determine this.
+ */
+- (BOOL)canLoadImageURL:(NSURL *)requestURL;
+
+/**
+ * Send a network request to load the request URL. The method should call the
+ * progressHandler (if applicable) and the completionHandler when the request
+ * has finished. The method should also return a cancellation block, if
+ * applicable.
+ */
+- (RCTImageLoaderCancellationBlock)loadImageForURL:(NSURL *)imageURL
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                   progressHandler:(RCTImageLoaderProgressBlock)progressHandler
+                                partialLoadHandler:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
+                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler;
+
+@optional
+
+/**
+ * If more than one RCTImageURLLoader responds YES to `-canLoadImageURL:`
+ * then `loaderPriority` is used to determine which one to use. The loader
+ * with the highest priority will be selected. Default priority is zero. If
+ * two or more valid loaders have the same priority, the selection order is
+ * undefined.
+ */
+- (float)loaderPriority;
+
+/**
+ * If the loader must be called on the serial url cache queue, and whether the completion
+ * block should be dispatched off the main thread. If this is NO, the loader will be
+ * called from the main queue. Defaults to YES.
+ *
+ * Use with care: disabling scheduling will reduce RCTImageLoader's ability to throttle
+ * network requests.
+ */
+- (BOOL)requiresScheduling;
+
+/**
+ * If images loaded by the loader should be cached in the decoded image cache.
+ * Defaults to YES.
+ */
+- (BOOL)shouldCacheLoadedImages;
+
+@end
+
+/**
+ * Provides the interface needed to register an image decoder. Image decoders
+ * are also bridge modules, so should be registered using RCT_EXPORT_MODULE().
+ */
+@protocol RCTImageDataDecoder <RCTBridgeModule>
+
+/**
+ * Indicates whether this handler is capable of decoding the specified data.
+ * Typically the handler would examine some sort of header data to determine
+ * this.
+ */
+- (BOOL)canDecodeImageData:(NSData *)imageData;
+
+/**
+ * Decode an image from the data object. The method should call the
+ * completionHandler when the decoding operation  has finished. The method
+ * should also return a cancellation block, if applicable.
+ *
+ * If you provide a custom image decoder, you most implement scheduling yourself,
+ * to avoid decoding large amounts of images at the same time.
+ */
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)imageData
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                 completionHandler:(RCTImageLoaderCompletionBlock)completionHandler;
+
+@optional
+
+/**
+ * If more than one RCTImageDataDecoder responds YES to `-canDecodeImageData:`
+ * then `decoderPriority` is used to determine which one to use. The decoder
+ * with the highest priority will be selected. Default priority is zero.
+ * If two or more valid decoders have the same priority, the selection order is
+ * undefined.
+ */
+- (float)decoderPriority;
+
+@end

node_modules/react-native/Libraries/Image/RCTImageLoader.m

@@ -0,0 +1,866 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <stdatomic.h>
+#import <objc/runtime.h>
+
+#import <ImageIO/ImageIO.h>
+
+#import <React/RCTConvert.h>
+#import <React/RCTDefines.h>
+#import <React/RCTImageLoader.h>
+#import <React/RCTLog.h>
+#import <React/RCTNetworking.h>
+#import <React/RCTUtils.h>
+
+#import "RCTImageCache.h"
+#import "RCTImageUtils.h"
+
+@implementation UIImage (React)
+
+- (CAKeyframeAnimation *)reactKeyframeAnimation
+{
+    return objc_getAssociatedObject(self, _cmd);
+}
+
+- (void)setReactKeyframeAnimation:(CAKeyframeAnimation *)reactKeyframeAnimation
+{
+    objc_setAssociatedObject(self, @selector(reactKeyframeAnimation), reactKeyframeAnimation, OBJC_ASSOCIATION_COPY_NONATOMIC);
+}
+
+@end
+
+@implementation RCTImageLoader
+{
+    NSArray<id<RCTImageURLLoader>> *_loaders;
+    NSArray<id<RCTImageDataDecoder>> *_decoders;
+    NSOperationQueue *_imageDecodeQueue;
+    dispatch_queue_t _URLRequestQueue;
+    id<RCTImageCache> _imageCache;
+    NSMutableArray *_pendingTasks;
+    NSInteger _activeTasks;
+    NSMutableArray *_pendingDecodes;
+    NSInteger _scheduledDecodes;
+    NSUInteger _activeBytes;
+  __weak id<RCTImageRedirectProtocol> _redirectDelegate;
+}
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
+- (instancetype)init
+{
+  return [self initWithRedirectDelegate:nil];
+}
+
+- (instancetype)initWithRedirectDelegate:(id<RCTImageRedirectProtocol>)redirectDelegate
+{
+    if (self = [super init]) {
+        _redirectDelegate = redirectDelegate;
+    }
+    return self;
+}
+
+- (void)setUp
+{
+    // Set defaults
+    _maxConcurrentLoadingTasks = _maxConcurrentLoadingTasks ?: 4;
+    _maxConcurrentDecodingTasks = _maxConcurrentDecodingTasks ?: 2;
+    _maxConcurrentDecodingBytes = _maxConcurrentDecodingBytes ?: 30 * 1024 * 1024; // 30MB
+
+    _URLRequestQueue = dispatch_queue_create("com.facebook.react.ImageLoaderURLRequestQueue", DISPATCH_QUEUE_SERIAL);
+}
+
+- (float)handlerPriority
+{
+    return 2;
+}
+
+- (id<RCTImageCache>)imageCache
+{
+    if (!_imageCache) {
+        //set up with default cache
+        _imageCache = [RCTImageCache new];
+    }
+    return _imageCache;
+}
+
+- (void)setImageCache:(id<RCTImageCache>)cache
+{
+    if (_imageCache) {
+        RCTLogWarn(@"RCTImageCache was already set and has now been overriden.");
+    }
+    _imageCache = cache;
+}
+
+- (id<RCTImageURLLoader>)imageURLLoaderForURL:(NSURL *)URL
+{
+    if (!_maxConcurrentLoadingTasks) {
+        [self setUp];
+    }
+
+    if (!_loaders) {
+        // Get loaders, sorted in reverse priority order (highest priority first)
+        RCTAssert(_bridge, @"Bridge not set");
+        _loaders = [[_bridge modulesConformingToProtocol:@protocol(RCTImageURLLoader)] sortedArrayUsingComparator:^NSComparisonResult(id<RCTImageURLLoader> a, id<RCTImageURLLoader> b) {
+            float priorityA = [a respondsToSelector:@selector(loaderPriority)] ? [a loaderPriority] : 0;
+            float priorityB = [b respondsToSelector:@selector(loaderPriority)] ? [b loaderPriority] : 0;
+            if (priorityA > priorityB) {
+                return NSOrderedAscending;
+            } else if (priorityA < priorityB) {
+                return NSOrderedDescending;
+            } else {
+                return NSOrderedSame;
+            }
+        }];
+    }
+
+    if (RCT_DEBUG) {
+        // Check for handler conflicts
+        float previousPriority = 0;
+        id<RCTImageURLLoader> previousLoader = nil;
+        for (id<RCTImageURLLoader> loader in _loaders) {
+            float priority = [loader respondsToSelector:@selector(loaderPriority)] ? [loader loaderPriority] : 0;
+            if (previousLoader && priority < previousPriority) {
+                return previousLoader;
+            }
+            if ([loader canLoadImageURL:URL]) {
+                if (previousLoader) {
+                    if (priority == previousPriority) {
+                        RCTLogError(@"The RCTImageURLLoaders %@ and %@ both reported that"
+                                    " they can load the URL %@, and have equal priority"
+                                    " (%g). This could result in non-deterministic behavior.",
+                                    loader, previousLoader, URL, priority);
+                    }
+                } else {
+                    previousLoader = loader;
+                    previousPriority = priority;
+                }
+            }
+        }
+        return previousLoader;
+    }
+
+    // Normal code path
+    for (id<RCTImageURLLoader> loader in _loaders) {
+        if ([loader canLoadImageURL:URL]) {
+            return loader;
+        }
+    }
+    return nil;
+}
+
+- (id<RCTImageDataDecoder>)imageDataDecoderForData:(NSData *)data
+{
+    if (!_maxConcurrentLoadingTasks) {
+        [self setUp];
+    }
+
+    if (!_decoders) {
+        // Get decoders, sorted in reverse priority order (highest priority first)
+        RCTAssert(_bridge, @"Bridge not set");
+        _decoders = [[_bridge modulesConformingToProtocol:@protocol(RCTImageDataDecoder)] sortedArrayUsingComparator:^NSComparisonResult(id<RCTImageDataDecoder> a, id<RCTImageDataDecoder> b) {
+            float priorityA = [a respondsToSelector:@selector(decoderPriority)] ? [a decoderPriority] : 0;
+            float priorityB = [b respondsToSelector:@selector(decoderPriority)] ? [b decoderPriority] : 0;
+            if (priorityA > priorityB) {
+                return NSOrderedAscending;
+            } else if (priorityA < priorityB) {
+                return NSOrderedDescending;
+            } else {
+                return NSOrderedSame;
+            }
+        }];
+    }
+
+    if (RCT_DEBUG) {
+        // Check for handler conflicts
+        float previousPriority = 0;
+        id<RCTImageDataDecoder> previousDecoder = nil;
+        for (id<RCTImageDataDecoder> decoder in _decoders) {
+            float priority = [decoder respondsToSelector:@selector(decoderPriority)] ? [decoder decoderPriority] : 0;
+            if (previousDecoder && priority < previousPriority) {
+                return previousDecoder;
+            }
+            if ([decoder canDecodeImageData:data]) {
+                if (previousDecoder) {
+                    if (priority == previousPriority) {
+                        RCTLogError(@"The RCTImageDataDecoders %@ and %@ both reported that"
+                                    " they can decode the data <NSData %p; %tu bytes>, and"
+                                    " have equal priority (%g). This could result in"
+                                    " non-deterministic behavior.",
+                                    decoder, previousDecoder, data, data.length, priority);
+                    }
+                } else {
+                    previousDecoder = decoder;
+                    previousPriority = priority;
+                }
+            }
+        }
+        return previousDecoder;
+    }
+
+    // Normal code path
+    for (id<RCTImageDataDecoder> decoder in _decoders) {
+        if ([decoder canDecodeImageData:data]) {
+            return decoder;
+        }
+    }
+    return nil;
+}
+
+static UIImage *RCTResizeImageIfNeeded(UIImage *image,
+                                       CGSize size,
+                                       CGFloat scale,
+                                       RCTResizeMode resizeMode)
+{
+    if (CGSizeEqualToSize(size, CGSizeZero) ||
+        CGSizeEqualToSize(image.size, CGSizeZero) ||
+        CGSizeEqualToSize(image.size, size)) {
+        return image;
+    }
+    CAKeyframeAnimation *animation = image.reactKeyframeAnimation;
+    CGRect targetSize = RCTTargetRect(image.size, size, scale, resizeMode);
+    CGAffineTransform transform = RCTTransformFromTargetRect(image.size, targetSize);
+    image = RCTTransformImage(image, size, scale, transform);
+    image.reactKeyframeAnimation = animation;
+    return image;
+}
+
+- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                  callback:(RCTImageLoaderCompletionBlock)callback
+{
+    return [self loadImageWithURLRequest:imageURLRequest
+                                    size:CGSizeZero
+                                   scale:1
+                                 clipped:YES
+                              resizeMode:RCTResizeModeStretch
+                           progressBlock:nil
+                        partialLoadBlock:nil
+                         completionBlock:callback];
+}
+
+- (void)dequeueTasks
+{
+    dispatch_async(_URLRequestQueue, ^{
+        // Remove completed tasks
+        NSMutableArray *tasksToRemove = nil;
+        for (RCTNetworkTask *task in self->_pendingTasks.reverseObjectEnumerator) {
+            switch (task.status) {
+                case RCTNetworkTaskFinished:
+                    if (!tasksToRemove) {
+                        tasksToRemove = [NSMutableArray new];
+                    }
+                    [tasksToRemove addObject:task];
+                    self->_activeTasks--;
+                    break;
+                case RCTNetworkTaskPending:
+                    break;
+                case RCTNetworkTaskInProgress:
+                    // Check task isn't "stuck"
+                    if (task.requestToken == nil) {
+                        RCTLogWarn(@"Task orphaned for request %@", task.request);
+                        if (!tasksToRemove) {
+                            tasksToRemove = [NSMutableArray new];
+                        }
+                        [tasksToRemove addObject:task];
+                        self->_activeTasks--;
+                        [task cancel];
+                    }
+                    break;
+            }
+        }
+
+        if (tasksToRemove) {
+            [self->_pendingTasks removeObjectsInArray:tasksToRemove];
+        }
+
+        // Start queued decode
+        NSInteger activeDecodes = self->_scheduledDecodes - self->_pendingDecodes.count;
+        while (activeDecodes == 0 || (self->_activeBytes <= self->_maxConcurrentDecodingBytes &&
+                                      activeDecodes <= self->_maxConcurrentDecodingTasks)) {
+            dispatch_block_t decodeBlock = self->_pendingDecodes.firstObject;
+            if (decodeBlock) {
+                [self->_pendingDecodes removeObjectAtIndex:0];
+                decodeBlock();
+            } else {
+                break;
+            }
+        }
+
+        // Start queued tasks
+        for (RCTNetworkTask *task in self->_pendingTasks) {
+            if (MAX(self->_activeTasks, self->_scheduledDecodes) >= self->_maxConcurrentLoadingTasks) {
+                break;
+            }
+            if (task.status == RCTNetworkTaskPending) {
+                [task start];
+                self->_activeTasks++;
+            }
+        }
+    });
+}
+
+/**
+ * This returns either an image, or raw image data, depending on the loading
+ * path taken. This is useful if you want to skip decoding, e.g. when preloading
+ * the image, or retrieving metadata.
+ */
+- (RCTImageLoaderCancellationBlock)_loadImageOrDataWithURLRequest:(NSURLRequest *)request
+                                                             size:(CGSize)size
+                                                            scale:(CGFloat)scale
+                                                       resizeMode:(RCTResizeMode)resizeMode
+                                                    progressBlock:(RCTImageLoaderProgressBlock)progressHandler
+                                                 partialLoadBlock:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
+                                                  completionBlock:(void (^)(NSError *error, id imageOrData, BOOL cacheResult, NSString *fetchDate))completionBlock
+{
+    {
+        NSMutableURLRequest *mutableRequest = [request mutableCopy];
+        [NSURLProtocol setProperty:@"RCTImageLoader"
+                            forKey:@"trackingName"
+                         inRequest:mutableRequest];
+
+        // Add missing png extension
+        if (request.URL.fileURL && request.URL.pathExtension.length == 0) {
+            mutableRequest.URL = [request.URL URLByAppendingPathExtension:@"png"];
+        }
+        if (_redirectDelegate != nil) {
+            mutableRequest.URL = [_redirectDelegate redirectAssetsURL:mutableRequest.URL];
+        }
+        request = mutableRequest;
+    }
+
+    // Find suitable image URL loader
+    id<RCTImageURLLoader> loadHandler = [self imageURLLoaderForURL:request.URL];
+    BOOL requiresScheduling = [loadHandler respondsToSelector:@selector(requiresScheduling)] ?
+    [loadHandler requiresScheduling] : YES;
+
+    __block atomic_bool cancelled = ATOMIC_VAR_INIT(NO);
+    // TODO: Protect this variable shared between threads.
+    __block dispatch_block_t cancelLoad = nil;
+    void (^completionHandler)(NSError *, id, NSString *) = ^(NSError *error, id imageOrData, NSString *fetchDate) {
+        cancelLoad = nil;
+
+        BOOL cacheResult = [loadHandler respondsToSelector:@selector(shouldCacheLoadedImages)] ?
+        [loadHandler shouldCacheLoadedImages] : YES;
+
+        // If we've received an image, we should try to set it synchronously,
+        // if it's data, do decoding on a background thread.
+        if (RCTIsMainQueue() && ![imageOrData isKindOfClass:[UIImage class]]) {
+            // Most loaders do not return on the main thread, so caller is probably not
+            // expecting it, and may do expensive post-processing in the callback
+            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+                if (!atomic_load(&cancelled)) {
+                    completionBlock(error, imageOrData, cacheResult, fetchDate);
+                }
+            });
+        } else if (!atomic_load(&cancelled)) {
+            completionBlock(error, imageOrData, cacheResult, fetchDate);
+        }
+    };
+
+    // If the loader doesn't require scheduling we call it directly on
+    // the main queue.
+    if (loadHandler && !requiresScheduling) {
+        return [loadHandler loadImageForURL:request.URL
+                                       size:size
+                                      scale:scale
+                                 resizeMode:resizeMode
+                            progressHandler:progressHandler
+                         partialLoadHandler:partialLoadHandler
+                          completionHandler:^(NSError *error, UIImage *image){
+                              completionHandler(error, image, nil);
+                          }];
+    }
+
+    // All access to URL cache must be serialized
+    if (!_URLRequestQueue) {
+        [self setUp];
+    }
+
+    __weak RCTImageLoader *weakSelf = self;
+    dispatch_async(_URLRequestQueue, ^{
+        __typeof(self) strongSelf = weakSelf;
+        if (atomic_load(&cancelled) || !strongSelf) {
+            return;
+        }
+
+        if (loadHandler) {
+            cancelLoad = [loadHandler loadImageForURL:request.URL
+                                                 size:size
+                                                scale:scale
+                                           resizeMode:resizeMode
+                                      progressHandler:progressHandler
+                                   partialLoadHandler:partialLoadHandler
+                                    completionHandler:^(NSError *error, UIImage *image) {
+                                        completionHandler(error, image, nil);
+                                    }];
+        } else {
+            // Use networking module to load image
+            cancelLoad = [strongSelf _loadURLRequest:request
+                                       progressBlock:progressHandler
+                                     completionBlock:completionHandler];
+        }
+    });
+
+    return ^{
+        BOOL alreadyCancelled = atomic_fetch_or(&cancelled, 1);
+        if (alreadyCancelled) {
+            return;
+        }
+        dispatch_block_t cancelLoadLocal = cancelLoad;
+        cancelLoad = nil;
+        if (cancelLoadLocal) {
+            cancelLoadLocal();
+        }
+    };
+}
+
+- (RCTImageLoaderCancellationBlock)_loadURLRequest:(NSURLRequest *)request
+                                     progressBlock:(RCTImageLoaderProgressBlock)progressHandler
+                                   completionBlock:(void (^)(NSError *error, id imageOrData, NSString *fetchDate))completionHandler
+{
+    // Check if networking module is available
+    if (RCT_DEBUG && ![_bridge respondsToSelector:@selector(networking)]) {
+        RCTLogError(@"No suitable image URL loader found for %@. You may need to "
+                    " import the RCTNetwork library in order to load images.",
+                    request.URL.absoluteString);
+        return NULL;
+    }
+
+    RCTNetworking *networking = [_bridge networking];
+
+    // Check if networking module can load image
+    if (RCT_DEBUG && ![networking canHandleRequest:request]) {
+        RCTLogError(@"No suitable image URL loader found for %@", request.URL.absoluteString);
+        return NULL;
+    }
+
+    // Use networking module to load image
+    RCTURLRequestCompletionBlock processResponse = ^(NSURLResponse *response, NSData *data, NSError *error) {
+        // Check for system errors
+        if (error) {
+            completionHandler(error, nil, nil);
+            return;
+        } else if (!response) {
+            completionHandler(RCTErrorWithMessage(@"Response metadata error"), nil, nil);
+            return;
+        } else if (!data) {
+            completionHandler(RCTErrorWithMessage(@"Unknown image download error"), nil, nil);
+            return;
+        }
+
+        // Check for http errors
+        NSString *responseDate;
+        if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
+            NSInteger statusCode = ((NSHTTPURLResponse *)response).statusCode;
+            if (statusCode != 200) {
+                NSString *errorMessage = [NSString stringWithFormat:@"Failed to load %@", response.URL];
+                NSDictionary *userInfo = @{NSLocalizedDescriptionKey: errorMessage};
+                completionHandler([[NSError alloc] initWithDomain:NSURLErrorDomain
+                                                             code:statusCode
+                                                         userInfo:userInfo], nil, nil);
+                return;
+            }
+
+            responseDate = ((NSHTTPURLResponse *)response).allHeaderFields[@"Date"];
+        }
+
+        // Call handler
+        completionHandler(nil, data, responseDate);
+    };
+
+    // Download image
+    __weak __typeof(self) weakSelf = self;
+    __block RCTNetworkTask *task =
+    [networking networkTaskWithRequest:request
+                       completionBlock:^(NSURLResponse *response, NSData *data, NSError *error) {
+                           __typeof(self) strongSelf = weakSelf;
+                           if (!strongSelf) {
+                               return;
+                           }
+
+                           if (error || !response || !data) {
+                               NSError *someError = nil;
+                               if (error) {
+                                   someError = error;
+                               } else if (!response) {
+                                   someError = RCTErrorWithMessage(@"Response metadata error");
+                               } else {
+                                   someError = RCTErrorWithMessage(@"Unknown image download error");
+                               }
+                               completionHandler(someError, nil, nil);
+                               [strongSelf dequeueTasks];
+                               return;
+                           }
+
+                           dispatch_async(strongSelf->_URLRequestQueue, ^{
+                               // Process image data
+                               processResponse(response, data, nil);
+
+                               // Prepare for next task
+                               [strongSelf dequeueTasks];
+                           });
+                       }];
+
+    task.downloadProgressBlock = ^(int64_t progress, int64_t total) {
+        if (progressHandler) {
+            progressHandler(progress, total);
+        }
+    };
+
+    if (task) {
+        if (!_pendingTasks) {
+            _pendingTasks = [NSMutableArray new];
+        }
+        [_pendingTasks addObject:task];
+        [self dequeueTasks];
+    }
+
+    return ^{
+        __typeof(self) strongSelf = weakSelf;
+        if (!strongSelf || !task) {
+            return;
+        }
+        dispatch_async(strongSelf->_URLRequestQueue, ^{
+            [task cancel];
+            task = nil;
+        });
+        [strongSelf dequeueTasks];
+    };
+}
+
+- (RCTImageLoaderCancellationBlock)loadImageWithURLRequest:(NSURLRequest *)imageURLRequest
+                                                      size:(CGSize)size
+                                                     scale:(CGFloat)scale
+                                                   clipped:(BOOL)clipped
+                                                resizeMode:(RCTResizeMode)resizeMode
+                                             progressBlock:(RCTImageLoaderProgressBlock)progressBlock
+                                          partialLoadBlock:(RCTImageLoaderPartialLoadBlock)partialLoadBlock
+                                           completionBlock:(RCTImageLoaderCompletionBlock)completionBlock
+{
+    __block atomic_bool cancelled = ATOMIC_VAR_INIT(NO);
+    // TODO: Protect this variable shared between threads.
+    __block dispatch_block_t cancelLoad = nil;
+    dispatch_block_t cancellationBlock = ^{
+        BOOL alreadyCancelled = atomic_fetch_or(&cancelled, 1);
+        if (alreadyCancelled) {
+            return;
+        }
+        dispatch_block_t cancelLoadLocal = cancelLoad;
+        cancelLoad = nil;
+        if (cancelLoadLocal) {
+            cancelLoadLocal();
+        }
+    };
+
+    __weak RCTImageLoader *weakSelf = self;
+    void (^completionHandler)(NSError *, id, BOOL, NSString *) = ^(NSError *error, id imageOrData, BOOL cacheResult, NSString *fetchDate) {
+        __typeof(self) strongSelf = weakSelf;
+        if (atomic_load(&cancelled) || !strongSelf) {
+            return;
+        }
+
+        if (!imageOrData || [imageOrData isKindOfClass:[UIImage class]]) {
+            cancelLoad = nil;
+            completionBlock(error, imageOrData);
+            return;
+        }
+
+        // Check decoded image cache
+        if (cacheResult) {
+            UIImage *image = [[strongSelf imageCache] imageForUrl:imageURLRequest.URL.absoluteString
+                                                             size:size
+                                                            scale:scale
+                                                       resizeMode:resizeMode
+                                                     responseDate:fetchDate];
+            if (image) {
+                cancelLoad = nil;
+                completionBlock(nil, image);
+                return;
+            }
+        }
+
+        RCTImageLoaderCompletionBlock decodeCompletionHandler = ^(NSError *error_, UIImage *image) {
+            if (cacheResult && image) {
+                // Store decoded image in cache
+                [[strongSelf imageCache] addImageToCache:image
+                                                     URL:imageURLRequest.URL.absoluteString
+                                                    size:size
+                                                   scale:scale
+                                              resizeMode:resizeMode
+                                            responseDate:fetchDate];
+            }
+
+            cancelLoad = nil;
+            completionBlock(error_, image);
+        };
+
+        cancelLoad = [strongSelf decodeImageData:imageOrData
+                                            size:size
+                                           scale:scale
+                                         clipped:clipped
+                                      resizeMode:resizeMode
+                                 completionBlock:decodeCompletionHandler];
+    };
+
+    cancelLoad = [self _loadImageOrDataWithURLRequest:imageURLRequest
+                                                 size:size
+                                                scale:scale
+                                           resizeMode:resizeMode
+                                        progressBlock:progressBlock
+                                     partialLoadBlock:partialLoadBlock
+                                      completionBlock:completionHandler];
+    return cancellationBlock;
+}
+
+- (RCTImageLoaderCancellationBlock)decodeImageData:(NSData *)data
+                                              size:(CGSize)size
+                                             scale:(CGFloat)scale
+                                           clipped:(BOOL)clipped
+                                        resizeMode:(RCTResizeMode)resizeMode
+                                   completionBlock:(RCTImageLoaderCompletionBlock)completionBlock
+{
+    if (data.length == 0) {
+        completionBlock(RCTErrorWithMessage(@"No image data"), nil);
+        return ^{};
+    }
+
+    __block atomic_bool cancelled = ATOMIC_VAR_INIT(NO);
+    void (^completionHandler)(NSError *, UIImage *) = ^(NSError *error, UIImage *image) {
+        if (RCTIsMainQueue()) {
+            // Most loaders do not return on the main thread, so caller is probably not
+            // expecting it, and may do expensive post-processing in the callback
+            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+                if (!atomic_load(&cancelled)) {
+                    completionBlock(error, clipped ? RCTResizeImageIfNeeded(image, size, scale, resizeMode) : image);
+                }
+            });
+        } else if (!atomic_load(&cancelled)) {
+            completionBlock(error, clipped ? RCTResizeImageIfNeeded(image, size, scale, resizeMode) : image);
+        }
+    };
+
+    id<RCTImageDataDecoder> imageDecoder = [self imageDataDecoderForData:data];
+    if (imageDecoder) {
+        return [imageDecoder decodeImageData:data
+                                        size:size
+                                       scale:scale
+                                  resizeMode:resizeMode
+                           completionHandler:completionHandler] ?: ^{};
+    } else {
+        dispatch_block_t decodeBlock = ^{
+            // Calculate the size, in bytes, that the decompressed image will require
+            NSInteger decodedImageBytes = (size.width * scale) * (size.height * scale) * 4;
+
+            // Mark these bytes as in-use
+            self->_activeBytes += decodedImageBytes;
+
+            // Do actual decompression on a concurrent background queue
+            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+                if (!atomic_load(&cancelled)) {
+
+                    // Decompress the image data (this may be CPU and memory intensive)
+                    UIImage *image = RCTDecodeImageWithData(data, size, scale, resizeMode);
+
+#if RCT_DEV
+                    CGSize imagePixelSize = RCTSizeInPixels(image.size, image.scale);
+                    CGSize screenPixelSize = RCTSizeInPixels(RCTScreenSize(), RCTScreenScale());
+                    if (imagePixelSize.width * imagePixelSize.height >
+                        screenPixelSize.width * screenPixelSize.height) {
+                        RCTLogInfo(@"[PERF ASSETS] Loading image at size %@, which is larger "
+                                   "than the screen size %@", NSStringFromCGSize(imagePixelSize),
+                                   NSStringFromCGSize(screenPixelSize));
+                    }
+#endif
+
+                    if (image) {
+                        completionHandler(nil, image);
+                    } else {
+                        NSString *errorMessage = [NSString stringWithFormat:@"Error decoding image data <NSData %p; %tu bytes>", data, data.length];
+                        NSError *finalError = RCTErrorWithMessage(errorMessage);
+                        completionHandler(finalError, nil);
+                    }
+                }
+
+                // We're no longer retaining the uncompressed data, so now we'll mark
+                // the decoding as complete so that the loading task queue can resume.
+                dispatch_async(self->_URLRequestQueue, ^{
+                    self->_scheduledDecodes--;
+                    self->_activeBytes -= decodedImageBytes;
+                    [self dequeueTasks];
+                });
+            });
+        };
+
+        if (!_URLRequestQueue) {
+            [self setUp];
+        }
+        dispatch_async(_URLRequestQueue, ^{
+            // The decode operation retains the compressed image data until it's
+            // complete, so we'll mark it as having started, in order to block
+            // further image loads from happening until we're done with the data.
+            self->_scheduledDecodes++;
+
+            if (!self->_pendingDecodes) {
+                self->_pendingDecodes = [NSMutableArray new];
+            }
+            NSInteger activeDecodes = self->_scheduledDecodes - self->_pendingDecodes.count - 1;
+            if (activeDecodes == 0 || (self->_activeBytes <= self->_maxConcurrentDecodingBytes &&
+                                       activeDecodes <= self->_maxConcurrentDecodingTasks)) {
+                decodeBlock();
+            } else {
+                [self->_pendingDecodes addObject:decodeBlock];
+            }
+        });
+
+        return ^{
+            atomic_store(&cancelled, YES);
+        };
+    }
+}
+
+- (RCTImageLoaderCancellationBlock)getImageSizeForURLRequest:(NSURLRequest *)imageURLRequest
+                                                       block:(void(^)(NSError *error, CGSize size))callback
+{
+    void (^completion)(NSError *, id, BOOL, NSString *) = ^(NSError *error, id imageOrData, BOOL cacheResult, NSString *fetchDate) {
+        CGSize size;
+        if ([imageOrData isKindOfClass:[NSData class]]) {
+            NSDictionary *meta = RCTGetImageMetadata(imageOrData);
+
+            NSInteger imageOrientation = [meta[(id)kCGImagePropertyOrientation] integerValue];
+            switch (imageOrientation) {
+                case kCGImagePropertyOrientationLeft:
+                case kCGImagePropertyOrientationRight:
+                case kCGImagePropertyOrientationLeftMirrored:
+                case kCGImagePropertyOrientationRightMirrored:
+                    // swap width and height
+                    size = (CGSize){
+                      [meta[(id)kCGImagePropertyPixelHeight] doubleValue],
+                      [meta[(id)kCGImagePropertyPixelWidth] doubleValue],
+                    };
+                    break;
+                case kCGImagePropertyOrientationUp:
+                case kCGImagePropertyOrientationDown:
+                case kCGImagePropertyOrientationUpMirrored:
+                case kCGImagePropertyOrientationDownMirrored:
+                default:
+                    size = (CGSize){
+                      [meta[(id)kCGImagePropertyPixelWidth] doubleValue],
+                      [meta[(id)kCGImagePropertyPixelHeight] doubleValue],
+                    };
+                    break;
+            }
+        } else {
+            UIImage *image = imageOrData;
+            size = (CGSize){
+                image.size.width * image.scale,
+                image.size.height * image.scale,
+            };
+        }
+        callback(error, size);
+    };
+
+    return [self _loadImageOrDataWithURLRequest:imageURLRequest
+                                           size:CGSizeZero
+                                          scale:1
+                                     resizeMode:RCTResizeModeStretch
+                                  progressBlock:NULL
+                               partialLoadBlock:NULL
+                                completionBlock:completion];
+}
+
+#pragma mark - RCTURLRequestHandler
+
+- (BOOL)canHandleRequest:(NSURLRequest *)request
+{
+    NSURL *requestURL = request.URL;
+
+    // If the data being loaded is a video, return NO
+    // Even better may be to implement this on the RCTImageURLLoader that would try to load it,
+    // but we'd have to run the logic both in RCTPhotoLibraryImageLoader and
+    // RCTAssetsLibraryRequestHandler. Once we drop iOS7 though, we'd drop
+    // RCTAssetsLibraryRequestHandler and can move it there.
+    static NSRegularExpression *videoRegex = nil;
+    if (!videoRegex) {
+      NSError *error = nil;
+      videoRegex = [NSRegularExpression regularExpressionWithPattern:@"(?:&|^)ext=MOV(?:&|$)"
+                                                             options:NSRegularExpressionCaseInsensitive
+                                                               error:&error];
+      if (error) {
+        RCTLogError(@"%@", error);
+      }
+    }
+
+    NSString *query = requestURL.query;
+    if (query != nil && [videoRegex firstMatchInString:query
+                                               options:0
+                                                 range:NSMakeRange(0, query.length)]) {
+      return NO;
+    }
+
+    for (id<RCTImageURLLoader> loader in _loaders) {
+        // Don't use RCTImageURLLoader protocol for modules that already conform to
+        // RCTURLRequestHandler as it's inefficient to decode an image and then
+        // convert it back into data
+        if (![loader conformsToProtocol:@protocol(RCTURLRequestHandler)] &&
+            [loader canLoadImageURL:requestURL]) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+- (id)sendRequest:(NSURLRequest *)request withDelegate:(id<RCTURLRequestDelegate>)delegate
+{
+    __block RCTImageLoaderCancellationBlock requestToken;
+    requestToken = [self loadImageWithURLRequest:request callback:^(NSError *error, UIImage *image) {
+        if (error) {
+            [delegate URLRequest:requestToken didCompleteWithError:error];
+            return;
+        }
+
+        NSString *mimeType = nil;
+        NSData *imageData = nil;
+        if (RCTImageHasAlpha(image.CGImage)) {
+            mimeType = @"image/png";
+            imageData = UIImagePNGRepresentation(image);
+        } else {
+            mimeType = @"image/jpeg";
+            imageData = UIImageJPEGRepresentation(image, 1.0);
+        }
+
+        NSURLResponse *response = [[NSURLResponse alloc] initWithURL:request.URL
+                                                            MIMEType:mimeType
+                                               expectedContentLength:imageData.length
+                                                    textEncodingName:nil];
+
+        [delegate URLRequest:requestToken didReceiveResponse:response];
+        [delegate URLRequest:requestToken didReceiveData:imageData];
+        [delegate URLRequest:requestToken didCompleteWithError:nil];
+    }];
+
+    return requestToken;
+}
+
+- (void)cancelRequest:(id)requestToken
+{
+    if (requestToken) {
+        ((RCTImageLoaderCancellationBlock)requestToken)();
+    }
+}
+
+@end
+
+@implementation RCTBridge (RCTImageLoader)
+
+- (RCTImageLoader *)imageLoader
+{
+    return [self moduleForClass:[RCTImageLoader class]];
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTImageShadowView.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTShadowView.h>
+
+@interface RCTImageShadowView : RCTShadowView
+
+@end

node_modules/react-native/Libraries/Image/RCTImageShadowView.m

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageShadowView.h"
+
+#import <React/RCTLog.h>
+
+@implementation RCTImageShadowView
+
+- (BOOL)isYogaLeafNode
+{
+  return YES;
+}
+
+- (BOOL)canHaveSubviews
+{
+  return NO;
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTImageStoreManager.h

@@ -0,0 +1,44 @@
+// Copyright (c) 2004-present, Facebook, Inc.
+//
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTURLRequestHandler.h>
+
+@interface RCTImageStoreManager : NSObject <RCTURLRequestHandler>
+
+/**
+ * Set and get cached image data asynchronously. It is safe to call these from any
+ * thread. The callbacks will be called on an unspecified thread.
+ */
+- (void)removeImageForTag:(NSString *)imageTag withBlock:(void (^)(void))block;
+- (void)storeImageData:(NSData *)imageData withBlock:(void (^)(NSString *imageTag))block;
+- (void)getImageDataForTag:(NSString *)imageTag withBlock:(void (^)(NSData *imageData))block;
+
+/**
+ * Convenience method to store an image directly (image is converted to data
+ * internally, so any metadata such as scale or orientation will be lost).
+ */
+- (void)storeImage:(UIImage *)image withBlock:(void (^)(NSString *imageTag))block;
+
+@end
+
+@interface RCTImageStoreManager (Deprecated)
+
+/**
+ * These methods are deprecated - use the data-based alternatives instead.
+ */
+- (NSString *)storeImage:(UIImage *)image __deprecated;
+- (UIImage *)imageForTag:(NSString *)imageTag __deprecated;
+- (void)getImageForTag:(NSString *)imageTag withBlock:(void (^)(UIImage *image))block __deprecated;
+
+@end
+
+@interface RCTBridge (RCTImageStoreManager)
+
+@property (nonatomic, readonly) RCTImageStoreManager *imageStoreManager;
+
+@end

node_modules/react-native/Libraries/Image/RCTImageStoreManager.m

@@ -0,0 +1,240 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageStoreManager.h"
+
+#import <stdatomic.h>
+
+#import <ImageIO/ImageIO.h>
+#import <MobileCoreServices/UTType.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+#import "RCTImageUtils.h"
+
+static NSString *const RCTImageStoreURLScheme = @"rct-image-store";
+
+@implementation RCTImageStoreManager
+{
+  NSMutableDictionary<NSString *, NSData *> *_store;
+  NSUInteger _id;
+}
+
+@synthesize methodQueue = _methodQueue;
+
+RCT_EXPORT_MODULE()
+
+- (float)handlerPriority
+{
+    return 1;
+}
+
+- (void)removeImageForTag:(NSString *)imageTag withBlock:(void (^)(void))block
+{
+  dispatch_async(_methodQueue, ^{
+    [self removeImageForTag:imageTag];
+    if (block) {
+      block();
+    }
+  });
+}
+
+- (NSString *)_storeImageData:(NSData *)imageData
+{
+  RCTAssertThread(_methodQueue, @"Must be called on RCTImageStoreManager thread");
+
+  if (!_store) {
+    _store = [NSMutableDictionary new];
+    _id = 0;
+  }
+
+  NSString *imageTag = [NSString stringWithFormat:@"%@://%tu", RCTImageStoreURLScheme, _id++];
+  _store[imageTag] = imageData;
+  return imageTag;
+}
+
+- (void)storeImageData:(NSData *)imageData withBlock:(void (^)(NSString *imageTag))block
+{
+  RCTAssertParam(block);
+  dispatch_async(_methodQueue, ^{
+    block([self _storeImageData:imageData]);
+  });
+}
+
+- (void)getImageDataForTag:(NSString *)imageTag withBlock:(void (^)(NSData *imageData))block
+{
+  RCTAssertParam(block);
+  dispatch_async(_methodQueue, ^{
+    block(self->_store[imageTag]);
+  });
+}
+
+- (void)storeImage:(UIImage *)image withBlock:(void (^)(NSString *imageTag))block
+{
+  RCTAssertParam(block);
+  dispatch_async(_methodQueue, ^{
+    NSString *imageTag = [self _storeImageData:RCTGetImageData(image, 0.75)];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      block(imageTag);
+    });
+  });
+}
+
+RCT_EXPORT_METHOD(removeImageForTag:(NSString *)imageTag)
+{
+  [_store removeObjectForKey:imageTag];
+}
+
+RCT_EXPORT_METHOD(hasImageForTag:(NSString *)imageTag
+                  callback:(RCTResponseSenderBlock)callback)
+{
+  callback(@[@(_store[imageTag] != nil)]);
+}
+
+// TODO (#5906496): Name could be more explicit - something like getBase64EncodedDataForTag:?
+RCT_EXPORT_METHOD(getBase64ForTag:(NSString *)imageTag
+                  successCallback:(RCTResponseSenderBlock)successCallback
+                  errorCallback:(RCTResponseErrorBlock)errorCallback)
+{
+  NSData *imageData = _store[imageTag];
+  if (!imageData) {
+    errorCallback(RCTErrorWithMessage([NSString stringWithFormat:@"Invalid imageTag: %@", imageTag]));
+    return;
+  }
+  // Dispatching to a background thread to perform base64 encoding
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    successCallback(@[[imageData base64EncodedStringWithOptions:0]]);
+  });
+}
+
+RCT_EXPORT_METHOD(addImageFromBase64:(NSString *)base64String
+                  successCallback:(RCTResponseSenderBlock)successCallback
+                  errorCallback:(RCTResponseErrorBlock)errorCallback)
+
+{
+  // Dispatching to a background thread to perform base64 decoding
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    NSData *imageData = [[NSData alloc] initWithBase64EncodedString:base64String options:0];
+    if (imageData) {
+      dispatch_async(self->_methodQueue, ^{
+        successCallback(@[[self _storeImageData:imageData]]);
+      });
+    } else {
+      errorCallback(RCTErrorWithMessage(@"Failed to add image from base64String"));
+    }
+  });
+}
+
+#pragma mark - RCTURLRequestHandler
+
+- (BOOL)canHandleRequest:(NSURLRequest *)request
+{
+  return [request.URL.scheme caseInsensitiveCompare:RCTImageStoreURLScheme] == NSOrderedSame;
+}
+
+- (id)sendRequest:(NSURLRequest *)request withDelegate:(id<RCTURLRequestDelegate>)delegate
+{
+  __block atomic_bool cancelled = ATOMIC_VAR_INIT(NO);
+  void (^cancellationBlock)(void) = ^{
+    atomic_store(&cancelled, YES);
+  };
+
+  // Dispatch async to give caller time to cancel the request
+  dispatch_async(_methodQueue, ^{
+    if (atomic_load(&cancelled)) {
+      return;
+    }
+
+    NSString *imageTag = request.URL.absoluteString;
+    NSData *imageData = self->_store[imageTag];
+    if (!imageData) {
+      NSError *error = RCTErrorWithMessage([NSString stringWithFormat:@"Invalid imageTag: %@", imageTag]);
+      [delegate URLRequest:cancellationBlock didCompleteWithError:error];
+      return;
+    }
+
+    CGImageSourceRef sourceRef = CGImageSourceCreateWithData((__bridge CFDataRef)imageData, NULL);
+    if (!sourceRef) {
+      NSError *error = RCTErrorWithMessage([NSString stringWithFormat:@"Unable to decode data for imageTag: %@", imageTag]);
+      [delegate URLRequest:cancellationBlock didCompleteWithError:error];
+      return;
+    }
+    CFStringRef UTI = CGImageSourceGetType(sourceRef);
+    CFRelease(sourceRef);
+
+    NSString *MIMEType = (__bridge_transfer NSString *)UTTypeCopyPreferredTagWithClass(UTI, kUTTagClassMIMEType);
+    NSURLResponse *response = [[NSURLResponse alloc] initWithURL:request.URL
+                                                        MIMEType:MIMEType
+                                           expectedContentLength:imageData.length
+                                                textEncodingName:nil];
+
+    [delegate URLRequest:cancellationBlock didReceiveResponse:response];
+    [delegate URLRequest:cancellationBlock didReceiveData:imageData];
+    [delegate URLRequest:cancellationBlock didCompleteWithError:nil];
+
+  });
+
+  return cancellationBlock;
+}
+
+- (void)cancelRequest:(id)requestToken
+{
+  if (requestToken) {
+    ((void (^)(void))requestToken)();
+  }
+}
+
+@end
+
+@implementation RCTImageStoreManager (Deprecated)
+
+- (NSString *)storeImage:(UIImage *)image
+{
+  RCTAssertMainQueue();
+  RCTLogWarn(@"RCTImageStoreManager.storeImage() is deprecated and has poor performance. Use an alternative method instead.");
+  __block NSString *imageTag;
+  dispatch_sync(_methodQueue, ^{
+    imageTag = [self _storeImageData:RCTGetImageData(image, 0.75)];
+  });
+  return imageTag;
+}
+
+- (UIImage *)imageForTag:(NSString *)imageTag
+{
+  RCTAssertMainQueue();
+  RCTLogWarn(@"RCTImageStoreManager.imageForTag() is deprecated and has poor performance. Use an alternative method instead.");
+  __block NSData *imageData;
+  dispatch_sync(_methodQueue, ^{
+    imageData = self->_store[imageTag];
+  });
+  return [UIImage imageWithData:imageData];
+}
+
+- (void)getImageForTag:(NSString *)imageTag withBlock:(void (^)(UIImage *image))block
+{
+  RCTAssertParam(block);
+  dispatch_async(_methodQueue, ^{
+    NSData *imageData = self->_store[imageTag];
+    dispatch_async(dispatch_get_main_queue(), ^{
+      // imageWithData: is not thread-safe, so we can't do this on methodQueue
+      block([UIImage imageWithData:imageData]);
+    });
+  });
+}
+
+@end
+
+@implementation RCTBridge (RCTImageStoreManager)
+
+- (RCTImageStoreManager *)imageStoreManager
+{
+  return [self moduleForClass:[RCTImageStoreManager class]];
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTImageUtils.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTDefines.h>
+#import <React/RCTResizeMode.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * This function takes an source size (typically from an image), a target size
+ * and scale that it will be drawn at (typically in a CGContext) and then
+ * calculates the rectangle to draw the image into so that it will be sized and
+ * positioned correctly according to the specified resizeMode.
+ */
+RCT_EXTERN CGRect RCTTargetRect(CGSize sourceSize, CGSize destSize,
+                                CGFloat destScale, RCTResizeMode resizeMode);
+
+/**
+ * This function takes a source size (typically from an image), a target rect
+ * that it will be drawn into (typically relative to a CGContext), and works out
+ * the transform needed to draw the image at the correct scale and position.
+ */
+RCT_EXTERN CGAffineTransform RCTTransformFromTargetRect(CGSize sourceSize,
+                                                        CGRect targetRect);
+
+/**
+ * This function takes an input content size & scale (typically from an image),
+ * a target size & scale at which it will be displayed (typically in a
+ * UIImageView) and then calculates the optimal size at which to redraw the
+ * image so that it will be displayed correctly with the specified resizeMode.
+ */
+RCT_EXTERN CGSize RCTTargetSize(CGSize sourceSize, CGFloat sourceScale,
+                                CGSize destSize, CGFloat destScale,
+                                RCTResizeMode resizeMode, BOOL allowUpscaling);
+
+/**
+ * This function takes an input content size & scale (typically from an image),
+ * a target size & scale that it will be displayed at, and determines if the
+ * source will need to be upscaled to fit (which may result in pixelization).
+ */
+RCT_EXTERN BOOL RCTUpscalingRequired(CGSize sourceSize, CGFloat sourceScale,
+                                     CGSize destSize, CGFloat destScale,
+                                     RCTResizeMode resizeMode);
+
+/**
+ * This function takes the source data for an image and decodes it at the
+ * specified size. If the original image is smaller than the destination size,
+ * the resultant image's scale will be decreased to compensate, so the
+ * width/height of the returned image is guaranteed to be >= destSize.
+ * Pass a destSize of CGSizeZero to decode the image at its original size.
+ */
+RCT_EXTERN UIImage *__nullable RCTDecodeImageWithData(NSData *data,
+                                                      CGSize destSize,
+                                                      CGFloat destScale,
+                                                      RCTResizeMode resizeMode);
+
+/**
+ * This function takes the source data for an image and decodes just the
+ * metadata, without decompressing the image itself.
+ */
+RCT_EXTERN NSDictionary<NSString *, id> *__nullable RCTGetImageMetadata(NSData *data);
+
+/**
+ * Convert an image back into data. Images with an alpha channel will be
+ * converted to lossless PNG data. Images without alpha will be converted to
+ * JPEG. The `quality` argument controls the compression ratio of the JPEG
+ * conversion, with 1.0 being maximum quality. It has no effect for images
+ * using PNG compression.
+ */
+RCT_EXTERN NSData *__nullable RCTGetImageData(UIImage *image, float quality);
+
+/**
+ * This function transforms an image. `destSize` is the size of the final image,
+ * and `destScale` is its scale. The `transform` argument controls how the
+ * source image will be mapped to the destination image.
+ */
+RCT_EXTERN UIImage *__nullable RCTTransformImage(UIImage *image,
+                                                 CGSize destSize,
+                                                 CGFloat destScale,
+                                                 CGAffineTransform transform);
+
+/*
+ * Return YES if image has an alpha component
+ */
+RCT_EXTERN BOOL RCTImageHasAlpha(CGImageRef image);
+
+NS_ASSUME_NONNULL_END

node_modules/react-native/Libraries/Image/RCTImageUtils.m

@@ -0,0 +1,386 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageUtils.h"
+
+#import <tgmath.h>
+
+#import <ImageIO/ImageIO.h>
+#import <MobileCoreServices/UTCoreTypes.h>
+
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+
+static CGFloat RCTCeilValue(CGFloat value, CGFloat scale)
+{
+  return ceil(value * scale) / scale;
+}
+
+static CGFloat RCTFloorValue(CGFloat value, CGFloat scale)
+{
+  return floor(value * scale) / scale;
+}
+
+static CGSize RCTCeilSize(CGSize size, CGFloat scale)
+{
+  return (CGSize){
+    RCTCeilValue(size.width, scale),
+    RCTCeilValue(size.height, scale)
+  };
+}
+
+static CGImagePropertyOrientation CGImagePropertyOrientationFromUIImageOrientation(UIImageOrientation imageOrientation)
+{
+  // see https://stackoverflow.com/a/6699649/496389
+  switch (imageOrientation) {
+    case UIImageOrientationUp: return kCGImagePropertyOrientationUp;
+    case UIImageOrientationDown: return kCGImagePropertyOrientationDown;
+    case UIImageOrientationLeft: return kCGImagePropertyOrientationLeft;
+    case UIImageOrientationRight: return kCGImagePropertyOrientationRight;
+    case UIImageOrientationUpMirrored: return kCGImagePropertyOrientationUpMirrored;
+    case UIImageOrientationDownMirrored: return kCGImagePropertyOrientationDownMirrored;
+    case UIImageOrientationLeftMirrored: return kCGImagePropertyOrientationLeftMirrored;
+    case UIImageOrientationRightMirrored: return kCGImagePropertyOrientationRightMirrored;
+    default: return kCGImagePropertyOrientationUp;
+  }
+}
+
+CGRect RCTTargetRect(CGSize sourceSize, CGSize destSize,
+                     CGFloat destScale, RCTResizeMode resizeMode)
+{
+  if (CGSizeEqualToSize(destSize, CGSizeZero)) {
+    // Assume we require the largest size available
+    return (CGRect){CGPointZero, sourceSize};
+  }
+
+  CGFloat aspect = sourceSize.width / sourceSize.height;
+  // If only one dimension in destSize is non-zero (for example, an Image
+  // with `flex: 1` whose height is indeterminate), calculate the unknown
+  // dimension based on the aspect ratio of sourceSize
+  if (destSize.width == 0) {
+    destSize.width = destSize.height * aspect;
+  }
+  if (destSize.height == 0) {
+    destSize.height = destSize.width / aspect;
+  }
+
+  // Calculate target aspect ratio if needed
+  CGFloat targetAspect = 0.0;
+  if (resizeMode != RCTResizeModeCenter &&
+      resizeMode != RCTResizeModeStretch) {
+    targetAspect = destSize.width / destSize.height;
+    if (aspect == targetAspect) {
+      resizeMode = RCTResizeModeStretch;
+    }
+  }
+
+  switch (resizeMode) {
+    case RCTResizeModeStretch:
+    case RCTResizeModeRepeat:
+
+      return (CGRect){CGPointZero, RCTCeilSize(destSize, destScale)};
+
+    case RCTResizeModeContain:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        sourceSize.width = destSize.width;
+        sourceSize.height = sourceSize.width / aspect;
+
+      } else { // target is wider than content
+
+        sourceSize.height = destSize.height;
+        sourceSize.width = sourceSize.height * aspect;
+      }
+      return (CGRect){
+        {
+          RCTFloorValue((destSize.width - sourceSize.width) / 2, destScale),
+          RCTFloorValue((destSize.height - sourceSize.height) / 2, destScale),
+        },
+        RCTCeilSize(sourceSize, destScale)
+      };
+
+    case RCTResizeModeCover:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        sourceSize.height = destSize.height;
+        sourceSize.width = sourceSize.height * aspect;
+        destSize.width = destSize.height * targetAspect;
+        return (CGRect){
+          {RCTFloorValue((destSize.width - sourceSize.width) / 2, destScale), 0},
+          RCTCeilSize(sourceSize, destScale)
+        };
+
+      } else { // target is wider than content
+
+        sourceSize.width = destSize.width;
+        sourceSize.height = sourceSize.width / aspect;
+        destSize.height = destSize.width / targetAspect;
+        return (CGRect){
+          {0, RCTFloorValue((destSize.height - sourceSize.height) / 2, destScale)},
+          RCTCeilSize(sourceSize, destScale)
+        };
+      }
+
+    case RCTResizeModeCenter:
+
+      // Make sure the image is not clipped by the target.
+      if (sourceSize.height > destSize.height) {
+        sourceSize.width = destSize.width;
+        sourceSize.height = sourceSize.width / aspect;
+      }
+      if (sourceSize.width > destSize.width) {
+        sourceSize.height = destSize.height;
+        sourceSize.width = sourceSize.height * aspect;
+      }
+
+      return (CGRect){
+        {
+          RCTFloorValue((destSize.width - sourceSize.width) / 2, destScale),
+          RCTFloorValue((destSize.height - sourceSize.height) / 2, destScale),
+        },
+        RCTCeilSize(sourceSize, destScale)
+      };
+  }
+}
+
+CGAffineTransform RCTTransformFromTargetRect(CGSize sourceSize, CGRect targetRect)
+{
+  CGAffineTransform transform = CGAffineTransformIdentity;
+  transform = CGAffineTransformTranslate(transform,
+                                         targetRect.origin.x,
+                                         targetRect.origin.y);
+  transform = CGAffineTransformScale(transform,
+                                     targetRect.size.width / sourceSize.width,
+                                     targetRect.size.height / sourceSize.height);
+  return transform;
+}
+
+CGSize RCTTargetSize(CGSize sourceSize, CGFloat sourceScale,
+                     CGSize destSize, CGFloat destScale,
+                     RCTResizeMode resizeMode,
+                     BOOL allowUpscaling)
+{
+  switch (resizeMode) {
+    case RCTResizeModeCenter:
+
+      return RCTTargetRect(sourceSize, destSize, destScale, resizeMode).size;
+
+    case RCTResizeModeStretch:
+
+      if (!allowUpscaling) {
+        CGFloat scale = sourceScale / destScale;
+        destSize.width = MIN(sourceSize.width * scale, destSize.width);
+        destSize.height = MIN(sourceSize.height * scale, destSize.height);
+      }
+      return RCTCeilSize(destSize, destScale);
+
+    default: {
+
+      // Get target size
+      CGSize size = RCTTargetRect(sourceSize, destSize, destScale, resizeMode).size;
+      if (!allowUpscaling) {
+        // return sourceSize if target size is larger
+        if (sourceSize.width * sourceScale < size.width * destScale) {
+          return sourceSize;
+        }
+      }
+      return size;
+    }
+  }
+}
+
+BOOL RCTUpscalingRequired(CGSize sourceSize, CGFloat sourceScale,
+                          CGSize destSize, CGFloat destScale,
+                          RCTResizeMode resizeMode)
+{
+  if (CGSizeEqualToSize(destSize, CGSizeZero)) {
+    // Assume we require the largest size available
+    return YES;
+  }
+
+  // Precompensate for scale
+  CGFloat scale = sourceScale / destScale;
+  sourceSize.width *= scale;
+  sourceSize.height *= scale;
+
+  // Calculate aspect ratios if needed (don't bother if resizeMode == stretch)
+  CGFloat aspect = 0.0, targetAspect = 0.0;
+  if (resizeMode != UIViewContentModeScaleToFill) {
+    aspect = sourceSize.width / sourceSize.height;
+    targetAspect = destSize.width / destSize.height;
+    if (aspect == targetAspect) {
+      resizeMode = RCTResizeModeStretch;
+    }
+  }
+
+  switch (resizeMode) {
+    case RCTResizeModeStretch:
+
+      return destSize.width > sourceSize.width || destSize.height > sourceSize.height;
+
+    case RCTResizeModeContain:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        return destSize.width > sourceSize.width;
+
+      } else { // target is wider than content
+
+        return destSize.height > sourceSize.height;
+      }
+
+    case RCTResizeModeCover:
+
+      if (targetAspect <= aspect) { // target is taller than content
+
+        return destSize.height > sourceSize.height;
+
+      } else { // target is wider than content
+
+        return destSize.width > sourceSize.width;
+      }
+
+    case RCTResizeModeRepeat:
+    case RCTResizeModeCenter:
+
+      return NO;
+  }
+}
+
+UIImage *__nullable RCTDecodeImageWithData(NSData *data,
+                                           CGSize destSize,
+                                           CGFloat destScale,
+                                           RCTResizeMode resizeMode)
+{
+  CGImageSourceRef sourceRef = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL);
+  if (!sourceRef) {
+    return nil;
+  }
+
+  // Get original image size
+  CFDictionaryRef imageProperties = CGImageSourceCopyPropertiesAtIndex(sourceRef, 0, NULL);
+  if (!imageProperties) {
+    CFRelease(sourceRef);
+    return nil;
+  }
+  NSNumber *width = CFDictionaryGetValue(imageProperties, kCGImagePropertyPixelWidth);
+  NSNumber *height = CFDictionaryGetValue(imageProperties, kCGImagePropertyPixelHeight);
+  CGSize sourceSize = {width.doubleValue, height.doubleValue};
+  CFRelease(imageProperties);
+
+  if (CGSizeEqualToSize(destSize, CGSizeZero)) {
+    destSize = sourceSize;
+    if (!destScale) {
+      destScale = 1;
+    }
+  } else if (!destScale) {
+    destScale = RCTScreenScale();
+  }
+
+  if (resizeMode == UIViewContentModeScaleToFill) {
+    // Decoder cannot change aspect ratio, so RCTResizeModeStretch is equivalent
+    // to RCTResizeModeCover for our purposes
+    resizeMode = RCTResizeModeCover;
+  }
+
+  // Calculate target size
+  CGSize targetSize = RCTTargetSize(sourceSize, 1, destSize, destScale, resizeMode, NO);
+  CGSize targetPixelSize = RCTSizeInPixels(targetSize, destScale);
+  CGFloat maxPixelSize = fmax(fmin(sourceSize.width, targetPixelSize.width),
+                              fmin(sourceSize.height, targetPixelSize.height));
+
+  NSDictionary<NSString *, NSNumber *> *options = @{
+    (id)kCGImageSourceShouldAllowFloat: @YES,
+    (id)kCGImageSourceCreateThumbnailWithTransform: @YES,
+    (id)kCGImageSourceCreateThumbnailFromImageAlways: @YES,
+    (id)kCGImageSourceThumbnailMaxPixelSize: @(maxPixelSize),
+  };
+
+  // Get thumbnail
+  CGImageRef imageRef = CGImageSourceCreateThumbnailAtIndex(sourceRef, 0, (__bridge CFDictionaryRef)options);
+  CFRelease(sourceRef);
+  if (!imageRef) {
+    return nil;
+  }
+
+  // Return image
+  UIImage *image = [UIImage imageWithCGImage:imageRef
+                                       scale:destScale
+                                 orientation:UIImageOrientationUp];
+  CGImageRelease(imageRef);
+  return image;
+}
+
+NSDictionary<NSString *, id> *__nullable RCTGetImageMetadata(NSData *data)
+{
+  CGImageSourceRef sourceRef = CGImageSourceCreateWithData((__bridge CFDataRef)data, NULL);
+  if (!sourceRef) {
+    return nil;
+  }
+  CFDictionaryRef imageProperties = CGImageSourceCopyPropertiesAtIndex(sourceRef, 0, NULL);
+  CFRelease(sourceRef);
+  return (__bridge_transfer id)imageProperties;
+}
+
+NSData *__nullable RCTGetImageData(UIImage *image, float quality)
+{
+  NSMutableDictionary *properties = [[NSMutableDictionary alloc] initWithDictionary:@{
+    (id)kCGImagePropertyOrientation : @(CGImagePropertyOrientationFromUIImageOrientation(image.imageOrientation))
+  }];
+  CGImageDestinationRef destination;
+  CFMutableDataRef imageData = CFDataCreateMutable(NULL, 0);
+  CGImageRef cgImage = image.CGImage;
+  if (RCTImageHasAlpha(cgImage)) {
+    // get png data
+    destination = CGImageDestinationCreateWithData(imageData, kUTTypePNG, 1, NULL);
+  } else {
+    // get jpeg data
+    destination = CGImageDestinationCreateWithData(imageData, kUTTypeJPEG, 1, NULL);
+    [properties setValue:@(quality) forKey:(id)kCGImageDestinationLossyCompressionQuality];
+  }
+  CGImageDestinationAddImage(destination, cgImage, (__bridge CFDictionaryRef)properties);
+  if (!CGImageDestinationFinalize(destination))
+  {
+    CFRelease(imageData);
+    imageData = NULL;
+  }
+  CFRelease(destination);
+  return (__bridge_transfer NSData *)imageData;
+}
+
+UIImage *__nullable RCTTransformImage(UIImage *image,
+                                      CGSize destSize,
+                                      CGFloat destScale,
+                                      CGAffineTransform transform)
+{
+  if (destSize.width <= 0 | destSize.height <= 0 || destScale <= 0) {
+    return nil;
+  }
+
+  BOOL opaque = !RCTImageHasAlpha(image.CGImage);
+  UIGraphicsBeginImageContextWithOptions(destSize, opaque, destScale);
+  CGContextRef currentContext = UIGraphicsGetCurrentContext();
+  CGContextConcatCTM(currentContext, transform);
+  [image drawAtPoint:CGPointZero];
+  UIImage *result = UIGraphicsGetImageFromCurrentImageContext();
+  UIGraphicsEndImageContext();
+  return result;
+}
+
+BOOL RCTImageHasAlpha(CGImageRef image)
+{
+  switch (CGImageGetAlphaInfo(image)) {
+    case kCGImageAlphaNone:
+    case kCGImageAlphaNoneSkipLast:
+    case kCGImageAlphaNoneSkipFirst:
+      return NO;
+    default:
+      return YES;
+  }
+}

node_modules/react-native/Libraries/Image/RCTImageView.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTResizeMode.h>
+
+@class RCTBridge;
+@class RCTImageSource;
+
+@interface RCTImageView : UIImageView
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge NS_DESIGNATED_INITIALIZER;
+
+@property (nonatomic, assign) UIEdgeInsets capInsets;
+@property (nonatomic, strong) UIImage *defaultImage;
+@property (nonatomic, assign) UIImageRenderingMode renderingMode;
+@property (nonatomic, copy) NSArray<RCTImageSource *> *imageSources;
+@property (nonatomic, assign) CGFloat blurRadius;
+@property (nonatomic, assign) RCTResizeMode resizeMode;
+
+@end

node_modules/react-native/Libraries/Image/RCTImageView.m

@@ -0,0 +1,453 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageView.h"
+
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTEventDispatcher.h>
+#import <React/RCTImageSource.h>
+#import <React/RCTUtils.h>
+#import <React/UIView+React.h>
+
+#import "RCTImageBlurUtils.h"
+#import "RCTImageLoader.h"
+#import "RCTImageUtils.h"
+
+/**
+ * Determines whether an image of `currentSize` should be reloaded for display
+ * at `idealSize`.
+ */
+static BOOL RCTShouldReloadImageForSizeChange(CGSize currentSize, CGSize idealSize)
+{
+  static const CGFloat upscaleThreshold = 1.2;
+  static const CGFloat downscaleThreshold = 0.5;
+
+  CGFloat widthMultiplier = idealSize.width / currentSize.width;
+  CGFloat heightMultiplier = idealSize.height / currentSize.height;
+
+  return widthMultiplier > upscaleThreshold || widthMultiplier < downscaleThreshold ||
+    heightMultiplier > upscaleThreshold || heightMultiplier < downscaleThreshold;
+}
+
+/**
+ * See RCTConvert (ImageSource). We want to send down the source as a similar
+ * JSON parameter.
+ */
+static NSDictionary *onLoadParamsForSource(RCTImageSource *source)
+{
+  NSDictionary *dict = @{
+    @"width": @(source.size.width),
+    @"height": @(source.size.height),
+    @"url": source.request.URL.absoluteString,
+  };
+  return @{ @"source": dict };
+}
+
+@interface RCTImageView ()
+
+@property (nonatomic, copy) RCTDirectEventBlock onLoadStart;
+@property (nonatomic, copy) RCTDirectEventBlock onProgress;
+@property (nonatomic, copy) RCTDirectEventBlock onError;
+@property (nonatomic, copy) RCTDirectEventBlock onPartialLoad;
+@property (nonatomic, copy) RCTDirectEventBlock onLoad;
+@property (nonatomic, copy) RCTDirectEventBlock onLoadEnd;
+
+@end
+
+@implementation RCTImageView
+{
+  // Weak reference back to the bridge, for image loading
+  __weak RCTBridge *_bridge;
+
+  // The image source that's currently displayed
+  RCTImageSource *_imageSource;
+
+  // The image source that's being loaded from the network
+  RCTImageSource *_pendingImageSource;
+
+  // Size of the image loaded / being loaded, so we can determine when to issue a reload to accommodate a changing size.
+  CGSize _targetSize;
+
+  // A block that can be invoked to cancel the most recent call to -reloadImage, if any
+  RCTImageLoaderCancellationBlock _reloadImageCancellationBlock;
+
+  // Whether the latest change of props requires the image to be reloaded
+  BOOL _needsReload;
+}
+
+- (instancetype)initWithBridge:(RCTBridge *)bridge
+{
+  if ((self = [super init])) {
+    _bridge = bridge;
+
+    NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
+    [center addObserver:self
+               selector:@selector(clearImageIfDetached)
+                   name:UIApplicationDidReceiveMemoryWarningNotification
+                 object:nil];
+    [center addObserver:self
+               selector:@selector(clearImageIfDetached)
+                   name:UIApplicationDidEnterBackgroundNotification
+                 object:nil];
+  }
+  return self;
+}
+
+- (void)dealloc
+{
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+RCT_NOT_IMPLEMENTED(- (instancetype)init)
+
+- (void)updateWithImage:(UIImage *)image
+{
+  if (!image) {
+    super.image = nil;
+    return;
+  }
+
+  // Apply rendering mode
+  if (_renderingMode != image.renderingMode) {
+    image = [image imageWithRenderingMode:_renderingMode];
+  }
+
+  if (_resizeMode == RCTResizeModeRepeat) {
+    image = [image resizableImageWithCapInsets:_capInsets resizingMode:UIImageResizingModeTile];
+  } else if (!UIEdgeInsetsEqualToEdgeInsets(UIEdgeInsetsZero, _capInsets)) {
+    // Applying capInsets of 0 will switch the "resizingMode" of the image to "tile" which is undesired
+    image = [image resizableImageWithCapInsets:_capInsets resizingMode:UIImageResizingModeStretch];
+  }
+
+  // Apply trilinear filtering to smooth out mis-sized images
+  self.layer.minificationFilter = kCAFilterTrilinear;
+  self.layer.magnificationFilter = kCAFilterTrilinear;
+
+  super.image = image;
+}
+
+- (void)setImage:(UIImage *)image
+{
+  image = image ?: _defaultImage;
+  if (image != self.image) {
+    [self updateWithImage:image];
+  }
+}
+
+- (void)setBlurRadius:(CGFloat)blurRadius
+{
+  if (blurRadius != _blurRadius) {
+    _blurRadius = blurRadius;
+    _needsReload = YES;
+  }
+}
+
+- (void)setCapInsets:(UIEdgeInsets)capInsets
+{
+  if (!UIEdgeInsetsEqualToEdgeInsets(_capInsets, capInsets)) {
+    if (UIEdgeInsetsEqualToEdgeInsets(_capInsets, UIEdgeInsetsZero) ||
+        UIEdgeInsetsEqualToEdgeInsets(capInsets, UIEdgeInsetsZero)) {
+      _capInsets = capInsets;
+      // Need to reload image when enabling or disabling capInsets
+      _needsReload = YES;
+    } else {
+      _capInsets = capInsets;
+      [self updateWithImage:self.image];
+    }
+  }
+}
+
+- (void)setRenderingMode:(UIImageRenderingMode)renderingMode
+{
+  if (_renderingMode != renderingMode) {
+    _renderingMode = renderingMode;
+    [self updateWithImage:self.image];
+  }
+}
+
+- (void)setImageSources:(NSArray<RCTImageSource *> *)imageSources
+{
+  if (![imageSources isEqual:_imageSources]) {
+    _imageSources = [imageSources copy];
+    _needsReload = YES;
+  }
+}
+
+- (void)setResizeMode:(RCTResizeMode)resizeMode
+{
+  if (_resizeMode != resizeMode) {
+    _resizeMode = resizeMode;
+
+    if (_resizeMode == RCTResizeModeRepeat) {
+      // Repeat resize mode is handled by the UIImage. Use scale to fill
+      // so the repeated image fills the UIImageView.
+      self.contentMode = UIViewContentModeScaleToFill;
+    } else {
+      self.contentMode = (UIViewContentMode)resizeMode;
+    }
+
+    if ([self shouldReloadImageSourceAfterResize]) {
+      _needsReload = YES;
+    }
+  }
+}
+
+- (void)cancelImageLoad
+{
+  RCTImageLoaderCancellationBlock previousCancellationBlock = _reloadImageCancellationBlock;
+  if (previousCancellationBlock) {
+    previousCancellationBlock();
+    _reloadImageCancellationBlock = nil;
+  }
+
+  _pendingImageSource = nil;
+}
+
+- (void)clearImage
+{
+  [self cancelImageLoad];
+  [self.layer removeAnimationForKey:@"contents"];
+  self.image = nil;
+  _imageSource = nil;
+}
+
+- (void)clearImageIfDetached
+{
+  if (!self.window) {
+    [self clearImage];
+  }
+}
+
+- (BOOL)hasMultipleSources
+{
+  return _imageSources.count > 1;
+}
+
+- (RCTImageSource *)imageSourceForSize:(CGSize)size
+{
+  if (![self hasMultipleSources]) {
+    return _imageSources.firstObject;
+  }
+
+  // Need to wait for layout pass before deciding.
+  if (CGSizeEqualToSize(size, CGSizeZero)) {
+    return nil;
+  }
+
+  const CGFloat scale = RCTScreenScale();
+  const CGFloat targetImagePixels = size.width * size.height * scale * scale;
+
+  RCTImageSource *bestSource = nil;
+  CGFloat bestFit = CGFLOAT_MAX;
+  for (RCTImageSource *source in _imageSources) {
+    CGSize imgSize = source.size;
+    const CGFloat imagePixels =
+      imgSize.width * imgSize.height * source.scale * source.scale;
+    const CGFloat fit = ABS(1 - (imagePixels / targetImagePixels));
+
+    if (fit < bestFit) {
+      bestFit = fit;
+      bestSource = source;
+    }
+  }
+  return bestSource;
+}
+
+- (BOOL)shouldReloadImageSourceAfterResize
+{
+  // If capInsets are set, image doesn't need reloading when resized
+  return UIEdgeInsetsEqualToEdgeInsets(_capInsets, UIEdgeInsetsZero);
+}
+
+- (BOOL)shouldChangeImageSource
+{
+  // We need to reload if the desired image source is different from the current image
+  // source AND the image load that's pending
+  RCTImageSource *desiredImageSource = [self imageSourceForSize:self.frame.size];
+  return ![desiredImageSource isEqual:_imageSource] &&
+         ![desiredImageSource isEqual:_pendingImageSource];
+}
+
+- (void)reloadImage
+{
+  [self cancelImageLoad];
+  _needsReload = NO;
+
+  RCTImageSource *source = [self imageSourceForSize:self.frame.size];
+  _pendingImageSource = source;
+
+  if (source && self.frame.size.width > 0 && self.frame.size.height > 0) {
+    if (_onLoadStart) {
+      _onLoadStart(nil);
+    }
+
+    RCTImageLoaderProgressBlock progressHandler = nil;
+    if (_onProgress) {
+      progressHandler = ^(int64_t loaded, int64_t total) {
+        self->_onProgress(@{
+          @"loaded": @((double)loaded),
+          @"total": @((double)total),
+        });
+      };
+    }
+
+    __weak RCTImageView *weakSelf = self;
+    RCTImageLoaderPartialLoadBlock partialLoadHandler = ^(UIImage *image) {
+      [weakSelf imageLoaderLoadedImage:image error:nil forImageSource:source partial:YES];
+    };
+
+    CGSize imageSize = self.bounds.size;
+    CGFloat imageScale = RCTScreenScale();
+    if (!UIEdgeInsetsEqualToEdgeInsets(_capInsets, UIEdgeInsetsZero)) {
+      // Don't resize images that use capInsets
+      imageSize = CGSizeZero;
+      imageScale = source.scale;
+    }
+
+    RCTImageLoaderCompletionBlock completionHandler = ^(NSError *error, UIImage *loadedImage) {
+      [weakSelf imageLoaderLoadedImage:loadedImage error:error forImageSource:source partial:NO];
+    };
+
+    _reloadImageCancellationBlock =
+    [_bridge.imageLoader loadImageWithURLRequest:source.request
+                                            size:imageSize
+                                           scale:imageScale
+                                         clipped:NO
+                                      resizeMode:_resizeMode
+                                   progressBlock:progressHandler
+                                partialLoadBlock:partialLoadHandler
+                                 completionBlock:completionHandler];
+  } else {
+    [self clearImage];
+  }
+}
+
+- (void)imageLoaderLoadedImage:(UIImage *)loadedImage error:(NSError *)error forImageSource:(RCTImageSource *)source partial:(BOOL)isPartialLoad
+{
+  if (![source isEqual:_pendingImageSource]) {
+    // Bail out if source has changed since we started loading
+    return;
+  }
+
+  if (error) {
+    if (_onError) {
+      _onError(@{ @"error": error.localizedDescription });
+    }
+    if (_onLoadEnd) {
+      _onLoadEnd(nil);
+    }
+    return;
+  }
+
+  void (^setImageBlock)(UIImage *) = ^(UIImage *image) {
+    if (!isPartialLoad) {
+      self->_imageSource = source;
+      self->_pendingImageSource = nil;
+    }
+
+    if (image.reactKeyframeAnimation) {
+      [self.layer addAnimation:image.reactKeyframeAnimation forKey:@"contents"];
+    } else {
+      [self.layer removeAnimationForKey:@"contents"];
+      self.image = image;
+    }
+
+    if (isPartialLoad) {
+      if (self->_onPartialLoad) {
+        self->_onPartialLoad(nil);
+      }
+    } else {
+      if (self->_onLoad) {
+        RCTImageSource *sourceLoaded = [source imageSourceWithSize:image.size scale:source.scale];
+        self->_onLoad(onLoadParamsForSource(sourceLoaded));
+      }
+      if (self->_onLoadEnd) {
+        self->_onLoadEnd(nil);
+      }
+    }
+  };
+
+  if (_blurRadius > __FLT_EPSILON__) {
+    // Blur on a background thread to avoid blocking interaction
+    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+      UIImage *blurredImage = RCTBlurredImageWithRadius(loadedImage, self->_blurRadius);
+      RCTExecuteOnMainQueue(^{
+        setImageBlock(blurredImage);
+      });
+    });
+  } else {
+    // No blur, so try to set the image on the main thread synchronously to minimize image
+    // flashing. (For instance, if this view gets attached to a window, then -didMoveToWindow
+    // calls -reloadImage, and we want to set the image synchronously if possible so that the
+    // image property is set in the same CATransaction that attaches this view to the window.)
+    RCTExecuteOnMainQueue(^{
+      setImageBlock(loadedImage);
+    });
+  }
+}
+
+- (void)reactSetFrame:(CGRect)frame
+{
+  [super reactSetFrame:frame];
+
+  // If we didn't load an image yet, or the new frame triggers a different image source
+  // to be loaded, reload to swap to the proper image source.
+  if ([self shouldChangeImageSource]) {
+    _targetSize = frame.size;
+    [self reloadImage];
+  } else if ([self shouldReloadImageSourceAfterResize]) {
+    CGSize imageSize = self.image.size;
+    CGFloat imageScale = self.image.scale;
+    CGSize idealSize = RCTTargetSize(imageSize, imageScale, frame.size, RCTScreenScale(),
+                                     (RCTResizeMode)self.contentMode, YES);
+
+    // Don't reload if the current image or target image size is close enough
+    if (!RCTShouldReloadImageForSizeChange(imageSize, idealSize) ||
+        !RCTShouldReloadImageForSizeChange(_targetSize, idealSize)) {
+      return;
+    }
+
+    // Don't reload if the current image size is the maximum size of the image source
+    CGSize imageSourceSize = _imageSource.size;
+    if (imageSize.width * imageScale == imageSourceSize.width * _imageSource.scale &&
+        imageSize.height * imageScale == imageSourceSize.height * _imageSource.scale) {
+      return;
+    }
+
+    RCTLogInfo(@"Reloading image %@ as size %@", _imageSource.request.URL.absoluteString, NSStringFromCGSize(idealSize));
+
+    // If the existing image or an image being loaded are not the right
+    // size, reload the asset in case there is a better size available.
+    _targetSize = idealSize;
+    [self reloadImage];
+  }
+}
+
+- (void)didSetProps:(NSArray<NSString *> *)changedProps
+{
+  if (_needsReload) {
+    [self reloadImage];
+  }
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+
+  if (!self.window) {
+    // Cancel loading the image if we've moved offscreen. In addition to helping
+    // prioritise image requests that are actually on-screen, this removes
+    // requests that have gotten "stuck" from the queue, unblocking other images
+    // from loading.
+    [self cancelImageLoad];
+  } else if ([self shouldChangeImageSource]) {
+    [self reloadImage];
+  }
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTImageViewManager.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTViewManager.h>
+
+@interface RCTImageViewManager : RCTViewManager
+
+@end

node_modules/react-native/Libraries/Image/RCTImageViewManager.m

@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTImageViewManager.h"
+
+#import <UIKit/UIKit.h>
+
+#import <React/RCTConvert.h>
+
+#import "RCTImageLoader.h"
+#import "RCTImageShadowView.h"
+#import "RCTImageView.h"
+
+@implementation RCTImageViewManager
+
+RCT_EXPORT_MODULE()
+
+- (RCTShadowView *)shadowView
+{
+  return [RCTImageShadowView new];
+}
+
+- (UIView *)view
+{
+  return [[RCTImageView alloc] initWithBridge:self.bridge];
+}
+
+RCT_EXPORT_VIEW_PROPERTY(blurRadius, CGFloat)
+RCT_EXPORT_VIEW_PROPERTY(capInsets, UIEdgeInsets)
+RCT_REMAP_VIEW_PROPERTY(defaultSource, defaultImage, UIImage)
+RCT_EXPORT_VIEW_PROPERTY(onLoadStart, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onProgress, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onError, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onPartialLoad, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onLoad, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onLoadEnd, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(resizeMode, RCTResizeMode)
+RCT_REMAP_VIEW_PROPERTY(source, imageSources, NSArray<RCTImageSource *>);
+RCT_CUSTOM_VIEW_PROPERTY(tintColor, UIColor, RCTImageView)
+{
+  // Default tintColor isn't nil - it's inherited from the superView - but we
+  // want to treat a null json value for `tintColor` as meaning 'disable tint',
+  // so we toggle `renderingMode` here instead of in `-[RCTImageView setTintColor:]`
+  view.tintColor = [RCTConvert UIColor:json] ?: defaultView.tintColor;
+  view.renderingMode = json ? UIImageRenderingModeAlwaysTemplate : defaultView.renderingMode;
+}
+
+RCT_EXPORT_METHOD(getSize:(NSURLRequest *)request
+                  successBlock:(RCTResponseSenderBlock)successBlock
+                  errorBlock:(RCTResponseErrorBlock)errorBlock)
+{
+  [self.bridge.imageLoader getImageSizeForURLRequest:request
+                                               block:^(NSError *error, CGSize size) {
+                                                 if (error) {
+                                                   errorBlock(error);
+                                                 } else {
+                                                   successBlock(@[@(size.width), @(size.height)]);
+                                                 }
+                                               }];
+}
+
+RCT_EXPORT_METHOD(prefetchImage:(NSURLRequest *)request
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+  if (!request) {
+    reject(@"E_INVALID_URI", @"Cannot prefetch an image for an empty URI", nil);
+    return;
+  }
+
+  [self.bridge.imageLoader loadImageWithURLRequest:request
+                                          callback:^(NSError *error, UIImage *image) {
+                                            if (error) {
+                                              reject(@"E_PREFETCH_FAILURE", nil, error);
+                                              return;
+                                            }
+                                            resolve(@YES);
+                                          }];
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTLocalAssetImageLoader.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTImageLoader.h>
+
+@interface RCTLocalAssetImageLoader : NSObject <RCTImageURLLoader>
+
+@end

node_modules/react-native/Libraries/Image/RCTLocalAssetImageLoader.m

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTLocalAssetImageLoader.h"
+
+#import <stdatomic.h>
+
+#import <React/RCTUtils.h>
+
+@implementation RCTLocalAssetImageLoader
+
+RCT_EXPORT_MODULE()
+
+- (BOOL)canLoadImageURL:(NSURL *)requestURL
+{
+  return RCTIsLocalAssetURL(requestURL);
+}
+
+- (BOOL)requiresScheduling
+{
+  // Don't schedule this loader on the URL queue so we can load the
+  // local assets synchronously to avoid flickers.
+  return NO;
+}
+
+- (BOOL)shouldCacheLoadedImages
+{
+  // UIImage imageNamed handles the caching automatically so we don't want
+  // to add it to the image cache.
+  return NO;
+}
+
+ - (RCTImageLoaderCancellationBlock)loadImageForURL:(NSURL *)imageURL
+                                               size:(CGSize)size
+                                              scale:(CGFloat)scale
+                                         resizeMode:(RCTResizeMode)resizeMode
+                                    progressHandler:(RCTImageLoaderProgressBlock)progressHandler
+                                 partialLoadHandler:(RCTImageLoaderPartialLoadBlock)partialLoadHandler
+                                  completionHandler:(RCTImageLoaderCompletionBlock)completionHandler
+{
+  __block atomic_bool cancelled = ATOMIC_VAR_INIT(NO);
+  RCTExecuteOnMainQueue(^{
+    if (atomic_load(&cancelled)) {
+      return;
+    }
+
+    UIImage *image = RCTImageFromLocalAssetURL(imageURL);
+    if (image) {
+      if (progressHandler) {
+        progressHandler(1, 1);
+      }
+      completionHandler(nil, image);
+    } else {
+      NSString *message = [NSString stringWithFormat:@"Could not find image %@", imageURL];
+      RCTLogWarn(@"%@", message);
+      completionHandler(RCTErrorWithMessage(message), nil);
+    }
+  });
+
+  return ^{
+    atomic_store(&cancelled, YES);
+  };
+}
+
+@end

node_modules/react-native/Libraries/Image/RCTResizeMode.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTConvert.h>
+
+typedef NS_ENUM(NSInteger, RCTResizeMode) {
+  RCTResizeModeCover = UIViewContentModeScaleAspectFill,
+  RCTResizeModeContain = UIViewContentModeScaleAspectFit,
+  RCTResizeModeStretch = UIViewContentModeScaleToFill,
+  RCTResizeModeCenter = UIViewContentModeCenter,
+  RCTResizeModeRepeat = -1, // Use negative values to avoid conflicts with iOS enum values.
+};
+
+@interface RCTConvert(RCTResizeMode)
+
++ (RCTResizeMode)RCTResizeMode:(id)json;
+
+@end

node_modules/react-native/Libraries/Image/RCTResizeMode.m

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTResizeMode.h"
+
+@implementation RCTConvert(RCTResizeMode)
+
+RCT_ENUM_CONVERTER(RCTResizeMode, (@{
+  @"cover": @(RCTResizeModeCover),
+  @"contain": @(RCTResizeModeContain),
+  @"stretch": @(RCTResizeModeStretch),
+  @"center": @(RCTResizeModeCenter),
+  @"repeat": @(RCTResizeModeRepeat),
+}), RCTResizeModeStretch, integerValue)
+
+@end

node_modules/react-native/Libraries/Image/RelativeImageStub.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule RelativeImageStub
+ * @flow
+ */
+'use strict';
+
+// This is a stub for flow to make it understand require('./icon.png')
+// See metro/src/Bundler/index.js
+
+var AssetRegistry = require('AssetRegistry');
+
+module.exports = AssetRegistry.registerAsset({
+  __packager_asset: true,
+  fileSystemLocation: '/full/path/to/directory',
+  httpServerLocation: '/assets/full/path/to/directory',
+  width: 100,
+  height: 100,
+  scales: [1, 2, 3],
+  hash: 'nonsense',
+  name: 'icon',
+  type: 'png',
+});

node_modules/react-native/Libraries/Image/nativeImageSource.js

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule nativeImageSource
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const Platform = require('Platform');
+
+// TODO: Change `nativeImageSource` to return this type.
+export type NativeImageSource = {|
+  +deprecated: true,
+  +height: number,
+  +uri: string,
+  +width: number,
+|};
+
+type NativeImageSourceSpec = {|
+  +android?: string,
+  +ios?: string,
+
+  // For more details on width and height, see
+  // http://facebook.github.io/react-native/docs/images.html#why-not-automatically-size-everything
+  +height: number,
+  +width: number,
+|};
+
+/**
+ * In hybrid apps, use `nativeImageSource` to access images that are already
+ * available on the native side, for example in Xcode Asset Catalogs or
+ * Android's drawable folder.
+ *
+ * However, keep in mind that React Native Packager does not guarantee that the
+ * image exists. If the image is missing you'll get an empty box. When adding
+ * new images your app needs to be recompiled.
+ *
+ * Prefer Static Image Resources system which provides more guarantees,
+ * automates measurements and allows adding new images without rebuilding the
+ * native app. For more details visit:
+ *
+ *   http://facebook.github.io/react-native/docs/images.html
+ *
+ */
+function nativeImageSource(spec: NativeImageSourceSpec): Object {
+  let uri = Platform.select(spec);
+  if (uri == null) {
+    console.warn(
+      'nativeImageSource(...): No image name supplied for `%s`:\n%s',
+      Platform.OS,
+      JSON.stringify(spec, null, 2),
+    );
+    uri = '';
+  }
+  return {
+    deprecated: true,
+    height: spec.height,
+    uri,
+    width: spec.width,
+  };
+}
+
+module.exports = nativeImageSource;

node_modules/react-native/Libraries/Image/resolveAssetSource.js

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule resolveAssetSource
+ * @flow
+ *
+ * Resolves an asset into a `source` for `Image`.
+ */
+'use strict';
+
+const AssetRegistry = require('AssetRegistry');
+const AssetSourceResolver = require('AssetSourceResolver');
+
+import type { ResolvedAssetSource } from 'AssetSourceResolver';
+
+let _customSourceTransformer, _serverURL, _scriptURL;
+let _sourceCodeScriptURL: ?string;
+
+function getDevServerURL(): ?string {
+  if (_serverURL === undefined) {
+    const match = _sourceCodeScriptURL && _sourceCodeScriptURL.match(/^https?:\/\/.*?\//);
+    if (match) {
+      // jsBundle was loaded from network
+      _serverURL = match[0];
+    } else {
+      // jsBundle was loaded from file
+      _serverURL = null;
+    }
+  }
+  return _serverURL;
+}
+
+function _coerceLocalScriptURL(scriptURL: ?string): ?string {
+  if (scriptURL) {
+    if (scriptURL.startsWith('assets://')) {
+      // android: running from within assets, no offline path to use
+      return null;
+    }
+    scriptURL = scriptURL.substring(0, scriptURL.lastIndexOf('/') + 1);
+    if (!scriptURL.includes('://')) {
+      // Add file protocol in case we have an absolute file path and not a URL.
+      // This shouldn't really be necessary. scriptURL should be a URL.
+      scriptURL = 'file://' + scriptURL;
+    }
+  }
+  return scriptURL;
+}
+
+function getScriptURL(): ?string {
+  if (_scriptURL === undefined) {
+    _scriptURL = _coerceLocalScriptURL(_sourceCodeScriptURL);
+  }
+  return _scriptURL;
+}
+
+function setCustomSourceTransformer(
+  transformer: (resolver: AssetSourceResolver) => ResolvedAssetSource,
+): void {
+  _customSourceTransformer = transformer;
+}
+
+/**
+ * `source` is either a number (opaque type returned by require('./foo.png'))
+ * or an `ImageSource` like { uri: '<http location || file path>' }
+ */
+function resolveAssetSource(source: any): ?ResolvedAssetSource {
+  if (typeof source === 'object') {
+    return source;
+  }
+
+  var asset = AssetRegistry.getAssetByID(source);
+  if (!asset) {
+    return null;
+  }
+
+  const resolver = new AssetSourceResolver(
+    getDevServerURL(),
+    getScriptURL(),
+    asset,
+  );
+  if (_customSourceTransformer) {
+    return _customSourceTransformer(resolver);
+  }
+  return resolver.defaultAsset();
+}
+
+let sourceCode = global.nativeExtensions && global.nativeExtensions.SourceCode;
+if (!sourceCode) {
+  const NativeModules = require('NativeModules');
+  sourceCode = NativeModules && NativeModules.SourceCode;
+}
+_sourceCodeScriptURL = sourceCode && sourceCode.scriptURL;
+
+module.exports = resolveAssetSource;
+module.exports.pickScale = AssetSourceResolver.pickScale;
+module.exports.setCustomSourceTransformer = setCustomSourceTransformer;