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/************************************************************************/ 25var __webpack_exports__ = {}; 26 27// EXPORTS 28__webpack_require__.d(__webpack_exports__, { 29 "default": () => (/* binding */ build_module) 30}); 31 32;// CONCATENATED MODULE: external ["wp","i18n"] 33const external_wp_i18n_namespaceObject = window["wp"]["i18n"]; 34;// CONCATENATED MODULE: ./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 */ 39function 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;// CONCATENATED MODULE: ./node_modules/@wordpress/api-fetch/build-module/middlewares/namespace-endpoint.js 69/** 70 * @type {import('../types').APIFetchMiddleware} 71 */ 72const 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;// CONCATENATED MODULE: ./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 */ 103const 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;
130// CONCATENATED MODULE: external ["wp","url"] 131const external_wp_url_namespaceObject = window["wp"]["url"]; 132;// CONCATENATED MODULE: ./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 */ 142function 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 */ 188function 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;// CONCATENATED MODULE: ./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 */ 215const 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 */ 231const 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 */ 237const 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 */ 251const 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 */ 262const 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 */ 275const 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;// CONCATENATED MODULE: ./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 */ 329const 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 */ 341const 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 */ 349const 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;// CONCATENATED MODULE: ./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 */ 377const 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;// CONCATENATED MODULE: ./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 */ 406const 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 */ 423const 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 */ 444const 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 */ 455function 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;// CONCATENATED MODULE: ./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 */ 483function 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 */ 494const 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;// CONCATENATED MODULE: ./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 */
566const 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;// CONCATENATED MODULE: ./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 */ 617const 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 */ 631const 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 */ 641const middlewares = [user_locale, namespace_endpoint, http_v1, fetch_all_middleware]; 642 643/** 644 * Register a middleware 645 * 646 * @param {import('./types').APIFetchMiddleware} middleware 647 */ 648function 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 */ 659const 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 */ 671const 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} */ 719let 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 */ 727function 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 */ 736function 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} 760apiFetch.use = registerMiddleware; 761apiFetch.setFetchHandler = setFetchHandler; 762apiFetch.createNonceMiddleware = nonce; 763apiFetch.createPreloadingMiddleware = preloading; 764apiFetch.createRootURLMiddleware = root_url; 765apiFetch.fetchAllMiddleware = fetch_all_middleware; 766apiFetch.mediaUploadMiddleware = media_upload; 767apiFetch.createThemePreviewMiddleware = theme_preview; 768/* harmony default export */ const build_module = (apiFetch); 769 770(window.wp = window.wp || {}).apiFetch = __webpack_exports__["default"]; 771/******/ })() 772;
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.