constructor(requestBundles, createContext) {
    const createHeadContext =
      bundles => createHeadContextWith(createContext, bundles);

    // Keep `requestBundles` and `createHeadContext` private.
    properties.set(this, {
      requestBundles, createHeadContext
    });

    /**
     * A Promise which resolves when the `Localization` instance has fetched
     * and parsed all localization resources in the user's first preferred
     * language (if available).
     *
     *     localization.interactive.then(callback);
     */
    this.interactive = requestBundles().then(
      // Create a `MessageContext` for the first bundle right away.
      bundles => createHeadContext(bundles).then(
        // Force `this.interactive` to resolve to the list of bundles.
        () => bundles
      )
    );
  }
Create an instance of the `Localization` class.

The instance's configuration is provided by two runtime-dependent
functions passed to the constructor.

The `requestBundles` function takes an array of language codes and returns
a Promise of an array of lazy `ResourceBundle` instances.  The
`Localization` instance will imediately call the `fetch` method of the
first bundle returned by `requestBundles` and may call `fetch` on
subsequent bundles in fallback scenarios.

The array of bundles is the de-facto current fallback chain of languages
and fetch locations.

The `createContext` function takes a language code and returns an instance
of `Intl.MessageContext`.  Since it's also provided to the constructor by
the runtime it may pass runtime-specific `functions` to the
`MessageContext` instances it creates.

@param   {Function}     requestBundles
@param   {Function}     createContext
@returns {Localization}