text: /**
   * 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.
   *
   * @flow
   * @format
   * @providesModule asyncRequire
   */
  
  'use strict';
  
  /**
   * The bundler must register the dependency properly when generating a call to
   * `asyncRequire`, that allows us to call `require` dynamically with confidence
   * the module ID is indeed valid and available.
   */
  function asyncRequire(moduleID: number): Promise<mixed> {
    return Promise.resolve()
      .then(() => {
        const {segmentId} = (require: $FlowFixMe).unpackModuleId(moduleID);
        return loadSegment(segmentId);
      })
      .then(() => require.call(null, (moduleID: $FlowFixMe)));
  }
  
  let segmentLoaders = new Map();
  
  /**
   * Ensure that a bundle segment is ready for use, for example requiring some of
   * its module. We cache load promises so as to avoid calling `fetchSegment`
   * twice for the same bundle. We assume that once a segment is fetched/loaded,
   * it is never gettting removed during this instance of the JavaScript VM.
   *
   * Segment #0 is the main segment, that is always available by definition, so
   * we never try to load anything.
   *
   * We don't use async/await syntax to avoid depending on `regeneratorRuntime`.
   */
  function loadSegment(segmentId: number): Promise<void> {
    return Promise.resolve().then(() => {
      if (segmentId === 0) {
        return;
      }
      let segmentLoader = segmentLoaders.get(segmentId);
      if (segmentLoader != null) {
        return segmentLoader;
      }
      const {fetchSegment} = global;
      if (fetchSegment == null) {
        throw new FetchSegmentNotAvailableError();
      }
      segmentLoader = new Promise((resolve, reject) => {
        fetchSegment(segmentId, error => {
          if (error != null) {
            reject(error);
            return;
          }
          resolve();
        });
      });
      segmentLoaders.set(segmentId, segmentLoader);
      return segmentLoader;
    });
  }
  
  class FetchSegmentNotAvailableError extends Error {
    constructor() {
      super(
        'When bundle splitting is enabled, the `global.fetchSegment` function ' +
          'must be provided to be able to load particular bundle segments.',
      );
    }
  }
  
  module.exports = asyncRequire;
  