(()=> {
"use strict";
var __webpack_require__={};
(()=> {
__webpack_require__.d=(exports, definition)=> {
for(var key in definition){
if(__webpack_require__.o(definition, key)&&!__webpack_require__.o(exports, key)){
Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
}
}
};
})();
(()=> {
__webpack_require__.o=(obj, prop)=> (Object.prototype.hasOwnProperty.call(obj, prop))
})();
(()=> {
__webpack_require__.r=(exports)=> {
if(typeof Symbol!=='undefined'&&Symbol.toStringTag){
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
}
Object.defineProperty(exports, '__esModule', { value: true });
};
})();
var __webpack_exports__={};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
actions: ()=> ( actions),
addAction: ()=> ( addAction),
addFilter: ()=> ( addFilter),
applyFilters: ()=> ( applyFilters),
applyFiltersAsync: ()=> ( applyFiltersAsync),
createHooks: ()=> ( build_module_createHooks),
currentAction: ()=> ( currentAction),
currentFilter: ()=> ( currentFilter),
defaultHooks: ()=> ( defaultHooks),
didAction: ()=> ( didAction),
didFilter: ()=> ( didFilter),
doAction: ()=> ( doAction),
doActionAsync: ()=> ( doActionAsync),
doingAction: ()=> ( doingAction),
doingFilter: ()=> ( doingFilter),
filters: ()=> ( filters),
hasAction: ()=> ( hasAction),
hasFilter: ()=> ( hasFilter),
removeAction: ()=> ( removeAction),
removeAllActions: ()=> ( removeAllActions),
removeAllFilters: ()=> ( removeAllFilters),
removeFilter: ()=> ( removeFilter)
});
;
function validateNamespace(namespace){
if('string'!==typeof namespace||''===namespace){
console.error('The namespace must be a non-empty string.');
return false;
}
if(!/^[a-zA-Z][a-zA-Z0-9_.\-\/]*$/.test(namespace)){
console.error('The namespace can only contain numbers, letters, dashes, periods, underscores and slashes.');
return false;
}
return true;
}
const build_module_validateNamespace=(validateNamespace);
;
function validateHookName(hookName){
if('string'!==typeof hookName||''===hookName){
console.error('The hook name must be a non-empty string.');
return false;
}
if(/^__/.test(hookName)){
console.error('The hook name cannot begin with `__`.');
return false;
}
if(!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(hookName)){
console.error('The hook name can only contain numbers, letters, dashes, periods and underscores.');
return false;
}
return true;
}
const build_module_validateHookName=(validateHookName);
;
function createAddHook(hooks, storeKey){
return function addHook(hookName, namespace, callback, priority=10){
const hooksStore=hooks[storeKey];
if(!build_module_validateHookName(hookName)){
return;
}
if(!build_module_validateNamespace(namespace)){
return;
}
if('function'!==typeof callback){
console.error('The hook callback must be a function.');
return;
}
if('number'!==typeof priority){
console.error('If specified, the hook priority must be a number.');
return;
}
const handler={
callback,
priority,
namespace
};
if(hooksStore[hookName]){
const handlers=hooksStore[hookName].handlers;
let i;
for (i=handlers.length; i > 0; i--){
if(priority >=handlers[i - 1].priority){
break;
}}
if(i===handlers.length){
handlers[i]=handler;
}else{
handlers.splice(i, 0, handler);
}
hooksStore.__current.forEach(hookInfo=> {
if(hookInfo.name===hookName&&hookInfo.currentIndex >=i){
hookInfo.currentIndex++;
}});
}else{
hooksStore[hookName]={
handlers: [handler],
runs: 0
};}
if(hookName!=='hookAdded'){
hooks.doAction('hookAdded', hookName, namespace, callback, priority);
}};}
const build_module_createAddHook=(createAddHook);
;
function createRemoveHook(hooks, storeKey, removeAll=false){
return function removeHook(hookName, namespace){
const hooksStore=hooks[storeKey];
if(!build_module_validateHookName(hookName)){
return;
}
if(!removeAll&&!build_module_validateNamespace(namespace)){
return;
}
if(!hooksStore[hookName]){
return 0;
}
let handlersRemoved=0;
if(removeAll){
handlersRemoved=hooksStore[hookName].handlers.length;
hooksStore[hookName]={
runs: hooksStore[hookName].runs,
handlers: []
};}else{
const handlers=hooksStore[hookName].handlers;
for (let i=handlers.length - 1; i >=0; i--){
if(handlers[i].namespace===namespace){
handlers.splice(i, 1);
handlersRemoved++;
hooksStore.__current.forEach(hookInfo=> {
if(hookInfo.name===hookName&&hookInfo.currentIndex >=i){
hookInfo.currentIndex--;
}});
}}
}
if(hookName!=='hookRemoved'){
hooks.doAction('hookRemoved', hookName, namespace);
}
return handlersRemoved;
};}
const build_module_createRemoveHook=(createRemoveHook);
;
function createHasHook(hooks, storeKey){
return function hasHook(hookName, namespace){
const hooksStore=hooks[storeKey];
if('undefined'!==typeof namespace){
return hookName in hooksStore&&hooksStore[hookName].handlers.some(hook=> hook.namespace===namespace);
}
return hookName in hooksStore;
};}
const build_module_createHasHook=(createHasHook);
;
function createRunHook(hooks, storeKey, returnFirstArg, async){
return function runHook(hookName, ...args){
const hooksStore=hooks[storeKey];
if(!hooksStore[hookName]){
hooksStore[hookName]={
handlers: [],
runs: 0
};}
hooksStore[hookName].runs++;
const handlers=hooksStore[hookName].handlers;
if(false){}
if(!handlers||!handlers.length){
return returnFirstArg ? args[0]:undefined;
}
const hookInfo={
name: hookName,
currentIndex: 0
};
async function asyncRunner(){
try {
hooksStore.__current.add(hookInfo);
let result=returnFirstArg ? args[0]:undefined;
while (hookInfo.currentIndex < handlers.length){
const handler=handlers[hookInfo.currentIndex];
result=await handler.callback.apply(null, args);
if(returnFirstArg){
args[0]=result;
}
hookInfo.currentIndex++;
}
return returnFirstArg ? result:undefined;
} finally {
hooksStore.__current.delete(hookInfo);
}}
function syncRunner(){
try {
hooksStore.__current.add(hookInfo);
let result=returnFirstArg ? args[0]:undefined;
while (hookInfo.currentIndex < handlers.length){
const handler=handlers[hookInfo.currentIndex];
result=handler.callback.apply(null, args);
if(returnFirstArg){
args[0]=result;
}
hookInfo.currentIndex++;
}
return returnFirstArg ? result:undefined;
} finally {
hooksStore.__current.delete(hookInfo);
}}
return (async ? asyncRunner:syncRunner)();
};}
const build_module_createRunHook=(createRunHook);
;
function createCurrentHook(hooks, storeKey){
return function currentHook(){
var _currentArray$at$name;
const hooksStore=hooks[storeKey];
const currentArray=Array.from(hooksStore.__current);
return (_currentArray$at$name=currentArray.at(-1)?.name)!==null&&_currentArray$at$name!==void 0 ? _currentArray$at$name:null;
};}
const build_module_createCurrentHook=(createCurrentHook);
;
function createDoingHook(hooks, storeKey){
return function doingHook(hookName){
const hooksStore=hooks[storeKey];
if('undefined'===typeof hookName){
return hooksStore.__current.size > 0;
}
return Array.from(hooksStore.__current).some(hook=> hook.name===hookName);
};}
const build_module_createDoingHook=(createDoingHook);
;
function createDidHook(hooks, storeKey){
return function didHook(hookName){
const hooksStore=hooks[storeKey];
if(!build_module_validateHookName(hookName)){
return;
}
return hooksStore[hookName]&&hooksStore[hookName].runs ? hooksStore[hookName].runs:0;
};}
const build_module_createDidHook=(createDidHook);
;
class _Hooks {
constructor(){
this.actions=Object.create(null);
this.actions.__current=new Set();
this.filters=Object.create(null);
this.filters.__current=new Set();
this.addAction=build_module_createAddHook(this, 'actions');
this.addFilter=build_module_createAddHook(this, 'filters');
this.removeAction=build_module_createRemoveHook(this, 'actions');
this.removeFilter=build_module_createRemoveHook(this, 'filters');
this.hasAction=build_module_createHasHook(this, 'actions');
this.hasFilter=build_module_createHasHook(this, 'filters');
this.removeAllActions=build_module_createRemoveHook(this, 'actions', true);
this.removeAllFilters=build_module_createRemoveHook(this, 'filters', true);
this.doAction=build_module_createRunHook(this, 'actions', false, false);
this.doActionAsync=build_module_createRunHook(this, 'actions', false, true);
this.applyFilters=build_module_createRunHook(this, 'filters', true, false);
this.applyFiltersAsync=build_module_createRunHook(this, 'filters', true, true);
this.currentAction=build_module_createCurrentHook(this, 'actions');
this.currentFilter=build_module_createCurrentHook(this, 'filters');
this.doingAction=build_module_createDoingHook(this, 'actions');
this.doingFilter=build_module_createDoingHook(this, 'filters');
this.didAction=build_module_createDidHook(this, 'actions');
this.didFilter=build_module_createDidHook(this, 'filters');
}}
function createHooks(){
return new _Hooks();
}
const build_module_createHooks=(createHooks);
;
const defaultHooks=build_module_createHooks();
const {
addAction,
addFilter,
removeAction,
removeFilter,
hasAction,
hasFilter,
removeAllActions,
removeAllFilters,
doAction,
doActionAsync,
applyFilters,
applyFiltersAsync,
currentAction,
currentFilter,
doingAction,
doingFilter,
didAction,
didFilter,
actions,
filters
}=defaultHooks;
(window.wp=window.wp||{}).hooks=__webpack_exports__;
})()
;