1(function() { 2"use strict"; 3var wp; 4(wp ||= {}).apiFetch = (() => { 5 var __create = Object.create; 6 var __defProp = Object.defineProperty; 7 var __getOwnPropDesc = Object.getOwnPropertyDescriptor; 8 var __getOwnPropNames = Object.getOwnPropertyNames; 9 var __getProtoOf = Object.getPrototypeOf; 10 var __hasOwnProp = Object.prototype.hasOwnProperty; 11 var __commonJS = (cb, mod) => function __require() { 12 return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; 13 }; 14 var __export = (target, all) => { 15 for (var name in all) 16 __defProp(target, name, { get: all[name], enumerable: true }); 17 }; 18 var __copyProps = (to, from, except, desc) => { 19 if (from && typeof from === "object" || typeof from === "function") { 20 for (let key of __getOwnPropNames(from)) 21 if (!__hasOwnProp.call(to, key) && key !== except) 22 __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); 23 } 24 return to; 25 }; 26 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( 27 // If the importer is in node compatibility mode or this is not an ESM 28 // file that has been converted to a CommonJS file using a Babel- 29 // compatible transform (i.e. "__esModule" has not been set), then set 30 // "default" to the CommonJS "module.exports" for node compatibility. 31 isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, 32 mod 33 )); 34 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); 35 36 // package-external:@wordpress/i18n 37 var require_i18n = __commonJS({ 38 "package-external:@wordpress/i18n"(exports, module) { 39 module.exports = window.wp.i18n; 40 } 41 }); 42 43 // package-external:@wordpress/private-apis 44 var require_private_apis = __commonJS({ 45 "package-external:@wordpress/private-apis"(exports, module) { 46 module.exports = window.wp.privateApis; 47 } 48 }); 49 50 // package-external:@wordpress/url 51 var require_url = __commonJS({ 52 "package-external:@wordpress/url"(exports, module) { 53 module.exports = window.wp.url; 54 } 55 }); 56 57
57// packages/api-fetch/build-module/index.mjs 58 var index_exports = {}; 59 __export(index_exports, { 60 default: () => index_default 61 }); 62 var import_i18n3 = __toESM(require_i18n(), 1); 63 64
64// packages/api-fetch/build-module/lock-unlock.mjs 65 var import_private_apis = __toESM(require_private_apis(), 1); 66 var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)( 67 "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", 68 "@wordpress/api-fetch" 69 ); 70 71
71// packages/api-fetch/build-module/middlewares/nonce.mjs 72 function createNonceMiddleware(nonce) { 73 const middleware = (options, next) => { 74 const { headers = {} } = options; 75 for (const headerName in headers) { 76 if (headerName.toLowerCase() === "x-wp-nonce" && headers[headerName] === middleware.nonce) { 77 return next(options); 78 } 79 } 80 return next({ 81 ...options, 82 headers: { 83 ...headers, 84 "X-WP-Nonce": middleware.nonce 85 } 86 }); 87 }; 88 middleware.nonce = nonce; 89 return middleware; 90 } 91 var nonce_default = createNonceMiddleware; 92 93
93// packages/api-fetch/build-module/middlewares/namespace-endpoint.mjs 94 var namespaceAndEndpointMiddleware = (options, next) => { 95 let path = options.path; 96 let namespaceTrimmed, endpointTrimmed; 97 if (typeof options.namespace === "string" && typeof options.endpoint === "string") { 98 namespaceTrimmed = options.namespace.replace(/^\/|\/$/g, ""); 99 endpointTrimmed = options.endpoint.replace(/^\//, ""); 100 if (endpointTrimmed) { 101 path = namespaceTrimmed + "/" + endpointTrimmed; 102 } else { 103 path = namespaceTrimmed; 104 } 105 } 106 delete options.namespace; 107 delete options.endpoint; 108 return next({ 109 ...options, 110 path 111 }); 112 }; 113 var namespace_endpoint_default = namespaceAndEndpointMiddleware; 114 115
115// packages/api-fetch/build-module/middlewares/root-url.mjs 116 var createRootURLMiddleware = (rootURL) => (options, next) => { 117 return namespace_endpoint_default(options, (optionsWithPath) => { 118 let url = optionsWithPath.url; 119 let path = optionsWithPath.path; 120 let apiRoot; 121 if (typeof path === "string") { 122 apiRoot = rootURL; 123 if (-1 !== rootURL.indexOf("?")) { 124 path = path.replace("?", "&"); 125 } 126 path = path.replace(/^\//, ""); 127 if ("string" === typeof apiRoot && -1 !== apiRoot.indexOf("?")) { 128 path = path.replace("?", "&"); 129 } 130 url = apiRoot + path; 131 } 132 return next({ 133 ...optionsWithPath, 134 url 135 }); 136 }); 137 }; 138 var root_url_default = createRootURLMiddleware; 139 140
140// packages/api-fetch/build-module/middlewares/preloading.mjs 141 var import_url = __toESM(require_url(), 1); 142 var ENABLE_MULTI_USE = /* @__PURE__ */ Symbol("preloadingEnableMultiUse"); 143 var CLEAR = /* @__PURE__ */ Symbol("preloadingClear"); 144 function createPreloadingMiddleware(preloadedData) { 145 const { OPTIONS = {}, ...GET } = Object.fromEntries( 146 Object.entries(preloadedData).map(([path, data]) => [ 147 (0, import_url.normalizePath)(path), 148 data 149 ]) 150 ); 151 const unusedGet = new Set(Object.keys(GET)); 152 const unusedOptions = new Set(Object.keys(OPTIONS)); 153 let multiUse = false; 154 const middleware = (options, next) => { 155 const { parse = true } = options; 156 let rawPath = options.path; 157 if (!rawPath && options.url) { 158 const { rest_route: pathFromQuery, ...queryArgs } = (0, import_url.getQueryArgs)( 159 options.url 160 ); 161 if (typeof pathFromQuery === "string") { 162 rawPath = (0, import_url.addQueryArgs)(pathFromQuery, queryArgs); 163 } 164 } 165 if (typeof rawPath !== "string") { 166 return next(options); 167 } 168 const method = options.method || "GET"; 169 const path = (0, import_url.normalizePath)(rawPath); 170 if ("GET" === method && GET[path]) { 171 const data = GET[path]; 172 if (!multiUse) { 173 delete GET[path]; 174 } 175 unusedGet.delete(path); 176 return prepareResponse(data, !!parse); 177 } else if ("OPTIONS" === method && OPTIONS[path]) { 178 const data = OPTIONS[path]; 179 if (!multiUse) { 180 delete OPTIONS[path]; 181 } 182 unusedOptions.delete(path); 183 return prepareResponse(data, !!parse); 184 } 185 return next(options); 186 }; 187 middleware[ENABLE_MULTI_USE] = () => { 188 multiUse = true; 189 }; 190 middleware[CLEAR] = () => { 191 const tags = [ 192 ...Array.from(unusedGet, (p) => `GET ${p}`), 193 ...Array.from(unusedOptions, (p) => `OPTIONS ${p}`) 194 ]; 195 if (tags.length) { 196 console.warn( 197 "[api-fetch][preload] Some preloads were never consumed:", 198 tags 199 ); 200 } else { 201 console.log("[api-fetch][preload] All preloads consumed."); 202 } 203 unusedGet.clear(); 204 unusedOptions.clear(); 205 for (const key of Object.keys(GET)) { 206 delete GET[key]; 207 } 208 for (const key of Object.keys(OPTIONS)) { 209 delete OPTIONS[key]; 210 } 211 }; 212 return middleware; 213 } 214 function prepareResponse(responseData, parse) { 215 if (parse) { 216 return Promise.resolve(responseData.body); 217 } 218 try { 219 return Promise.resolve( 220 new window.Response(JSON.stringify(responseData.body), { 221 status: 200, 222 statusText: "OK", 223 headers: responseData.headers 224 }) 225 ); 226 } catch { 227 Object.entries( 228 responseData.headers 229 ).forEach(([key, value]) => { 230 if (key.toLowerCase() === "link") { 231 responseData.headers[key] = value.replace( 232 /<([^>]+)>/, 233 (_, url) => `<${encodeURI(url)}>` 234 ); 235 } 236 }); 237 return Promise.resolve( 238 parse ? responseData.body : new window.Response(JSON.stringify(responseData.body), { 239 status: 200, 240 statusText: "OK", 241 headers: responseData.headers 242 }) 243 ); 244 } 245 } 246 var preloading_default = createPreloadingMiddleware; 247 248
248// packages/api-fetch/build-module/middlewares/fetch-all-middleware.mjs 249 var import_url2 = __toESM(require_url(), 1); 250 var modifyQuery = ({ path, url, ...options }, queryArgs) => ({ 251 ...options, 252 url: url && (0, import_url2.addQueryArgs)(url, queryArgs), 253 path: path && (0, import_url2.addQueryArgs)(path, queryArgs) 254 }); 255 var parseResponse = (response) => response.json ? response.json() : Promise.reject(response); 256 var parseLinkHeader = (linkHeader) => { 257 if (!linkHeader) { 258 return {}; 259 } 260 const match = linkHeader.match(/<([^>]+)>; rel="next"/); 261 return match ? { 262 next: match[1] 263 } : {}; 264 }; 265 var getNextPageUrl = (response) => { 266 const { next } = parseLinkHeader(response.headers.get("link")); 267 return next; 268 }; 269 var requestContainsUnboundedQuery = (options) => { 270 const pathIsUnbounded = !!options.path && options.path.indexOf("per_page=-1") !== -1; 271 const urlIsUnbounded = !!options.url && options.url.indexOf("per_page=-1") !== -1; 272 return pathIsUnbounded || urlIsUnbounded; 273 }; 274 var fetchAllMiddleware = async (options, next) => { 275 if (options.parse === false) { 276 return next(options); 277 } 278 if (!requestContainsUnboundedQuery(options)) { 279 return next(options); 280 } 281 const response = await index_default({ 282 ...modifyQuery(options, { 283 per_page: 100 284 }), 285 // Ensure headers are returned for page 1. 286 parse: false 287 }); 288 const results = await parseResponse(response); 289 if (!Array.isArray(results)) { 290 return results; 291 } 292 let nextPage = getNextPageUrl(response); 293 if (!nextPage) { 294 return results; 295 } 296 let mergedResults = [].concat(results); 297 while (nextPage) { 298 const nextResponse = await index_default({ 299 ...options, 300 // Ensure the URL for the next page is used instead of any provided path. 301 path: void 0, 302 url: nextPage, 303 // Ensure we still get headers so we can identify the next page. 304 parse: false 305 }); 306 const nextResults = await parseResponse(nextResponse); 307 mergedResults = mergedResults.concat(nextResults); 308 nextPage = getNextPageUrl(nextResponse); 309 } 310 return mergedResults; 311 }; 312 var fetch_all_middleware_default = fetchAllMiddleware; 313 314
314// packages/api-fetch/build-module/middlewares/http-v1.mjs 315 var OVERRIDE_METHODS = /* @__PURE__ */ new Set(["PATCH", "PUT", "DELETE"]); 316 var DEFAULT_METHOD = "GET"; 317 var httpV1Middleware = (options, next) => { 318 const { method = DEFAULT_METHOD } = options; 319 if (OVERRIDE_METHODS.has(method.toUpperCase())) { 320 options = { 321 ...options, 322 headers: { 323 "Content-Type": "application/json", 324 ...options.headers, 325 "X-HTTP-Method-Override": method 326 }, 327 method: "POST" 328 }; 329 } 330 return next(options); 331 }; 332 var http_v1_default = httpV1Middleware; 333 334
334// packages/api-fetch/build-module/middlewares/user-locale.mjs 335 var import_url3 = __toESM(require_url(), 1); 336 var userLocaleMiddleware = (options, next) => { 337 if (typeof options.url === "string" && !(0, import_url3.hasQueryArg)(options.url, "_locale")) { 338 options.url = (0, import_url3.addQueryArgs)(options.url, { _locale: "user" }); 339 } 340 if (typeof options.path === "string" && !(0, import_url3.hasQueryArg)(options.path, "_locale")) { 341 options.path = (0, import_url3.addQueryArgs)(options.path, { _locale: "user" }); 342 } 343 return next(options); 344 }; 345 var user_locale_default = userLocaleMiddleware; 346 347
347// packages/api-fetch/build-module/middlewares/media-upload.mjs 348 var import_i18n2 = __toESM(require_i18n(), 1); 349 350
350// packages/api-fetch/build-module/utils/response.mjs 351 var import_i18n = __toESM(require_i18n(), 1); 352 async function parseJsonAndNormalizeError(response) { 353 try { 354 return await response.json(); 355 } catch { 356 throw { 357 code: "invalid_json", 358 message: (0, import_i18n.__)("The response is not a valid JSON response.") 359 }; 360 } 361 } 362 async function parseResponseAndNormalizeError(response, shouldParseResponse = true) { 363 if (!shouldParseResponse) { 364 return response; 365 } 366 if (response.status === 204) { 367 return null; 368 } 369 return await parseJsonAndNormalizeError(response); 370 } 371 async function parseAndThrowError(response, shouldParseResponse = true) { 372 if (!shouldParseResponse) { 373 throw response; 374 } 375 throw await parseJsonAndNormalizeError(response); 376 } 377 378
378// packages/api-fetch/build-module/middlewares/media-upload.mjs 379 function isMediaUploadRequest(options) { 380 const isCreateMethod = !!options.method && options.method === "POST"; 381 const isMediaEndpoint = !!options.path && options.path.indexOf("/wp/v2/media") !== -1 || !!options.url && options.url.indexOf("/wp/v2/media") !== -1; 382 return isMediaEndpoint && isCreateMethod; 383 } 384 var mediaUploadMiddleware = (options, next) => { 385 if (!isMediaUploadRequest(options)) { 386 return next(options); 387 } 388 let retries = 0; 389 const maxRetries = 5; 390 const postProcess = (attachmentId) => { 391 retries++; 392 return next({ 393 path: `/wp/v2/media/${attachmentId}/post-process`, 394 method: "POST", 395 data: { action: "create-image-subsizes" }, 396 parse: false 397 }).catch(() => { 398 if (retries < maxRetries) { 399 return postProcess(attachmentId); 400 } 401 next({ 402 path: `/wp/v2/media/${attachmentId}?force=true`, 403 method: "DELETE" 404 }); 405 return Promise.reject(); 406 }); 407 }; 408 return next({ ...options, parse: false }).catch((response) => { 409 if (!(response instanceof globalThis.Response)) { 410 return Promise.reject(response); 411 } 412 const attachmentId = response.headers.get( 413 "x-wp-upload-attachment-id" 414 ); 415 if (response.status >= 500 && response.status < 600 && attachmentId) { 416 return postProcess(attachmentId).catch(() => { 417 if (options.parse !== false) { 418 return Promise.reject({ 419 code: "post_process", 420 message: (0, import_i18n2.__)( 421 "Media upload failed. If this is a photo or a large image, please scale it down and try again." 422 ) 423 }); 424 } 425 return Promise.reject(response); 426 }); 427 } 428 return parseAndThrowError(response, options.parse); 429 }).then( 430 (response) => parseResponseAndNormalizeError(response, options.parse) 431 ); 432 }; 433 var media_upload_default = mediaUploadMiddleware; 434 435
435// packages/api-fetch/build-module/middlewares/theme-preview.mjs 436 var import_url4 = __toESM(require_url(), 1); 437 var createThemePreviewMiddleware = (themePath) => (options, next) => { 438 if (typeof options.url === "string") { 439 const wpThemePreview = (0, import_url4.getQueryArg)( 440 options.url, 441 "wp_theme_preview" 442 ); 443 if (wpThemePreview === void 0) { 444 options.url = (0, import_url4.addQueryArgs)(options.url, { 445 wp_theme_preview: themePath 446 }); 447 } else if (wpThemePreview === "") { 448 options.url = (0, import_url4.removeQueryArgs)( 449 options.url, 450 "wp_theme_preview" 451 ); 452 } 453 } 454 if (typeof options.path === "string") { 455 const wpThemePreview = (0, import_url4.getQueryArg)( 456 options.path, 457 "wp_theme_preview" 458 ); 459 if (wpThemePreview === void 0) { 460 options.path = (0, import_url4.addQueryArgs)(options.path, { 461 wp_theme_preview: themePath 462 }); 463 } else if (wpThemePreview === "") { 464 options.path = (0, import_url4.removeQueryArgs)( 465 options.path, 466 "wp_theme_preview" 467 ); 468 } 469 } 470 return next(options); 471 }; 472 var theme_preview_default = createThemePreviewMiddleware; 473 474
474// packages/api-fetch/build-module/index.mjs 475 var DEFAULT_HEADERS = { 476 // The backend uses the Accept header as a condition for considering an 477 // incoming request as a REST request. 478 // 479 // See: https://core.trac.wordpress.org/ticket/44534 480 Accept: "application/json, */*;q=0.1" 481 }; 482 var DEFAULT_OPTIONS = { 483 credentials: "include" 484 }; 485 var middlewares = [ 486 user_locale_default, 487 namespace_endpoint_default, 488 http_v1_default, 489 fetch_all_middleware_default 490 ]; 491 function registerMiddleware(middleware) { 492 middlewares.unshift(middleware); 493 } 494 function enablePreloadMultiUse() { 495 for (const middleware of middlewares) { 496 middleware[ENABLE_MULTI_USE]?.(); 497 } 498 } 499 function clearPreloadedData() { 500 for (const middleware of middlewares) { 501 middleware[CLEAR]?.(); 502 } 503 } 504 var defaultFetchHandler = (nextOptions) => { 505 const { url, path, data, parse = true, ...remainingOptions } = nextOptions; 506 let { body, headers } = nextOptions; 507 headers = { ...DEFAULT_HEADERS, ...headers }; 508 if (data) { 509 body = JSON.stringify(data); 510 headers["Content-Type"] = "application/json"; 511 } 512 const responsePromise = globalThis.fetch( 513 // Fall back to explicitly passing `window.location` which is the behavior if `undefined` is passed. 514 url || path || window.location.href, 515 { 516 ...DEFAULT_OPTIONS, 517 ...remainingOptions, 518 body, 519 headers 520 } 521 ); 522 return responsePromise.then( 523 (response) => { 524 if (!response.ok) { 525 return parseAndThrowError(response, parse); 526 } 527 return parseResponseAndNormalizeError(response, parse); 528 }, 529 (err) => { 530 if (err && err.name === "AbortError") { 531 throw err; 532 } 533 if (!globalThis.navigator.onLine) { 534 throw { 535 code: "offline_error", 536 message: (0, import_i18n3.__)( 537 "Unable to connect. Please check your Internet connection." 538 ) 539 }; 540 } 541 throw { 542 code: "fetch_error", 543 message: (0, import_i18n3.__)( 544 "Could not get a valid response from the server." 545 ) 546 }; 547 } 548 ); 549 }; 550 var fetchHandler = defaultFetchHandler; 551 function setFetchHandler(newFetchHandler) { 552 fetchHandler = newFetchHandler; 553 } 554 var apiFetch = (options) => { 555 const enhancedHandler = middlewares.reduceRight( 556 (next, middleware) => { 557 return (workingOptions) => middleware(workingOptions, next); 558 }, 559 fetchHandler 560 ); 561 return enhancedHandler(options).catch((error) => { 562 if (error.code !== "rest_cookie_invalid_nonce") { 563 return Promise.reject(error); 564 } 565 return globalThis.fetch(apiFetch.nonceEndpoint).then((response) => { 566 if (!response.ok) { 567 return Promise.reject(error); 568 } 569 return response.text(); 570 }).then((text) => { 571 apiFetch.nonceMiddleware.nonce = text; 572 return apiFetch(options); 573 }); 574 }); 575 }; 576 apiFetch.use = registerMiddleware; 577 apiFetch.setFetchHandler = setFetchHandler; 578 apiFetch.privateApis = {}; 579 lock(apiFetch.privateApis, { 580 enablePreloadMultiUse, 581 clearPreloadedData 582 }); 583 apiFetch.createNonceMiddleware = nonce_default; 584 apiFetch.createPreloadingMiddleware = preloading_default; 585 apiFetch.createRootURLMiddleware = root_url_default; 586 apiFetch.fetchAllMiddleware = fetch_all_middleware_default; 587 apiFetch.mediaUploadMiddleware = media_upload_default; 588 apiFetch.createThemePreviewMiddleware = theme_preview_default; 589 var index_default = apiFetch; 590 return __toCommonJS(index_exports); 591})(); 592if (typeof wp.apiFetch === 'object' && wp.apiFetch.default) { wp.apiFetch = wp.apiFetch.default; } 593(window.wp ||= {}).apiFetch = wp.apiFetch; 594})();
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.