vendor: 4,232 bytes, lines 1-104
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/******/ /* webpack/runtime/make namespace object */ 25/******/ (() => { 26/******/ // define __esModule on exports 27/******/ __webpack_require__.r = (exports) => { 28/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 29/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 30/******/ } 31/******/ Object.defineProperty(exports, '__esModule', { value: true }); 32/******/ }; 33/******/ })(); 34/******/ 35/************************************************************************/ 36var __webpack_exports__ = {}; 37// ESM COMPAT FLAG 38__webpack_require__.r(__webpack_exports__); 39 40// EXPORTS 41__webpack_require__.d(__webpack_exports__, { 42 actions: () => (/* binding */ actions), 43 addAction: () => (/* binding */ addAction), 44 addFilter: () => (/* binding */ addFilter), 45 applyFilters: () => (/* binding */ applyFilters), 46 applyFiltersAsync: () => (/* binding */ applyFiltersAsync), 47 createHooks: () => (/* reexport */ build_module_createHooks), 48 currentAction: () => (/* binding */ currentAction), 49 currentFilter: () => (/* binding */ currentFilter), 50 defaultHooks: () => (/* binding */ defaultHooks), 51 didAction: () => (/* binding */ didAction), 52 didFilter: () => (/* binding */ didFilter), 53 doAction: () => (/* binding */ doAction), 54 doActionAsync: () => (/* binding */ doActionAsync), 55 doingAction: () => (/* binding */ doingAction), 56 doingFilter: () => (/* binding */ doingFilter), 57 filters: () => (/* binding */ filters), 58 hasAction: () => (/* binding */ hasAction), 59 hasFilter: () => (/* binding */ hasFilter), 60 removeAction: () => (/* binding */ removeAction), 61 removeAllActions: () => (/* binding */ removeAllActions), 62 removeAllFilters: () => (/* binding */ removeAllFilters), 63 removeFilter: () => (/* binding */ removeFilter) 64}); 65 66;// ./node_modules/@wordpress/hooks/build-module/validateNamespace.js 67/** 68 * Validate a namespace string. 69 * 70 * @param {string} namespace The namespace to validate - should take the form 71 * `vendor/plugin/function`. 72 * 73 * @return {boolean} Whether the namespace is valid. 74 */ 75function validateNamespace(namespace) { 76 if ('string' !== typeof namespace || '' === namespace) { 77 // eslint-disable-next-line no-console 78 console.error('The namespace must be a non-empty string.'); 79 return false; 80 } 81 if (!/^[a-zA-Z][a-zA-Z0-9_.\-\/]*$/.test(namespace)) { 82 // eslint-disable-next-line no-console 83 console.error('The namespace can only contain numbers, letters, dashes, periods, underscores and slashes.'); 84 return false; 85 } 86 return true; 87} 88/* harmony default export */ const build_module_validateNamespace = (validateNamespace); 89 90;// ./node_modules/@wordpress/hooks/build-module/validateHookName.js 91/** 92 * Validate a hookName string. 93 * 94 * @param {string} hookName The hook name to validate. Should be a non empty string containing 95 * only numbers, letters, dashes, periods and underscores. Also, 96 * the hook name cannot begin with `__`. 97 * 98 * @return {boolean} Whether the hook name is valid. 99 */ 100function validateHookName(hookName) { 101 if ('string' !== typeof hookName || '' === hookName) { 102 // eslint-disable-next-line no-console 103 console.error('The hook name must be a non-empty string.'); 104 return false;
105 } 106 if (/^__/.test(hookName)) { 107 // eslint-disable-next-line no-console 108 console.error('The hook name cannot begin with `__`.'); 109 return false; 110 } 111 if (!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(hookName)) { 112 // eslint-disable-next-line no-console 113 console.error('The hook name can only contain numbers, letters, dashes, periods and underscores.'); 114 return false; 115 } 116 return true; 117} 118/* harmony default export */ const build_module_validateHookName = (validateHookName); 119 120;// ./node_modules/@wordpress/hooks/build-module/createAddHook.js 121/** 122 * Internal dependencies 123 */ 124 125 126 127/** 128 * @callback AddHook 129 * 130 * Adds the hook to the appropriate hooks container. 131 * 132 * @param {string} hookName Name of hook to add 133 * @param {string} namespace The unique namespace identifying the callback in the form `vendor/plugin/function`. 134 * @param {import('.').Callback} callback Function to call when the hook is run 135 * @param {number} [priority=10] Priority of this hook 136 */ 137 138/** 139 * Returns a function which, when invoked, will add a hook. 140 * 141 * @param {import('.').Hooks} hooks Hooks instance. 142 * @param {import('.').StoreKey} storeKey 143 * 144 * @return {AddHook} Function that adds a new hook. 145 */ 146function createAddHook(hooks, storeKey) { 147 return function addHook(hookName, namespace, callback, priority = 10) { 148 const hooksStore = hooks[storeKey]; 149 if (!build_module_validateHookName(hookName)) { 150 return; 151 } 152 if (!build_module_validateNamespace(namespace)) { 153 return; 154 } 155 if ('function' !== typeof callback) { 156 // eslint-disable-next-line no-console 157 console.error('The hook callback must be a function.'); 158 return; 159 } 160 161 // Validate numeric priority 162 if ('number' !== typeof priority) { 163 // eslint-disable-next-line no-console 164 console.error('If specified, the hook priority must be a number.'); 165 return; 166 } 167 const handler = { 168 callback, 169 priority, 170 namespace 171 }; 172 if (hooksStore[hookName]) { 173 // Find the correct insert index of the new hook. 174 const handlers = hooksStore[hookName].handlers; 175 176 /** @type {number} */ 177 let i; 178 for (i = handlers.length; i > 0; i--) { 179 if (priority >= handlers[i - 1].priority) { 180 break; 181 } 182 } 183 if (i === handlers.length) { 184 // If append, operate via direct assignment. 185 handlers[i] = handler; 186 } else { 187 // Otherwise, insert before index via splice. 188 handlers.splice(i, 0, handler); 189 } 190 191 // We may also be currently executing this hook. If the callback 192 // we're adding would come after the current callback, there's no 193 // problem; otherwise we need to increase the execution index of 194 // any other runs by 1 to account for the added element. 195 hooksStore.__current.forEach(hookInfo => { 196 if (hookInfo.name === hookName && hookInfo.currentIndex >= i) { 197 hookInfo.currentIndex++; 198 } 199 }); 200 } else { 201 // This is the first hook of its type. 202 hooksStore[hookName] = { 203 handlers: [handler], 204 runs: 0 205 }; 206 } 207 if (hookName !== 'hookAdded') { 208 hooks.doAction('hookAdded', hookName, namespace, callback, priority); 209 } 210 }; 211} 212/* harmony default export */ const build_module_createAddHook = (createAddHook); 213 214;// ./node_modules/@wordpress/hooks/build-module/createRemoveHook.js 215/** 216 * Internal dependencies 217 */ 218 219 220 221/** 222 * @callback RemoveHook 223 * Removes the specified callback (or all callbacks) from the hook with a given hookName 224 * and namespace. 225 * 226 * @param {string} hookName The name of the hook to modify. 227 * @param {string} namespace The unique namespace identifying the callback in the 228 * form `vendor/plugin/function`. 229 * 230 * @return {number | undefined} The number of callbacks removed. 231 */ 232 233/** 234 * Returns a function which, when invoked, will remove a specified hook or all 235 * hooks by the given name. 236 * 237 * @param {import('.').Hooks} hooks Hooks instance. 238 * @param {import('.').StoreKey} storeKey 239 * @param {boolean} [removeAll=false] Whether to remove all callbacks for a hookName, 240 * without regard to namespace. Used to create 241 * `removeAll*` functions. 242 * 243 * @return {RemoveHook} Function that removes hooks. 244 */ 245function createRemoveHook(hooks, storeKey, removeAll = false) { 246 return function removeHook(hookName, namespace) { 247 const hooksStore = hooks[storeKey]; 248 if (!build_module_validateHookName(hookName)) { 249 return; 250 } 251 if (!removeAll && !build_module_validateNamespace(namespace)) { 252 return; 253 } 254 255 // Bail if no hooks exist by this name. 256 if (!hooksStore[hookName]) { 257 return 0; 258 } 259 let handlersRemoved = 0; 260 if (removeAll) { 261 handlersRemoved = hooksStore[hookName].handlers.length; 262 hooksStore[hookName] = { 263 runs: hooksStore[hookName].runs, 264 handlers: [] 265 }; 266 } else { 267 // Try to find the specified callback to remove. 268 const handlers = hooksStore[hookName].handlers; 269 for (let i = handlers.length - 1; i >= 0; i--) { 270 if (handlers[i].namespace === namespace) { 271 handlers.splice(i, 1); 272 handlersRemoved++; 273 // This callback may also be part of a hook that is 274 // currently executing. If the callback we're removing 275 // comes after the current callback, there's no problem; 276 // otherwise we need to decrease the execution index of any 277 // other runs by 1 to account for the removed element. 278 hooksStore.__current.forEach(hookInfo => { 279 if (hookInfo.name === hookName && hookInfo.currentIndex >= i) { 280 hookInfo.currentIndex--; 281 } 282 }); 283 } 284 } 285 } 286 if (hookName !== 'hookRemoved') { 287 hooks.doAction('hookRemoved', hookName, namespace); 288 } 289 return handlersRemoved; 290 }; 291} 292/* harmony default export */ const build_module_createRemoveHook = (createRemoveHook); 293 294;// ./node_modules/@wordpress/hooks/build-module/createHasHook.js 295/** 296 * @callback HasHook 297 * 298 * Returns whether any handlers are attached for the given hookName and optional namespace. 299 * 300 * @param {string} hookName The name of the hook to check for. 301 * @param {string} [namespace] Optional. The unique namespace identifying the callback 302 * in the form `vendor/plugin/function`. 303 * 304 * @return {boolean} Whether there are handlers that are attached to the given hook. 305 */ 306/** 307 * Returns a function which, when invoked, will return whether any handlers are 308 * attached to a particular hook. 309 * 310 * @param {import('.').Hooks} hooks Hooks instance. 311 * @param {import('.').StoreKey} storeKey 312 * 313 * @return {HasHook} Function that returns whether any handlers are 314 * attached to a particular hook and optional namespace. 315 */ 316function createHasHook(hooks, storeKey) { 317 return function hasHook(hookName, namespace) { 318 const hooksStore = hooks[storeKey]; 319 320 // Use the namespace if provided. 321 if ('undefined' !== typeof namespace) { 322 return hookName in hooksStore && hooksStore[hookName].handlers.some(hook => hook.namespace === namespace); 323 } 324 return hookName in hooksStore; 325 }; 326} 327/* harmony default export */ const build_module_createHasHook = (createHasHook); 328 329;// ./node_modules/@wordpress/hooks/build-module/createRunHook.js 330/** 331 * Returns a function which, when invoked, will execute all callbacks 332 * registered to a hook of the specified type, optionally returning the final 333 * value of the call chain. 334 * 335 * @param {import('.').Hooks} hooks Hooks instance. 336 * @param {import('.').StoreKey} storeKey 337 * @param {boolean} returnFirstArg Whether each hook callback is expected to return its first argument. 338 * @param {boolean} async Whether the hook callback should be run asynchronously 339 *
340 * @return {(hookName:string, ...args: unknown[]) => undefined|unknown} Function that runs hook callbacks. 341 */ 342function createRunHook(hooks, storeKey, returnFirstArg, async) { 343 return function runHook(hookName, ...args) { 344 const hooksStore = hooks[storeKey]; 345 if (!hooksStore[hookName]) { 346 hooksStore[hookName] = { 347 handlers: [], 348 runs: 0 349 }; 350 } 351 hooksStore[hookName].runs++; 352 const handlers = hooksStore[hookName].handlers; 353 354 // The following code is stripped from production builds. 355 if (false) {} 356 if (!handlers || !handlers.length) { 357 return returnFirstArg ? args[0] : undefined; 358 } 359 const hookInfo = { 360 name: hookName, 361 currentIndex: 0 362 }; 363 async function asyncRunner() { 364 try { 365 hooksStore.__current.add(hookInfo); 366 let result = returnFirstArg ? args[0] : undefined; 367 while (hookInfo.currentIndex < handlers.length) { 368 const handler = handlers[hookInfo.currentIndex]; 369 result = await handler.callback.apply(null, args); 370 if (returnFirstArg) { 371 args[0] = result; 372 } 373 hookInfo.currentIndex++; 374 } 375 return returnFirstArg ? result : undefined; 376 } finally { 377 hooksStore.__current.delete(hookInfo); 378 } 379 } 380 function syncRunner() { 381 try { 382 hooksStore.__current.add(hookInfo); 383 let result = returnFirstArg ? args[0] : undefined; 384 while (hookInfo.currentIndex < handlers.length) { 385 const handler = handlers[hookInfo.currentIndex]; 386 result = handler.callback.apply(null, args); 387 if (returnFirstArg) { 388 args[0] = result; 389 } 390 hookInfo.currentIndex++; 391 } 392 return returnFirstArg ? result : undefined; 393 } finally { 394 hooksStore.__current.delete(hookInfo); 395 } 396 } 397 return (async ? asyncRunner : syncRunner)(); 398 }; 399} 400/* harmony default export */ const build_module_createRunHook = (createRunHook); 401 402;// ./node_modules/@wordpress/hooks/build-module/createCurrentHook.js 403/** 404 * Returns a function which, when invoked, will return the name of the 405 * currently running hook, or `null` if no hook of the given type is currently 406 * running. 407 * 408 * @param {import('.').Hooks} hooks Hooks instance. 409 * @param {import('.').StoreKey} storeKey 410 * 411 * @return {() => string | null} Function that returns the current hook name or null. 412 */ 413function createCurrentHook(hooks, storeKey) { 414 return function currentHook() { 415 var _currentArray$at$name; 416 const hooksStore = hooks[storeKey]; 417 const currentArray = Array.from(hooksStore.__current); 418 return (_currentArray$at$name = currentArray.at(-1)?.name) !== null && _currentArray$at$name !== void 0 ? _currentArray$at$name : null; 419 }; 420} 421/* harmony default export */ const build_module_createCurrentHook = (createCurrentHook); 422 423;// ./node_modules/@wordpress/hooks/build-module/createDoingHook.js 424/** 425 * @callback DoingHook 426 * Returns whether a hook is currently being executed. 427 * 428 * @param {string} [hookName] The name of the hook to check for. If 429 * omitted, will check for any hook being executed. 430 * 431 * @return {boolean} Whether the hook is being executed. 432 */ 433 434/** 435 * Returns a function which, when invoked, will return whether a hook is 436 * currently being executed. 437 * 438 * @param {import('.').Hooks} hooks Hooks instance. 439 * @param {import('.').StoreKey} storeKey 440 * 441 * @return {DoingHook} Function that returns whether a hook is currently 442 * being executed. 443 */ 444function createDoingHook(hooks, storeKey) { 445 return function doingHook(hookName) { 446 const hooksStore = hooks[storeKey]; 447 448 // If the hookName was not passed, check for any current hook. 449 if ('undefined' === typeof hookName) { 450 return hooksStore.__current.size > 0; 451 } 452 453 // Find if the `hookName` hook is in `__current`. 454 return Array.from(hooksStore.__current).some(hook => hook.name === hookName); 455 }; 456} 457/* harmony default export */ const build_module_createDoingHook = (createDoingHook); 458 459;// ./node_modules/@wordpress/hooks/build-module/createDidHook.js 460/** 461 * Internal dependencies 462 */ 463 464 465/** 466 * @callback DidHook 467 * 468 * Returns the number of times an action has been fired. 469 * 470 * @param {string} hookName The hook name to check. 471 * 472 * @return {number | undefined} The number of times the hook has run. 473 */ 474 475/** 476 * Returns a function which, when invoked, will return the number of times a 477 * hook has been called. 478 * 479 * @param {import('.').Hooks} hooks Hooks instance. 480 * @param {import('.').StoreKey} storeKey 481 * 482 * @return {DidHook} Function that returns a hook's call count. 483 */ 484function createDidHook(hooks, storeKey) { 485 return function didHook(hookName) { 486 const hooksStore = hooks[storeKey]; 487 if (!build_module_validateHookName(hookName)) { 488 return; 489 } 490 return hooksStore[hookName] && hooksStore[hookName].runs ? hooksStore[hookName].runs : 0; 491 }; 492} 493/* harmony default export */ const build_module_createDidHook = (createDidHook); 494 495;// ./node_modules/@wordpress/hooks/build-module/createHooks.js 496/** 497 * Internal dependencies 498 */ 499 500 501 502 503 504 505 506 507/**
508 * Internal class for constructing hooks. Use `createHooks()` function 509 * 510 * Note, it is necessary to expose this class to make its type public. 511 * 512 * @private 513 */ 514class _Hooks { 515 constructor() { 516 /** @type {import('.').Store} actions */ 517 this.actions = Object.create(null); 518 this.actions.__current = new Set(); 519 520 /** @type {import('.').Store} filters */ 521 this.filters = Object.create(null); 522 this.filters.__current = new Set(); 523 this.addAction = build_module_createAddHook(this, 'actions'); 524 this.addFilter = build_module_createAddHook(this, 'filters'); 525 this.removeAction = build_module_createRemoveHook(this, 'actions'); 526 this.removeFilter = build_module_createRemoveHook(this, 'filters'); 527 this.hasAction = build_module_createHasHook(this, 'actions'); 528 this.hasFilter = build_module_createHasHook(this, 'filters'); 529 this.removeAllActions = build_module_createRemoveHook(this, 'actions', true); 530 this.removeAllFilters = build_module_createRemoveHook(this, 'filters', true); 531 this.doAction = build_module_createRunHook(this, 'actions', false, false); 532 this.doActionAsync = build_module_createRunHook(this, 'actions', false, true); 533 this.applyFilters = build_module_createRunHook(this, 'filters', true, false); 534 this.applyFiltersAsync = build_module_createRunHook(this, 'filters', true, true); 535 this.currentAction = build_module_createCurrentHook(this, 'actions'); 536 this.currentFilter = build_module_createCurrentHook(this, 'filters'); 537 this.doingAction = build_module_createDoingHook(this, 'actions'); 538 this.doingFilter = build_module_createDoingHook(this, 'filters'); 539 this.didAction = build_module_createDidHook(this, 'actions'); 540 this.didFilter = build_module_createDidHook(this, 'filters'); 541 } 542} 543 544/** @typedef {_Hooks} Hooks */ 545 546/** 547 * Returns an instance of the hooks object. 548 * 549 * @return {Hooks} A Hooks instance. 550 */ 551function createHooks() { 552 return new _Hooks(); 553} 554/* harmony default export */ const build_module_createHooks = (createHooks); 555 556;// ./node_modules/@wordpress/hooks/build-module/index.js 557/** 558 * Internal dependencies 559 */ 560 561 562/** @typedef {(...args: any[])=>any} Callback */ 563 564/** 565 * @typedef Handler 566 * @property {Callback} callback The callback 567 * @property {string} namespace The namespace 568 * @property {number} priority The namespace 569 */ 570 571/** 572 * @typedef Hook 573 * @property {Handler[]} handlers Array of handlers 574 * @property {number} runs Run counter 575 */ 576 577/** 578 * @typedef Current 579 * @property {string} name Hook name 580 * @property {number} currentIndex The index 581 */ 582 583/** 584 * @typedef {Record<string, Hook> & {__current: Set<Current>}} Store 585 */ 586 587/** 588 * @typedef {'actions' | 'filters'} StoreKey 589 */ 590 591/** 592 * @typedef {import('./createHooks').Hooks} Hooks 593 */ 594 595const defaultHooks = build_module_createHooks(); 596const { 597 addAction, 598 addFilter, 599 removeAction, 600 removeFilter, 601 hasAction, 602 hasFilter, 603 removeAllActions, 604 removeAllFilters, 605 doAction, 606 doActionAsync, 607 applyFilters, 608 applyFiltersAsync, 609 currentAction, 610 currentFilter, 611 doingAction, 612 doingFilter, 613 didAction, 614 didFilter, 615 actions, 616 filters 617} = defaultHooks; 618 619 620(window.wp = window.wp || {}).hooks = __webpack_exports__; 621/******/ })() 622;
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.