hunk.code_window:       return;
       }
       WritableMap result = Arguments.createMap();
       result.putString("type", "dismiss");
       mOpenBrowserPromise.resolve(result);
  
hunk.labels: keep keep add keep keep keep
hunk.after_edit:     EventBus.getDefault().unregister(this);
  
hunk.file_path: android/app/src/main/java/abi14_0_0/host/exp/exponent/modules/api/WebBrowserModule.java
hunk.type: add
file: /**
   * Copyright (c) 2015-present, Facebook, Inc.
   * All rights reserved.
   *
   * This source code is licensed under the BSD-style license found in the
   * LICENSE file in the root directory of this source tree. An additional grant
   * of patent rights can be found in the PATENTS file in the same directory.
   *
   * @providesModule Map
   * @preventMunge
   * @typechecks
   */
  
  /* eslint-disable no-extend-native, no-shadow-restricted-names */
  
  'use strict';
  
  var _shouldPolyfillES6Collection = require('_shouldPolyfillES6Collection');
  var guid = require('guid');
  var isNode = require('fbjs/lib/isNode');
  var toIterator = require('toIterator');
  
  module.exports = (function(global, undefined) {
    // Since our implementation is spec-compliant for the most part we can safely
    // delegate to a built-in version if exists and is implemented correctly.
    // Firefox had gotten a few implementation details wrong across different
    // versions so we guard against that.
    if (!_shouldPolyfillES6Collection('Map')) {
      return global.Map;
    }
  
    /**
     * == ES6 Map Collection ==
     *
     * This module is meant to implement a Map collection as described in chapter
     * 23.1 of the ES6 specification.
     *
     * Map objects are collections of key/value pairs where both the keys and
     * values may be arbitrary ECMAScript language values. A distinct key value
     * may only occur in one key/value pair within the Map's collection.
     *
     * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-map-objects
     *
     * There only two -- rather small -- diviations from the spec:
     *
     * 1. The use of frozen objects as keys.
     *    We decided not to allow and simply throw an error. The reason being is
     *    we store a "hash" on the object for fast access to it's place in the
     *    internal map entries.
     *    If this turns out to be a popular use case it's possible to implement by
     *    overiding `Object.freeze` to store a "hash" property on the object
     *    for later use with the map.
     *
     * 2. The `size` property on a map object is a regular property and not a
     *    computed property on the prototype as described by the spec.
     *    The reason being is that we simply want to support ES3 environments
     *    which doesn't implement computed properties.
     *
     * == Usage ==
     *
     * var map = new Map(iterable);
     *
     * map.set(key, value);
     * map.get(key); // value
     * map.has(key); // true
     * map.delete(key); // true
     *
     * var iterator = map.keys();
     * iterator.next(); // {value: key, done: false}
     *
     * var iterator = map.values();
     * iterator.next(); // {value: value, done: false}
     *
     * var iterator = map.entries();
     * iterator.next(); // {value: [key, value], done: false}
     *
     * map.forEach(function(value, key){ this === thisArg }, thisArg);
     *
     * map.clear(); // resets map.
     */
  
    /**
     * Constants
     */
  
    // Kinds of map iterations 23.1.5.3
    var KIND_KEY = 'key';
    var KIND_VALUE = 'value';
    var KIND_KEY_VALUE = 'key+value';
  
    // In older browsers we can't create a null-prototype object so we have to
    // defend against key collisions with built-in methods.
    var KEY_PREFIX = '$map_';
  
    // This property will be used as the internal size variable to disallow
    // writing and to issue warnings for writings in development.
    var SECRET_SIZE_PROP;
    if (__DEV__) {
      SECRET_SIZE_PROP = '$size' + guid();
    }
  
    // In oldIE we use the DOM Node `uniqueID` property to get create the hash.
    var OLD_IE_HASH_PREFIX = 'IE_HASH_';
  
    class Map {
  
      /**
       * 23.1.1.1
       * Takes an `iterable` which is basically any object that implements a
       * Symbol.iterator (@@iterator) method. The iterable is expected to be a
       * collection of pairs. Each pair is a key/value pair that will be used
       * to instantiate the map.
       *
       * @param {*} iterable
       */
      constructor(iterable) {
        if (!isObject(this)) {
          throw new TypeError('Wrong map object type.');
        }
  
        initMap(this);
  
        if (iterable != null) {
          var it = toIterator(iterable);
          var next;
          while (!(next = it.next()).done) {
            if (!isObject(next.value)) {
              throw new TypeError('Expected iterable items to be pair objects.');
            }
            this.set(next.value[0], next.value[1]);
          }
        }
      }
  
      /**
       * 23.1.3.1
       * Clears the map from all keys and values.
       */
      clear() {
        initMap(this);
      }
  
      /**
       * 23.1.3.7
       * Check if a key exists in the collection.
       *
       * @param {*} key
       * @return {boolean}
       */
      has(key) {
        var index = getIndex(this, key);
        return !!(index != null && this._mapData[index]);
      }
  
      /**
       * 23.1.3.9
       * Adds a key/value pair to the collection.
       *
       * @param {*} key
       * @param {*} value
       * @return {map}
       */
      set(key, value) {
        var index = getIndex(this, key);
  
        if (index != null && this._mapData[index]) {
          this._mapData[index][1] = value;
        } else {
          index = this._mapData.push([
            key,
            value
          ]) - 1;
          setIndex(this, key, index);
          if (__DEV__) {
            this[SECRET_SIZE_PROP] += 1;
          } else {
            this.size += 1;
          }
        }
  
        return this;
      }
  
      /**
       * 23.1.3.6
       * Gets a value associated with a key in the collection.
       *
       * @param {*} key
       * @return {*}
       */
      get(key) {
        var index = getIndex(this, key);
        if (index == null) {
          return undefined;
        } else {
          return this._mapData[index][1];
        }
      }
  
  
      /**
       * 23.1.3.3
       * Delete a key/value from the collection.
       *
       * @param {*} key
       * @return {boolean} Whether the key was found and deleted.
       */
      delete(key) {
        var index = getIndex(this, key);
        if (index != null && this._mapData[index]) {
          setIndex(this, key, undefined);
          this._mapData[index] = undefined;
          if (__DEV__) {
            this[SECRET_SIZE_PROP] -= 1;
          } else {
            this.size -= 1;
          }
          return true;
        } else {
          return false;
        }
      }
  
      /**
       * 23.1.3.4
       * Returns an iterator over the key/value pairs (in the form of an Array) in
       * the collection.
       *
       * @return {MapIterator}
       */
      entries() {
        return new MapIterator(this, KIND_KEY_VALUE);
      }
  
      /**
       * 23.1.3.8
       * Returns an iterator over the keys in the collection.
       *
       * @return {MapIterator}
       */
      keys() {
        return new MapIterator(this, KIND_KEY);
      }
  
      /**
       * 23.1.3.11
       * Returns an iterator over the values pairs in the collection.
       *
       * @return {MapIterator}
       */
      values() {
        return new MapIterator(this, KIND_VALUE);
      }
  
      /**
       * 23.1.3.5
       * Iterates over the key/value pairs in the collection calling `callback`
       * with [value, key, map]. An optional `thisArg` can be passed to set the
       * context when `callback` is called.
       *
       * @param {function} callback
       * @param {?object} thisArg
       */
      forEach(callback, thisArg) {
        if (typeof callback !== 'function') {
          throw new TypeError('Callback must be callable.');
        }
  
        var boundCallback = callback.bind(thisArg || undefined);
        var mapData = this._mapData;
  
        // Note that `mapData.length` should be computed on each iteration to
        // support iterating over new items in the map that were added after the
        // start of the iteration.
        for (var i = 0; i < mapData.length; i++) {
          var entry = mapData[i];
          if (entry != null) {
            boundCallback(entry[1], entry[0], this);
          }
        }
      }
    }
  
    // 23.1.3.12
    Map.prototype[toIterator.ITERATOR_SYMBOL] = Map.prototype.entries;
  
    class MapIterator {
  
      /**
       * 23.1.5.1
       * Create a `MapIterator` for a given `map`. While this class is private it
       * will create objects that will be passed around publicily.
       *
       * @param {map} map
       * @param {string} kind
       */
      constructor(map, kind) {
        if (!(isObject(map) && map._mapData)) {
          throw new TypeError('Object is not a map.');
        }
  
        if ([KIND_KEY, KIND_KEY_VALUE, KIND_VALUE].indexOf(kind) === -1) {
          throw new Error('Invalid iteration kind.');
        }
  
        this._map = map;
        this._nextIndex = 0;
        this._kind = kind;
      }
  
      /**
       * 23.1.5.2.1
       * Get the next iteration.
       *
       * @return {object}
       */
      next() {
        if (!this instanceof Map) {
          throw new TypeError('Expected to be called on a MapIterator.');
        }
  
        var map = this._map;
        var index = this._nextIndex;
        var kind = this._kind;
  
        if (map == null) {
          return createIterResultObject(undefined, true);
        }
  
        var entries = map._mapData;
  
        while (index < entries.length) {
          var record = entries[index];
  
          index += 1;
          this._nextIndex = index;
  
          if (record) {
            if (kind === KIND_KEY) {
              return createIterResultObject(record[0], false);
            } else if (kind === KIND_VALUE) {
              return createIterResultObject(record[1], false);
            } else if (kind) {
              return createIterResultObject(record, false);
            }
          }
        }
  
        this._map = undefined;
  
        return createIterResultObject(undefined, true);
      }
    }
  
    // We can put this in the class definition once we have computed props
    // transform.
    // 23.1.5.2.2
    MapIterator.prototype[toIterator.ITERATOR_SYMBOL] = function() {
      return this;
    };
  
    /**
     * Helper Functions.
     */
  
    /**
     * Return an index to map.[[MapData]] array for a given Key.
     *
     * @param {map} map
     * @param {*} key
     * @return {?number}
     */
    function getIndex(map, key) {
      if (isObject(key)) {
        var hash = getHash(key);
        return map._objectIndex[hash];
      } else {
        var prefixedKey = KEY_PREFIX + key;
        if (typeof key === 'string') {
          return map._stringIndex[prefixedKey];
        } else {
          return map._otherIndex[prefixedKey];
        }
      }
    }
  
    /**
     * Setup an index that refer to the key's location in map.[[MapData]].
     *
     * @param {map} map
     * @param {*} key
     */
    function setIndex(map, key, index) {
      var shouldDelete = index == null;
  
      if (isObject(key)) {
        var hash = getHash(key);
        if (shouldDelete) {
          delete map._objectIndex[hash];
        } else {
          map._objectIndex[hash] = index;
        }
      } else {
        var prefixedKey = KEY_PREFIX + key;
        if (typeof key === 'string') {
          if (shouldDelete) {
            delete map._stringIndex[prefixedKey];
          } else {
            map._stringIndex[prefixedKey] = index;
          }
        } else {
          if (shouldDelete) {
            delete map._otherIndex[prefixedKey];
          } else {
            map._otherIndex[prefixedKey] = index;
          }
        }
      }
    }
  
    /**
     * Instantiate a map with internal slots.
     *
     * @param {map} map
     */
    function initMap(map) {
      // Data structure design inspired by Traceur's Map implementation.
      // We maintain an internal array for all the entries. The array is needed
      // to remember order. However, to have a reasonable HashMap performance
      // i.e. O(1) for insertion, deletion, and retrieval. We maintain indices
      // in objects for fast look ups. Indices are split up according to data
      // types to avoid collisions.
      map._mapData = [];
  
      // Object index maps from an object "hash" to index. The hash being a unique
      // property of our choosing that we associate with the object. Association
      // is done by ways of keeping a non-enumerable property on the object.
      // Ideally these would be `Object.create(null)` objects but since we're
      // trying to support ES3 we'll have to gaurd against collisions using
      // prefixes on the keys rather than rely on null prototype objects.
      map._objectIndex = {};
  
      // String index maps from strings to index.
      map._stringIndex = {};
  
      // Numbers, booleans, undefined, and null.
      map._otherIndex = {};
  
      // Unfortunately we have to support ES3 and cannot have `Map.prototype.size`
      // be a getter method but just a regular method. The biggest problem with
      // this is safety. Clients can change the size property easily and possibly
      // without noticing (e.g. `if (map.size = 1) {..}` kind of typo). What we
      // can do to mitigate use getters and setters in development to disallow
      // and issue a warning for changing the `size` property.
      if (__DEV__) {
        if (isES5) {
          // If the `SECRET_SIZE_PROP` property is already defined then we're not
          // in the first call to `initMap` (e.g. coming from `map.clear()`) so
          // all we need to do is reset the size without defining the properties.
          if (map.hasOwnProperty(SECRET_SIZE_PROP)) {
            map[SECRET_SIZE_PROP] = 0;
          } else {
            Object.defineProperty(map, SECRET_SIZE_PROP, {
              value: 0,
              writable: true
            });
            Object.defineProperty(map, 'size', {
              set: (v) => {
                console.error(
                  'PLEASE FIX ME: You are changing the map size property which ' +
                  'should not be writable and will break in production.'
                );
                throw new Error('The map size property is not writable.');
              },
              get: () => map[SECRET_SIZE_PROP]
            });
          }
  
          // NOTE: Early return to implement immutable `.size` in DEV.
          return;
        }
      }
  
      // This is a diviation from the spec. `size` should be a getter on
      // `Map.prototype`. However, we have to support IE8.
      map.size = 0;
    }
  
    /**
     * Check if something is an object.
     *
     * @param {*} o
     * @return {boolean}
     */
    function isObject(o) {
      return o != null && (typeof o === 'object' || typeof o === 'function');
    }
  
    /**
     * Create an iteration object.
     *
     * @param {*} value
     * @param {boolean} done
     * @return {object}
     */
    function createIterResultObject(value, done) {
      return {value, done};
    }
  
    // Are we in a legit ES5 environment. Spoiler alert: that doesn't include IE8.
    var isES5 = (function() {
      try {
        Object.defineProperty({}, 'x', {});
        return true;
      } catch (e) {
        return false;
      }
    })();
  
    /**
     * Check if an object can be extended.
     *
     * @param {object|array|function|regexp} o
     * @return {boolean}
     */
    function isExtensible(o) {
      if (!isES5) {
        return true;
      } else {
        return Object.isExtensible(o);
      }
    }
  
    /**
     * IE has a `uniqueID` set on every DOM node. So we construct the hash from
     * this uniqueID to avoid memory leaks and the IE cloneNode bug where it
     * clones properties in addition to the attributes.
     *
     * @param {object} node
     * @return {?string}
     */
    function getIENodeHash(node) {
      var uniqueID;
      switch (node.nodeType) {
        case 1: // Element
          uniqueID = node.uniqueID;
          break;
        case 9: // Document
          uniqueID = node.documentElement.uniqueID;
          break;
        default:
          return null;
      }
  
      if (uniqueID) {
        return  OLD_IE_HASH_PREFIX + uniqueID;
      } else {
        return null;
      }
    }
  
    var getHash = (function() {
      var propIsEnumerable = Object.prototype.propertyIsEnumerable;
      var hashProperty = guid();
      var hashCounter = 0;
  
      /**
       * Get the "hash" associated with an object.
       *
       * @param {object|array|function|regexp} o
       * @return {number}
       */
      return function getHash(o) { // eslint-disable-line no-shadow
        if (o[hashProperty]) {
          return o[hashProperty];
        } else if (!isES5 &&
                    o.propertyIsEnumerable &&
                    o.propertyIsEnumerable[hashProperty]) {
          return o.propertyIsEnumerable[hashProperty];
        } else if (!isES5 &&
                    isNode(o) &&
                    getIENodeHash(o)) {
          return getIENodeHash(o);
        } else if (!isES5 && o[hashProperty]) {
          return o[hashProperty];
        }
  
        if (isExtensible(o)) {
          hashCounter += 1;
          if (isES5) {
            Object.defineProperty(o, hashProperty, {
              enumerable: false,
              writable: false,
              configurable: false,
              value: hashCounter
            });
          } else if (o.propertyIsEnumerable) {
            // Since we can't define a non-enumerable property on the object
            // we'll hijack one of the less-used non-enumerable properties to
            // save our hash on it. Addiotionally, since this is a function it
            // will not show up in `JSON.stringify` which is what we want.
            o.propertyIsEnumerable = function() {
              return propIsEnumerable.apply(this, arguments);
            };
            o.propertyIsEnumerable[hashProperty] = hashCounter;
          } else if (isNode(o)) {
            // At this point we couldn't get the IE `uniqueID` to use as a hash
            // and we couldn't use a non-enumerable property to exploit the
            // dontEnum bug so we simply add the `hashProperty` on the node
            // itself.
            o[hashProperty] = hashCounter;
          } else {
            throw new Error('Unable to set a non-enumerable property on object.');
          }
          return hashCounter;
        } else {
          throw new Error('Non-extensible objects are not allowed as keys.');
        }
      };
    })();
  
    return Map;
  })(Function('return this')()); // eslint-disable-line no-new-func
  