[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    if (parse) {
 190      return Promise.resolve(responseData.body);
 191    }
 192    try {
 193      return Promise.resolve(new window.Response(JSON.stringify(responseData.body), {
 194        status: 200,
 195        statusText: 'OK',
 196        headers: responseData.headers
 197      }));
 198    } catch {
 199      // See: https://github.com/WordPress/gutenberg/issues/67358#issuecomment-2621163926.
 200      Object.entries(responseData.headers).forEach(([key, value]) => {
 201        if (key.toLowerCase() === 'link') {
 202          responseData.headers[key] = value.replace(/<([^>]+)>/, (/** @type {any} */_, /** @type {string} */url) => `<$encodeURI(url)}>`);
 203        }
 204      });
 205      return Promise.resolve(parse ? responseData.body : new window.Response(JSON.stringify(responseData.body), {
 206        status: 200,
 207        statusText: 'OK',
 208        headers: responseData.headers
 209      }));
 210    }
 211  }
 212  /* harmony default export */ const preloading = (createPreloadingMiddleware);
 213  
 214  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/fetch-all-middleware.js
 215  /**
 216   * WordPress dependencies
 217   */
 218  
 219  
 220  /**
 221   * Internal dependencies
 222   */
 223  
 224  
 225  /**
 226   * Apply query arguments to both URL and Path, whichever is present.
 227   *
 228   * @param {import('../types').APIFetchOptions} props
 229   * @param {Record<string, string | number>}    queryArgs
 230   * @return {import('../types').APIFetchOptions} The request with the modified query args
 231   */
 232  const modifyQuery = ({
 233    path,
 234    url,
 235    ...options
 236  }, queryArgs) => ({
 237    ...options,
 238    url: url && (0,external_wp_url_namespaceObject.addQueryArgs)(url, queryArgs),
 239    path: path && (0,external_wp_url_namespaceObject.addQueryArgs)(path, queryArgs)
 240  });
 241  
 242  /**
 243   * Duplicates parsing functionality from apiFetch.
 244   *
 245   * @param {Response} response
 246   * @return {Promise<any>} Parsed response json.
 247   */
 248  const parseResponse = response => response.json ? response.json() : Promise.reject(response);
 249  
 250  /**
 251   * @param {string | null} linkHeader
 252   * @return {{ next?: string }} The parsed link header.
 253   */
 254  const parseLinkHeader = linkHeader => {
 255    if (!linkHeader) {
 256      return {};
 257    }
 258    const match = linkHeader.match(/<([^>]+)>; rel="next"/);
 259    return match ? {
 260      next: match[1]
 261    } : {};
 262  };
 263  
 264  /**
 265   * @param {Response} response
 266   * @return {string | undefined} The next page URL.
 267   */
 268  const getNextPageUrl = response => {
 269    const {
 270      next
 271    } = parseLinkHeader(response.headers.get('link'));
 272    return next;
 273  };
 274  
 275  /**
 276   * @param {import('../types').APIFetchOptions} options
 277   * @return {boolean} True if the request contains an unbounded query.
 278   */
 279  const requestContainsUnboundedQuery = options => {
 280    const pathIsUnbounded = !!options.path && options.path.indexOf('per_page=-1') !== -1;
 281    const urlIsUnbounded = !!options.url && options.url.indexOf('per_page=-1') !== -1;
 282    return pathIsUnbounded || urlIsUnbounded;
 283  };
 284  
 285  /**
 286   * The REST API enforces an upper limit on the per_page option. To handle large
 287   * collections, apiFetch consumers can pass `per_page=-1`; this middleware will
 288   * then recursively assemble a full response array from all available pages.
 289   *
 290   * @type {import('../types').APIFetchMiddleware}
 291   */
 292  const fetchAllMiddleware = async (options, next) => {
 293    if (options.parse === false) {
 294      // If a consumer has opted out of parsing, do not apply middleware.
 295      return next(options);
 296    }
 297    if (!requestContainsUnboundedQuery(options)) {
 298      // If neither url nor path is requesting all items, do not apply middleware.
 299      return next(options);
 300    }
 301  
 302    // Retrieve requested page of results.
 303    const response = await build_module({
 304      ...modifyQuery(options, {
 305        per_page: 100
 306      }),
 307      // Ensure headers are returned for page 1.
 308      parse: false
 309    });
 310    const results = await parseResponse(response);
 311    if (!Array.isArray(results)) {
 312      // We have no reliable way of merging non-array results.
 313      return results;
 314    }
 315    let nextPage = getNextPageUrl(response);
 316    if (!nextPage) {
 317      // There are no further pages to request.
 318      return results;
 319    }
 320  
 321    // Iteratively fetch all remaining pages until no "next" header is found.
 322    let mergedResults = /** @type {any[]} */[].concat(results);
 323    while (nextPage) {
 324      const nextResponse = await build_module({
 325        ...options,
 326        // Ensure the URL for the next page is used instead of any provided path.
 327        path: undefined,
 328        url: nextPage,
 329        // Ensure we still get headers so we can identify the next page.
 330        parse: false
 331      });
 332      const nextResults = await parseResponse(nextResponse);
 333      mergedResults = mergedResults.concat(nextResults);
 334      nextPage = getNextPageUrl(nextResponse);
 335    }
 336    return mergedResults;
 337  };
 338  /* harmony default export */ const fetch_all_middleware = (fetchAllMiddleware);
 339  
 340  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/http-v1.js
 341  /**
 342   * Set of HTTP methods which are eligible to be overridden.
 343   *
 344   * @type {Set<string>}
 345   */
 346  const OVERRIDE_METHODS = new Set(['PATCH', 'PUT', 'DELETE']);
 347  
 348  /**
 349   * Default request method.
 350   *
 351   * "A request has an associated method (a method). Unless stated otherwise it
 352   * is `GET`."
 353   *
 354   * @see  https://fetch.spec.whatwg.org/#requests
 355   *
 356   * @type {string}
 357   */
 358  const DEFAULT_METHOD = 'GET';
 359  
 360  /**
 361   * API Fetch middleware which overrides the request method for HTTP v1
 362   * compatibility leveraging the REST API X-HTTP-Method-Override header.
 363   *
 364   * @type {import('../types').APIFetchMiddleware}
 365   */
 366  const httpV1Middleware = (options, next) => {
 367    const {
 368      method = DEFAULT_METHOD
 369    } = options;
 370    if (OVERRIDE_METHODS.has(method.toUpperCase())) {
 371      options = {
 372        ...options,
 373        headers: {
 374          ...options.headers,
 375          'X-HTTP-Method-Override': method,
 376          'Content-Type': 'application/json'
 377        },
 378        method: 'POST'
 379      };
 380    }
 381    return next(options);
 382  };
 383  /* harmony default export */ const http_v1 = (httpV1Middleware);
 384  
 385  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/user-locale.js
 386  /**
 387   * WordPress dependencies
 388   */
 389  
 390  
 391  /**
 392   * @type {import('../types').APIFetchMiddleware}
 393   */
 394  const userLocaleMiddleware = (options, next) => {
 395    if (typeof options.url === 'string' && !(0,external_wp_url_namespaceObject.hasQueryArg)(options.url, '_locale')) {
 396      options.url = (0,external_wp_url_namespaceObject.addQueryArgs)(options.url, {
 397        _locale: 'user'
 398      });
 399    }
 400    if (typeof options.path === 'string' && !(0,external_wp_url_namespaceObject.hasQueryArg)(options.path, '_locale')) {
 401      options.path = (0,external_wp_url_namespaceObject.addQueryArgs)(options.path, {
 402        _locale: 'user'
 403      });
 404    }
 405    return next(options);
 406  };
 407  /* harmony default export */ const user_locale = (userLocaleMiddleware);
 408  
 409  ;// ./node_modules/@wordpress/api-fetch/build-module/utils/response.js
 410  /**
 411   * WordPress dependencies
 412   */
 413  
 414  
 415  /**
 416   * Parses the apiFetch response.
 417   *
 418   * @param {Response} response
 419   * @param {boolean}  shouldParseResponse
 420   *
 421   * @return {Promise<any> | null | Response} Parsed response.
 422   */
 423  const response_parseResponse = (response, shouldParseResponse = true) => {
 424    if (shouldParseResponse) {
 425      if (response.status === 204) {
 426        return null;
 427      }
 428      return response.json ? response.json() : Promise.reject(response);
 429    }
 430    return response;
 431  };
 432  
 433  /**
 434   * Calls the `json` function on the Response, throwing an error if the response
 435   * doesn't have a json function or if parsing the json itself fails.
 436   *
 437   * @param {Response} response
 438   * @return {Promise<any>} Parsed response.
 439   */
 440  const parseJsonAndNormalizeError = response => {
 441    const invalidJsonError = {
 442      code: 'invalid_json',
 443      message: (0,external_wp_i18n_namespaceObject.__)('The response is not a valid JSON response.')
 444    };
 445    if (!response || !response.json) {
 446      throw invalidJsonError;
 447    }
 448    return response.json().catch(() => {
 449      throw invalidJsonError;
 450    });
 451  };
 452  
 453  /**
 454   * Parses the apiFetch response properly and normalize response errors.
 455   *
 456   * @param {Response} response
 457   * @param {boolean}  shouldParseResponse
 458   *
 459   * @return {Promise<any>} Parsed response.
 460   */
 461  const parseResponseAndNormalizeError = (response, shouldParseResponse = true) => {
 462    return Promise.resolve(response_parseResponse(response, shouldParseResponse)).catch(res => parseAndThrowError(res, shouldParseResponse));
 463  };
 464  
 465  /**
 466   * Parses a response, throwing an error if parsing the response fails.
 467   *
 468   * @param {Response} response
 469   * @param {boolean}  shouldParseResponse
 470   * @return {Promise<any>} Parsed response.
 471   */
 472  function parseAndThrowError(response, shouldParseResponse = true) {
 473    if (!shouldParseResponse) {
 474      throw response;
 475    }
 476    return parseJsonAndNormalizeError(response).then(error => {
 477      const unknownError = {
 478        code: 'unknown_error',
 479        message: (0,external_wp_i18n_namespaceObject.__)('An unknown error occurred.')
 480      };
 481      throw error || unknownError;
 482    });
 483  }
 484  
 485  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/media-upload.js
 486  /**
 487   * WordPress dependencies
 488   */
 489  
 490  
 491  /**
 492   * Internal dependencies
 493   */
 494  
 495  
 496  /**
 497   * @param {import('../types').APIFetchOptions} options
 498   * @return {boolean} True if the request is for media upload.
 499   */
 500  function isMediaUploadRequest(options) {
 501    const isCreateMethod = !!options.method && options.method === 'POST';
 502    const isMediaEndpoint = !!options.path && options.path.indexOf('/wp/v2/media') !== -1 || !!options.url && options.url.indexOf('/wp/v2/media') !== -1;
 503    return isMediaEndpoint && isCreateMethod;
 504  }
 505  
 506  /**
 507   * Middleware handling media upload failures and retries.
 508   *
 509   * @type {import('../types').APIFetchMiddleware}
 510   */
 511  const mediaUploadMiddleware = (options, next) => {
 512    if (!isMediaUploadRequest(options)) {
 513      return next(options);
 514    }
 515    let retries = 0;
 516    const maxRetries = 5;
 517  
 518    /**
 519     * @param {string} attachmentId
 520     * @return {Promise<any>} Processed post response.
 521     */
 522    const postProcess = attachmentId => {
 523      retries++;
 524      return next({
 525        path: `/wp/v2/media/$attachmentId}/post-process`,
 526        method: 'POST',
 527        data: {
 528          action: 'create-image-subsizes'
 529        },
 530        parse: false
 531      }).catch(() => {
 532        if (retries < maxRetries) {
 533          return postProcess(attachmentId);
 534        }
 535        next({
 536          path: `/wp/v2/media/$attachmentId}?force=true`,
 537          method: 'DELETE'
 538        });
 539        return Promise.reject();
 540      });
 541    };
 542    return next({
 543      ...options,
 544      parse: false
 545    }).catch(response => {
 546      // `response` could actually be an error thrown by `defaultFetchHandler`.
 547      if (!response.headers) {
 548        return Promise.reject(response);
 549      }
 550      const attachmentId = response.headers.get('x-wp-upload-attachment-id');
 551      if (response.status >= 500 && response.status < 600 && attachmentId) {
 552        return postProcess(attachmentId).catch(() => {
 553          if (options.parse !== false) {
 554            return Promise.reject({
 555              code: 'post_process',
 556              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.')
 557            });
 558          }
 559          return Promise.reject(response);
 560        });
 561      }
 562      return parseAndThrowError(response, options.parse);
 563    }).then(response => parseResponseAndNormalizeError(response, options.parse));
 564  };
 565  /* harmony default export */ const media_upload = (mediaUploadMiddleware);
 566  
 567  ;// ./node_modules/@wordpress/api-fetch/build-module/middlewares/theme-preview.js
 568  /**
 569   * WordPress dependencies
 570   */
 571  
 572  
 573  /**
 574   * This appends a `wp_theme_preview` parameter to the REST API request URL if
 575   * the admin URL contains a `theme` GET parameter.
 576   *
 577   * If the REST API request URL has contained the `wp_theme_preview` parameter as `''`,
 578   * then bypass this middleware.
 579   *
 580   * @param {Record<string, any>} themePath
 581   * @return {import('../types').APIFetchMiddleware} Preloading middleware.
 582   */
 583  const createThemePreviewMiddleware = themePath => (options, next) => {
 584    if (typeof options.url === 'string') {
 585      const wpThemePreview = (0,external_wp_url_namespaceObject.getQueryArg)(options.url, 'wp_theme_preview');
 586      if (wpThemePreview === undefined) {
 587        options.url = (0,external_wp_url_namespaceObject.addQueryArgs)(options.url, {
 588          wp_theme_preview: themePath
 589        });
 590      } else if (wpThemePreview === '') {
 591        options.url = (0,external_wp_url_namespaceObject.removeQueryArgs)(options.url, 'wp_theme_preview');
 592      }
 593    }
 594    if (typeof options.path === 'string') {
 595      const wpThemePreview = (0,external_wp_url_namespaceObject.getQueryArg)(options.path, 'wp_theme_preview');
 596      if (wpThemePreview === undefined) {
 597        options.path = (0,external_wp_url_namespaceObject.addQueryArgs)(options.path, {
 598          wp_theme_preview: themePath
 599        });
 600      } else if (wpThemePreview === '') {
 601        options.path = (0,external_wp_url_namespaceObject.removeQueryArgs)(options.path, 'wp_theme_preview');
 602      }
 603    }
 604    return next(options);
 605  };
 606  /* harmony default export */ const theme_preview = (createThemePreviewMiddleware);
 607  
 608  ;// ./node_modules/@wordpress/api-fetch/build-module/index.js
 609  /**
 610   * WordPress dependencies
 611   */
 612  
 613  
 614  /**
 615   * Internal dependencies
 616   */
 617  
 618  
 619  
 620  
 621  
 622  
 623  
 624  
 625  
 626  
 627  
 628  /**
 629   * Default set of header values which should be sent with every request unless
 630   * explicitly provided through apiFetch options.
 631   *
 632   * @type {Record<string, string>}
 633   */
 634  const DEFAULT_HEADERS = {
 635    // The backend uses the Accept header as a condition for considering an
 636    // incoming request as a REST request.
 637    //
 638    // See: https://core.trac.wordpress.org/ticket/44534
 639    Accept: 'application/json, */*;q=0.1'
 640  };
 641  
 642  /**
 643   * Default set of fetch option values which should be sent with every request
 644   * unless explicitly provided through apiFetch options.
 645   *
 646   * @type {Object}
 647   */
 648  const DEFAULT_OPTIONS = {
 649    credentials: 'include'
 650  };
 651  
 652  /** @typedef {import('./types').APIFetchMiddleware} APIFetchMiddleware */
 653  /** @typedef {import('./types').APIFetchOptions} APIFetchOptions */
 654  
 655  /**
 656   * @type {import('./types').APIFetchMiddleware[]}
 657   */
 658  const middlewares = [user_locale, namespace_endpoint, http_v1, fetch_all_middleware];
 659  
 660  /**
 661   * Register a middleware
 662   *
 663   * @param {import('./types').APIFetchMiddleware} middleware
 664   */
 665  function registerMiddleware(middleware) {
 666    middlewares.unshift(middleware);
 667  }
 668  
 669  /**
 670   * Checks the status of a response, throwing the Response as an error if
 671   * it is outside the 200 range.
 672   *
 673   * @param {Response} response
 674   * @return {Response} The response if the status is in the 200 range.
 675   */
 676  const checkStatus = response => {
 677    if (response.status >= 200 && response.status < 300) {
 678      return response;
 679    }
 680    throw response;
 681  };
 682  
 683  /** @typedef {(options: import('./types').APIFetchOptions) => Promise<any>} FetchHandler*/
 684  
 685  /**
 686   * @type {FetchHandler}
 687   */
 688  const defaultFetchHandler = nextOptions => {
 689    const {
 690      url,
 691      path,
 692      data,
 693      parse = true,
 694      ...remainingOptions
 695    } = nextOptions;
 696    let {
 697      body,
 698      headers
 699    } = nextOptions;
 700  
 701    // Merge explicitly-provided headers with default values.
 702    headers = {
 703      ...DEFAULT_HEADERS,
 704      ...headers
 705    };
 706  
 707    // The `data` property is a shorthand for sending a JSON body.
 708    if (data) {
 709      body = JSON.stringify(data);
 710      headers['Content-Type'] = 'application/json';
 711    }
 712    const responsePromise = window.fetch(
 713    // Fall back to explicitly passing `window.location` which is the behavior if `undefined` is passed.
 714    url || path || window.location.href, {
 715      ...DEFAULT_OPTIONS,
 716      ...remainingOptions,
 717      body,
 718      headers
 719    });
 720    return responsePromise.then(value => Promise.resolve(value).then(checkStatus).catch(response => parseAndThrowError(response, parse)).then(response => parseResponseAndNormalizeError(response, parse)), err => {
 721      // Re-throw AbortError for the users to handle it themselves.
 722      if (err && err.name === 'AbortError') {
 723        throw err;
 724      }
 725  
 726      // Otherwise, there is most likely no network connection.
 727      // Unfortunately the message might depend on the browser.
 728      throw {
 729        code: 'fetch_error',
 730        message: (0,external_wp_i18n_namespaceObject.__)('You are probably offline.')
 731      };
 732    });
 733  };
 734  
 735  /** @type {FetchHandler} */
 736  let fetchHandler = defaultFetchHandler;
 737  
 738  /**
 739   * Defines a custom fetch handler for making the requests that will override
 740   * the default one using window.fetch
 741   *
 742   * @param {FetchHandler} newFetchHandler The new fetch handler
 743   */
 744  function setFetchHandler(newFetchHandler) {
 745    fetchHandler = newFetchHandler;
 746  }
 747  
 748  /**
 749   * @template T
 750   * @param {import('./types').APIFetchOptions} options
 751   * @return {Promise<T>} A promise representing the request processed via the registered middlewares.
 752   */
 753  function apiFetch(options) {
 754    // creates a nested function chain that calls all middlewares and finally the `fetchHandler`,
 755    // converting `middlewares = [ m1, m2, m3 ]` into:
 756    // ```
 757    // opts1 => m1( opts1, opts2 => m2( opts2, opts3 => m3( opts3, fetchHandler ) ) );
 758    // ```
 759    const enhancedHandler = middlewares.reduceRight((/** @type {FetchHandler} */next, middleware) => {
 760      return workingOptions => middleware(workingOptions, next);
 761    }, fetchHandler);
 762    return enhancedHandler(options).catch(error => {
 763      if (error.code !== 'rest_cookie_invalid_nonce') {
 764        return Promise.reject(error);
 765      }
 766  
 767      // If the nonce is invalid, refresh it and try again.
 768      return window
 769      // @ts-ignore
 770      .fetch(apiFetch.nonceEndpoint).then(checkStatus).then(data => data.text()).then(text => {
 771        // @ts-ignore
 772        apiFetch.nonceMiddleware.nonce = text;
 773        return apiFetch(options);
 774      });
 775    });
 776  }
 777  apiFetch.use = registerMiddleware;
 778  apiFetch.setFetchHandler = setFetchHandler;
 779  apiFetch.createNonceMiddleware = nonce;
 780  apiFetch.createPreloadingMiddleware = preloading;
 781  apiFetch.createRootURLMiddleware = root_url;
 782  apiFetch.fetchAllMiddleware = fetch_all_middleware;
 783  apiFetch.mediaUploadMiddleware = media_upload;
 784  apiFetch.createThemePreviewMiddleware = theme_preview;
 785  /* harmony default export */ const build_module = (apiFetch);
 786  
 787  (window.wp = window.wp || {}).apiFetch = __webpack_exports__["default"];
 788  /******/ })()
 789  ;