[Summary view] [Print] [Text view]

   1  /******/ (() => { // webpackBootstrap
   2  /******/     "use strict";
   3  /******/     // The require scope
   4  /******/     var __webpack_require__ = {};
   5  /******/     
   6  /************************************************************************/
   7  /******/     /* webpack/runtime/define property getters */
   8  /******/     (() => {
   9  /******/         // define getter functions for harmony exports
  10  /******/         __webpack_require__.d = (exports, definition) => {
  11  /******/             for(var key in definition) {
  12  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
  13  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
  14  /******/                 }
  15  /******/             }
  16  /******/         };
  17  /******/     })();
  18  /******/     
  19  /******/     /* webpack/runtime/hasOwnProperty shorthand */
  20  /******/     (() => {
  21  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
  22  /******/     })();
  23  /******/     
  24  /************************************************************************/
  25  var __webpack_exports__ = {};
  26  
  27  // EXPORTS
  28  __webpack_require__.d(__webpack_exports__, {
  29    "default": () => (/* binding */ build_module)
  30  });
  31  
  32  ;// external ["wp","i18n"]
  33  const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
  34  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/nonce.js
  35  /**
  36   * @param {string} nonce
  37   * @return {import('../types').APIFetchMiddleware & { nonce: string }} A middleware to enhance a request with a nonce.
  38   */
  39  function createNonceMiddleware(nonce) {
  40    /**
  41     * @type {import('../types').APIFetchMiddleware & { nonce: string }}
  42     */
  43    const middleware = (options, next) => {
  44      const {
  45        headers = {}
  46      } = options;
  47  
  48      // If an 'X-WP-Nonce' header (or any case-insensitive variation
  49      // thereof) was specified, no need to add a nonce header.
  50      for (const headerName in headers) {
  51        if (headerName.toLowerCase() === 'x-wp-nonce' && headers[headerName] === middleware.nonce) {
  52          return next(options);
  53        }
  54      }
  55      return next({
  56        ...options,
  57        headers: {
  58          ...headers,
  59          'X-WP-Nonce': middleware.nonce
  60        }
  61      });
  62    };
  63    middleware.nonce = nonce;
  64    return middleware;
  65  }
  66  /* harmony default export */ const nonce = (createNonceMiddleware);
  67  
  68  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/namespace-endpoint.js
  69  /**
  70   * @type {import('../types').APIFetchMiddleware}
  71   */
  72  const namespaceAndEndpointMiddleware = (options, next) => {
  73    let path = options.path;
  74    let namespaceTrimmed, endpointTrimmed;
  75    if (typeof options.namespace === 'string' && typeof options.endpoint === 'string') {
  76      namespaceTrimmed = options.namespace.replace(/^\/|\/$/g, '');
  77      endpointTrimmed = options.endpoint.replace(/^\//, '');
  78      if (endpointTrimmed) {
  79        path = namespaceTrimmed + '/' + endpointTrimmed;
  80      } else {
  81        path = namespaceTrimmed;
  82      }
  83    }
  84    delete options.namespace;
  85    delete options.endpoint;
  86    return next({
  87      ...options,
  88      path
  89    });
  90  };
  91  /* harmony default export */ const namespace_endpoint = (namespaceAndEndpointMiddleware);
  92  
  93  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/root-url.js
  94  /**
  95   * Internal dependencies
  96   */
  97  
  98  
  99  /**
 100   * @param {string} rootURL
 101   * @return {import('../types').APIFetchMiddleware} Root URL middleware.
 102   */
 103  const createRootURLMiddleware = rootURL => (options, next) => {
 104    return namespace_endpoint(options, optionsWithPath => {
 105      let url = optionsWithPath.url;
 106      let path = optionsWithPath.path;
 107      let apiRoot;
 108      if (typeof path === 'string') {
 109        apiRoot = rootURL;
 110        if (-1 !== rootURL.indexOf('?')) {
 111          path = path.replace('?', '&');
 112        }
 113        path = path.replace(/^\//, '');
 114  
 115        // API root may already include query parameter prefix if site is
 116        // configured to use plain permalinks.
 117        if ('string' === typeof apiRoot && -1 !== apiRoot.indexOf('?')) {
 118          path = path.replace('?', '&');
 119        }
 120        url = apiRoot + path;
 121      }
 122      return next({
 123        ...optionsWithPath,
 124        url
 125      });
 126    });
 127  };
 128  /* harmony default export */ const root_url = (createRootURLMiddleware);
 129  
 130  ;// external ["wp","url"]
 131  const external_wp_url_namespaceObject = window["wp"]["url"];
 132  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/preloading.js
 133  /**
 134   * WordPress dependencies
 135   */
 136  
 137  
 138  /**
 139   * @param {Record<string, any>} preloadedData
 140   * @return {import('../types').APIFetchMiddleware} Preloading middleware.
 141   */
 142  function createPreloadingMiddleware(preloadedData) {
 143    const cache = Object.fromEntries(Object.entries(preloadedData).map(([path, data]) => [(0,external_wp_url_namespaceObject.normalizePath)(path), data]));
 144    return (options, next) => {
 145      const {
 146        parse = true
 147      } = options;
 148      /** @type {string | void} */
 149      let rawPath = options.path;
 150      if (!rawPath && options.url) {
 151        const {
 152          rest_route: pathFromQuery,
 153          ...queryArgs
 154        } = (0,external_wp_url_namespaceObject.getQueryArgs)(options.url);
 155        if (typeof pathFromQuery === 'string') {
 156          rawPath = (0,external_wp_url_namespaceObject.addQueryArgs)(pathFromQuery, queryArgs);
 157        }
 158      }
 159      if (typeof rawPath !== 'string') {
 160        return next(options);
 161      }
 162      const method = options.method || 'GET';
 163      const path = (0,external_wp_url_namespaceObject.normalizePath)(rawPath);
 164      if ('GET' === method && cache[path]) {
 165        const cacheData = cache[path];
 166  
 167        // Unsetting the cache key ensures that the data is only used a single time.
 168        delete cache[path];
 169        return prepareResponse(cacheData, !!parse);
 170      } else if ('OPTIONS' === method && cache[method] && cache[method][path]) {
 171        const cacheData = cache[method][path];
 172  
 173        // Unsetting the cache key ensures that the data is only used a single time.
 174        delete cache[method][path];
 175        return prepareResponse(cacheData, !!parse);
 176      }
 177      return next(options);
 178    };
 179  }
 180  
 181  /**
 182   * This is a helper function that sends a success response.
 183   *
 184   * @param {Record<string, any>} responseData
 185   * @param {boolean}             parse
 186   * @return {Promise<any>} Promise with the response.
 187   */
 188  function prepareResponse(responseData, parse) {
 189    return Promise.resolve(parse ? responseData.body : new window.Response(JSON.stringify(responseData.body), {
 190      status: 200,
 191      statusText: 'OK',
 192      headers: responseData.headers
 193    }));
 194  }
 195  /* harmony default export */ const preloading = (createPreloadingMiddleware);
 196  
 197  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/fetch-all-middleware.js
 198  /**
 199   * WordPress dependencies
 200   */
 201  
 202  
 203  /**
 204   * Internal dependencies
 205   */
 206  
 207  
 208  /**
 209   * Apply query arguments to both URL and Path, whichever is present.
 210   *
 211   * @param {import('../types').APIFetchOptions} props
 212   * @param {Record<string, string | number>}    queryArgs
 213   * @return {import('../types').APIFetchOptions} The request with the modified query args
 214   */
 215  const modifyQuery = ({
 216    path,
 217    url,
 218    ...options
 219  }, queryArgs) => ({
 220    ...options,
 221    url: url && (0,external_wp_url_namespaceObject.addQueryArgs)(url, queryArgs),
 222    path: path && (0,external_wp_url_namespaceObject.addQueryArgs)(path, queryArgs)
 223  });
 224  
 225  /**
 226   * Duplicates parsing functionality from apiFetch.
 227   *
 228   * @param {Response} response
 229   * @return {Promise<any>} Parsed response json.
 230   */
 231  const parseResponse = response => response.json ? response.json() : Promise.reject(response);
 232  
 233  /**
 234   * @param {string | null} linkHeader
 235   * @return {{ next?: string }} The parsed link header.
 236   */
 237  const parseLinkHeader = linkHeader => {
 238    if (!linkHeader) {
 239      return {};
 240    }
 241    const match = linkHeader.match(/<([^>]+)>; rel="next"/);
 242    return match ? {
 243      next: match[1]
 244    } : {};
 245  };
 246  
 247  /**
 248   * @param {Response} response
 249   * @return {string | undefined} The next page URL.
 250   */
 251  const getNextPageUrl = response => {
 252    const {
 253      next
 254    } = parseLinkHeader(response.headers.get('link'));
 255    return next;
 256  };
 257  
 258  /**
 259   * @param {import('../types').APIFetchOptions} options
 260   * @return {boolean} True if the request contains an unbounded query.
 261   */
 262  const requestContainsUnboundedQuery = options => {
 263    const pathIsUnbounded = !!options.path && options.path.indexOf('per_page=-1') !== -1;
 264    const urlIsUnbounded = !!options.url && options.url.indexOf('per_page=-1') !== -1;
 265    return pathIsUnbounded || urlIsUnbounded;
 266  };
 267  
 268  /**
 269   * The REST API enforces an upper limit on the per_page option. To handle large
 270   * collections, apiFetch consumers can pass `per_page=-1`; this middleware will
 271   * then recursively assemble a full response array from all available pages.
 272   *
 273   * @type {import('../types').APIFetchMiddleware}
 274   */
 275  const fetchAllMiddleware = async (options, next) => {
 276    if (options.parse === false) {
 277      // If a consumer has opted out of parsing, do not apply middleware.
 278      return next(options);
 279    }
 280    if (!requestContainsUnboundedQuery(options)) {
 281      // If neither url nor path is requesting all items, do not apply middleware.
 282      return next(options);
 283    }
 284  
 285    // Retrieve requested page of results.
 286    const response = await build_module({
 287      ...modifyQuery(options, {
 288        per_page: 100
 289      }),
 290      // Ensure headers are returned for page 1.
 291      parse: false
 292    });
 293    const results = await parseResponse(response);
 294    if (!Array.isArray(results)) {
 295      // We have no reliable way of merging non-array results.
 296      return results;
 297    }
 298    let nextPage = getNextPageUrl(response);
 299    if (!nextPage) {
 300      // There are no further pages to request.
 301      return results;
 302    }
 303  
 304    // Iteratively fetch all remaining pages until no "next" header is found.
 305    let mergedResults = /** @type {any[]} */[].concat(results);
 306    while (nextPage) {
 307      const nextResponse = await build_module({
 308        ...options,
 309        // Ensure the URL for the next page is used instead of any provided path.
 310        path: undefined,
 311        url: nextPage,
 312        // Ensure we still get headers so we can identify the next page.
 313        parse: false
 314      });
 315      const nextResults = await parseResponse(nextResponse);
 316      mergedResults = mergedResults.concat(nextResults);
 317      nextPage = getNextPageUrl(nextResponse);
 318    }
 319    return mergedResults;
 320  };
 321  /* harmony default export */ const fetch_all_middleware = (fetchAllMiddleware);
 322  
 323  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/http-v1.js
 324  /**
 325   * Set of HTTP methods which are eligible to be overridden.
 326   *
 327   * @type {Set<string>}
 328   */
 329  const OVERRIDE_METHODS = new Set(['PATCH', 'PUT', 'DELETE']);
 330  
 331  /**
 332   * Default request method.
 333   *
 334   * "A request has an associated method (a method). Unless stated otherwise it
 335   * is `GET`."
 336   *
 337   * @see  https://fetch.spec.whatwg.org/#requests
 338   *
 339   * @type {string}
 340   */
 341  const DEFAULT_METHOD = 'GET';
 342  
 343  /**
 344   * API Fetch middleware which overrides the request method for HTTP v1
 345   * compatibility leveraging the REST API X-HTTP-Method-Override header.
 346   *
 347   * @type {import('../types').APIFetchMiddleware}
 348   */
 349  const httpV1Middleware = (options, next) => {
 350    const {
 351      method = DEFAULT_METHOD
 352    } = options;
 353    if (OVERRIDE_METHODS.has(method.toUpperCase())) {
 354      options = {
 355        ...options,
 356        headers: {
 357          ...options.headers,
 358          'X-HTTP-Method-Override': method,
 359          'Content-Type': 'application/json'
 360        },
 361        method: 'POST'
 362      };
 363    }
 364    return next(options);
 365  };
 366  /* harmony default export */ const http_v1 = (httpV1Middleware);
 367  
 368  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/user-locale.js
 369  /**
 370   * WordPress dependencies
 371   */
 372  
 373  
 374  /**
 375   * @type {import('../types').APIFetchMiddleware}
 376   */
 377  const userLocaleMiddleware = (options, next) => {
 378    if (typeof options.url === 'string' && !(0,external_wp_url_namespaceObject.hasQueryArg)(options.url, '_locale')) {
 379      options.url = (0,external_wp_url_namespaceObject.addQueryArgs)(options.url, {
 380        _locale: 'user'
 381      });
 382    }
 383    if (typeof options.path === 'string' && !(0,external_wp_url_namespaceObject.hasQueryArg)(options.path, '_locale')) {
 384      options.path = (0,external_wp_url_namespaceObject.addQueryArgs)(options.path, {
 385        _locale: 'user'
 386      });
 387    }
 388    return next(options);
 389  };
 390  /* harmony default export */ const user_locale = (userLocaleMiddleware);
 391  
 392  ;// ./node_modules/@wordpress/api-fetch/build-module/utils/response.js
 393  /**
 394   * WordPress dependencies
 395   */
 396  
 397  
 398  /**
 399   * Parses the apiFetch response.
 400   *
 401   * @param {Response} response
 402   * @param {boolean}  shouldParseResponse
 403   *
 404   * @return {Promise<any> | null | Response} Parsed response.
 405   */
 406  const response_parseResponse = (response, shouldParseResponse = true) => {
 407    if (shouldParseResponse) {
 408      if (response.status === 204) {
 409        return null;
 410      }
 411      return response.json ? response.json() : Promise.reject(response);
 412    }
 413    return response;
 414  };
 415  
 416  /**
 417   * Calls the `json` function on the Response, throwing an error if the response
 418   * doesn't have a json function or if parsing the json itself fails.
 419   *
 420   * @param {Response} response
 421   * @return {Promise<any>} Parsed response.
 422   */
 423  const parseJsonAndNormalizeError = response => {
 424    const invalidJsonError = {
 425      code: 'invalid_json',
 426      message: (0,external_wp_i18n_namespaceObject.__)('The response is not a valid JSON response.')
 427    };
 428    if (!response || !response.json) {
 429      throw invalidJsonError;
 430    }
 431    return response.json().catch(() => {
 432      throw invalidJsonError;
 433    });
 434  };
 435  
 436  /**
 437   * Parses the apiFetch response properly and normalize response errors.
 438   *
 439   * @param {Response} response
 440   * @param {boolean}  shouldParseResponse
 441   *
 442   * @return {Promise<any>} Parsed response.
 443   */
 444  const parseResponseAndNormalizeError = (response, shouldParseResponse = true) => {
 445    return Promise.resolve(response_parseResponse(response, shouldParseResponse)).catch(res => parseAndThrowError(res, shouldParseResponse));
 446  };
 447  
 448  /**
 449   * Parses a response, throwing an error if parsing the response fails.
 450   *
 451   * @param {Response} response
 452   * @param {boolean}  shouldParseResponse
 453   * @return {Promise<any>} Parsed response.
 454   */
 455  function parseAndThrowError(response, shouldParseResponse = true) {
 456    if (!shouldParseResponse) {
 457      throw response;
 458    }
 459    return parseJsonAndNormalizeError(response).then(error => {
 460      const unknownError = {
 461        code: 'unknown_error',
 462        message: (0,external_wp_i18n_namespaceObject.__)('An unknown error occurred.')
 463      };
 464      throw error || unknownError;
 465    });
 466  }
 467  
 468  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/media-upload.js
 469  /**
 470   * WordPress dependencies
 471   */
 472  
 473  
 474  /**
 475   * Internal dependencies
 476   */
 477  
 478  
 479  /**
 480   * @param {import('../types').APIFetchOptions} options
 481   * @return {boolean} True if the request is for media upload.
 482   */
 483  function isMediaUploadRequest(options) {
 484    const isCreateMethod = !!options.method && options.method === 'POST';
 485    const isMediaEndpoint = !!options.path && options.path.indexOf('/wp/v2/media') !== -1 || !!options.url && options.url.indexOf('/wp/v2/media') !== -1;
 486    return isMediaEndpoint && isCreateMethod;
 487  }
 488  
 489  /**
 490   * Middleware handling media upload failures and retries.
 491   *
 492   * @type {import('../types').APIFetchMiddleware}
 493   */
 494  const mediaUploadMiddleware = (options, next) => {
 495    if (!isMediaUploadRequest(options)) {
 496      return next(options);
 497    }
 498    let retries = 0;
 499    const maxRetries = 5;
 500  
 501    /**
 502     * @param {string} attachmentId
 503     * @return {Promise<any>} Processed post response.
 504     */
 505    const postProcess = attachmentId => {
 506      retries++;
 507      return next({
 508        path: `/wp/v2/media/$attachmentId}/post-process`,
 509        method: 'POST',
 510        data: {
 511          action: 'create-image-subsizes'
 512        },
 513        parse: false
 514      }).catch(() => {
 515        if (retries < maxRetries) {
 516          return postProcess(attachmentId);
 517        }
 518        next({
 519          path: `/wp/v2/media/$attachmentId}?force=true`,
 520          method: 'DELETE'
 521        });
 522        return Promise.reject();
 523      });
 524    };
 525    return next({
 526      ...options,
 527      parse: false
 528    }).catch(response => {
 529      // `response` could actually be an error thrown by `defaultFetchHandler`.
 530      if (!response.headers) {
 531        return Promise.reject(response);
 532      }
 533      const attachmentId = response.headers.get('x-wp-upload-attachment-id');
 534      if (response.status >= 500 && response.status < 600 && attachmentId) {
 535        return postProcess(attachmentId).catch(() => {
 536          if (options.parse !== false) {
 537            return Promise.reject({
 538              code: 'post_process',
 539              message: (0,external_wp_i18n_namespaceObject.__)('Media upload failed. If this is a photo or a large image, please scale it down and try again.')
 540            });
 541          }
 542          return Promise.reject(response);
 543        });
 544      }
 545      return parseAndThrowError(response, options.parse);
 546    }).then(response => parseResponseAndNormalizeError(response, options.parse));
 547  };
 548  /* harmony default export */ const media_upload = (mediaUploadMiddleware);
 549  
 550  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/theme-preview.js
 551  /**
 552   * WordPress dependencies
 553   */
 554  
 555  
 556  /**
 557   * This appends a `wp_theme_preview` parameter to the REST API request URL if
 558   * the admin URL contains a `theme` GET parameter.
 559   *
 560   * If the REST API request URL has contained the `wp_theme_preview` parameter as `''`,
 561   * then bypass this middleware.
 562   *
 563   * @param {Record<string, any>} themePath
 564   * @return {import('../types').APIFetchMiddleware} Preloading middleware.
 565   */
 566  const createThemePreviewMiddleware = themePath => (options, next) => {
 567    if (typeof options.url === 'string') {
 568      const wpThemePreview = (0,external_wp_url_namespaceObject.getQueryArg)(options.url, 'wp_theme_preview');
 569      if (wpThemePreview === undefined) {
 570        options.url = (0,external_wp_url_namespaceObject.addQueryArgs)(options.url, {
 571          wp_theme_preview: themePath
 572        });
 573      } else if (wpThemePreview === '') {
 574        options.url = (0,external_wp_url_namespaceObject.removeQueryArgs)(options.url, 'wp_theme_preview');
 575      }
 576    }
 577    if (typeof options.path === 'string') {
 578      const wpThemePreview = (0,external_wp_url_namespaceObject.getQueryArg)(options.path, 'wp_theme_preview');
 579      if (wpThemePreview === undefined) {
 580        options.path = (0,external_wp_url_namespaceObject.addQueryArgs)(options.path, {
 581          wp_theme_preview: themePath
 582        });
 583      } else if (wpThemePreview === '') {
 584        options.path = (0,external_wp_url_namespaceObject.removeQueryArgs)(options.path, 'wp_theme_preview');
 585      }
 586    }
 587    return next(options);
 588  };
 589  /* harmony default export */ const theme_preview = (createThemePreviewMiddleware);
 590  
 591  ;// ./node_modules/@wordpress/api-fetch/build-module/index.js
 592  /**
 593   * WordPress dependencies
 594   */
 595  
 596  
 597  /**
 598   * Internal dependencies
 599   */
 600  
 601  
 602  
 603  
 604  
 605  
 606  
 607  
 608  
 609  
 610  
 611  /**
 612   * Default set of header values which should be sent with every request unless
 613   * explicitly provided through apiFetch options.
 614   *
 615   * @type {Record<string, string>}
 616   */
 617  const DEFAULT_HEADERS = {
 618    // The backend uses the Accept header as a condition for considering an
 619    // incoming request as a REST request.
 620    //
 621    // See: https://core.trac.wordpress.org/ticket/44534
 622    Accept: 'application/json, */*;q=0.1'
 623  };
 624  
 625  /**
 626   * Default set of fetch option values which should be sent with every request
 627   * unless explicitly provided through apiFetch options.
 628   *
 629   * @type {Object}
 630   */
 631  const DEFAULT_OPTIONS = {
 632    credentials: 'include'
 633  };
 634  
 635  /** @typedef {import('./types').APIFetchMiddleware} APIFetchMiddleware */
 636  /** @typedef {import('./types').APIFetchOptions} APIFetchOptions */
 637  
 638  /**
 639   * @type {import('./types').APIFetchMiddleware[]}
 640   */
 641  const middlewares = [user_locale, namespace_endpoint, http_v1, fetch_all_middleware];
 642  
 643  /**
 644   * Register a middleware
 645   *
 646   * @param {import('./types').APIFetchMiddleware} middleware
 647   */
 648  function registerMiddleware(middleware) {
 649    middlewares.unshift(middleware);
 650  }
 651  
 652  /**
 653   * Checks the status of a response, throwing the Response as an error if
 654   * it is outside the 200 range.
 655   *
 656   * @param {Response} response
 657   * @return {Response} The response if the status is in the 200 range.
 658   */
 659  const checkStatus = response => {
 660    if (response.status >= 200 && response.status < 300) {
 661      return response;
 662    }
 663    throw response;
 664  };
 665  
 666  /** @typedef {(options: import('./types').APIFetchOptions) => Promise<any>} FetchHandler*/
 667  
 668  /**
 669   * @type {FetchHandler}
 670   */
 671  const defaultFetchHandler = nextOptions => {
 672    const {
 673      url,
 674      path,
 675      data,
 676      parse = true,
 677      ...remainingOptions
 678    } = nextOptions;
 679    let {
 680      body,
 681      headers
 682    } = nextOptions;
 683  
 684    // Merge explicitly-provided headers with default values.
 685    headers = {
 686      ...DEFAULT_HEADERS,
 687      ...headers
 688    };
 689  
 690    // The `data` property is a shorthand for sending a JSON body.
 691    if (data) {
 692      body = JSON.stringify(data);
 693      headers['Content-Type'] = 'application/json';
 694    }
 695    const responsePromise = window.fetch(
 696    // Fall back to explicitly passing `window.location` which is the behavior if `undefined` is passed.
 697    url || path || window.location.href, {
 698      ...DEFAULT_OPTIONS,
 699      ...remainingOptions,
 700      body,
 701      headers
 702    });
 703    return responsePromise.then(value => Promise.resolve(value).then(checkStatus).catch(response => parseAndThrowError(response, parse)).then(response => parseResponseAndNormalizeError(response, parse)), err => {
 704      // Re-throw AbortError for the users to handle it themselves.
 705      if (err && err.name === 'AbortError') {
 706        throw err;
 707      }
 708  
 709      // Otherwise, there is most likely no network connection.
 710      // Unfortunately the message might depend on the browser.
 711      throw {
 712        code: 'fetch_error',
 713        message: (0,external_wp_i18n_namespaceObject.__)('You are probably offline.')
 714      };
 715    });
 716  };
 717  
 718  /** @type {FetchHandler} */
 719  let fetchHandler = defaultFetchHandler;
 720  
 721  /**
 722   * Defines a custom fetch handler for making the requests that will override
 723   * the default one using window.fetch
 724   *
 725   * @param {FetchHandler} newFetchHandler The new fetch handler
 726   */
 727  function setFetchHandler(newFetchHandler) {
 728    fetchHandler = newFetchHandler;
 729  }
 730  
 731  /**
 732   * @template T
 733   * @param {import('./types').APIFetchOptions} options
 734   * @return {Promise<T>} A promise representing the request processed via the registered middlewares.
 735   */
 736  function apiFetch(options) {
 737    // creates a nested function chain that calls all middlewares and finally the `fetchHandler`,
 738    // converting `middlewares = [ m1, m2, m3 ]` into:
 739    // ```
 740    // opts1 => m1( opts1, opts2 => m2( opts2, opts3 => m3( opts3, fetchHandler ) ) );
 741    // ```
 742    const enhancedHandler = middlewares.reduceRight(( /** @type {FetchHandler} */next, middleware) => {
 743      return workingOptions => middleware(workingOptions, next);
 744    }, fetchHandler);
 745    return enhancedHandler(options).catch(error => {
 746      if (error.code !== 'rest_cookie_invalid_nonce') {
 747        return Promise.reject(error);
 748      }
 749  
 750      // If the nonce is invalid, refresh it and try again.
 751      return window
 752      // @ts-ignore
 753      .fetch(apiFetch.nonceEndpoint).then(checkStatus).then(data => data.text()).then(text => {
 754        // @ts-ignore
 755        apiFetch.nonceMiddleware.nonce = text;
 756        return apiFetch(options);
 757      });
 758    });
 759  }
 760  apiFetch.use = registerMiddleware;
 761  apiFetch.setFetchHandler = setFetchHandler;
 762  apiFetch.createNonceMiddleware = nonce;
 763  apiFetch.createPreloadingMiddleware = preloading;
 764  apiFetch.createRootURLMiddleware = root_url;
 765  apiFetch.fetchAllMiddleware = fetch_all_middleware;
 766  apiFetch.mediaUploadMiddleware = media_upload;
 767  apiFetch.createThemePreviewMiddleware = theme_preview;
 768  /* harmony default export */ const build_module = (apiFetch);
 769  
 770  (window.wp = window.wp || {}).apiFetch = __webpack_exports__["default"];
 771  /******/ })()
 772  ;