@eightshift/ui-components 6.3.0 → 7.1.0

package/dist/build-module-sxK3nxOK.js

@@ -0,0 +1,855 @@
+//#region node_modules/@tannin/sprintf/src/index.js
+/**
+* Regular expression matching format placeholder syntax.
+*
+* The pattern for matching named arguments is a naive and incomplete matcher
+* against valid JavaScript identifier names.
+*
+* via Mathias Bynens:
+*
+* >An identifier must start with $, _, or any character in the Unicode
+* >categories “Uppercase letter (Lu)”, “Lowercase letter (Ll)”, “Titlecase
+* >letter (Lt)”, “Modifier letter (Lm)”, “Other letter (Lo)”, or “Letter
+* >number (Nl)”.
+* >
+* >The rest of the string can contain the same characters, plus any U+200C zero
+* >width non-joiner characters, U+200D zero width joiner characters, and
+* >characters in the Unicode categories “Non-spacing mark (Mn)”, “Spacing
+* >combining mark (Mc)”, “Decimal digit number (Nd)”, or “Connector
+* >punctuation (Pc)”.
+*
+* If browser support is constrained to those supporting ES2015, this could be
+* made more accurate using the `u` flag:
+*
+* ```
+* /^[$_\p{L}\p{Nl}][$_\p{L}\p{Nl}\u200C\u200D\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/u;
+* ```
+*
+* @see http://www.pixelbeat.org/programming/gcc/format_specs.html
+* @see https://mathiasbynens.be/notes/javascript-identifiers#valid-identifier-names
+*
+* @type {RegExp}
+*/
+var PATTERN$1 = /%(((\d+)\$)|(\(([$_a-zA-Z][$_a-zA-Z0-9]*)\)))?[ +0#-]*\d*(\.(\d+|\*))?(ll|[lhqL])?([cduxXefgsp%])/g;
+/**
+* Given a format string, returns string with arguments interpolatation.
+* Arguments can either be provided directly via function arguments spread, or
+* with an array as the second argument.
+*
+* @see https://en.wikipedia.org/wiki/Printf_format_string
+*
+* @example
+*
+* ```js
+* import sprintf from '@tannin/sprintf';
+*
+* sprintf( 'Hello %s!', 'world' );
+* // ⇒ 'Hello world!'
+* ```
+* @template {string} T
+* @overload
+* @param {T} string - string printf format string
+* @param {...import('../types').SprintfArgs<T>} args - arguments to interpolate
+*
+* @return {string} Formatted string.
+*/
+/**
+* Given a format string, returns string with arguments interpolatation.
+* Arguments can either be provided directly via function arguments spread, or
+* with an array as the second argument.
+*
+* @see https://en.wikipedia.org/wiki/Printf_format_string
+*
+* @example
+*
+* ```js
+* import sprintf from '@tannin/sprintf';
+*
+* sprintf( 'Hello %s!', 'world' );
+* // ⇒ 'Hello world!'
+* ```
+* @template {string} T
+* @overload
+* @param {T} string - string printf format string
+* @param {import('../types').SprintfArgs<T>} args - arguments to interpolate
+*
+* @return {string} Formatted string.
+*/
+/**
+* Given a format string, returns string with arguments interpolatation.
+* Arguments can either be provided directly via function arguments spread, or
+* with an array as the second argument.
+*
+* @see https://en.wikipedia.org/wiki/Printf_format_string
+*
+* @example
+*
+* ```js
+* import sprintf from '@tannin/sprintf';
+*
+* sprintf( 'Hello %s!', 'world' );
+* // ⇒ 'Hello world!'
+* ```
+* @template {string} T
+* @param {T} string - string printf format string
+* @param {...import('../types').SprintfArgs<T>} args - arguments to interpolate
+*
+* @return {string} Formatted string.
+*/
+function sprintf$1(string, ...args) {
+	var i = 0;
+	if (Array.isArray(args[0])) args = args[0];
+	return string.replace(PATTERN$1, function() {
+		var index = arguments[3], name = arguments[5], precision = arguments[7], type = arguments[9], value;
+		if (type === "%") return "%";
+		if (precision === "*") {
+			precision = args[i];
+			i++;
+		}
+		if (name === void 0) {
+			if (index === void 0) index = i + 1;
+			i++;
+			value = args[index - 1];
+		} else if (args[0] && typeof args[0] === "object" && args[0].hasOwnProperty(name)) value = args[0][name];
+		if (type === "f") value = parseFloat(value) || 0;
+		else if (type === "d") value = parseInt(value) || 0;
+		if (precision !== void 0) {
+			if (type === "f") value = value.toFixed(precision);
+			else if (type === "s") value = value.substr(0, precision);
+		}
+		return value !== void 0 && value !== null ? value : "";
+	});
+}
+//#endregion
+//#region node_modules/@wordpress/i18n/build-module/sprintf.mjs
+function sprintf(format, ...args) {
+	return sprintf$1(format, ...args);
+}
+//#endregion
+//#region node_modules/@tannin/postfix/index.js
+var PRECEDENCE = {
+	"(": 9,
+	"!": 8,
+	"*": 7,
+	"/": 7,
+	"%": 7,
+	"+": 6,
+	"-": 6,
+	"<": 5,
+	"<=": 5,
+	">": 5,
+	">=": 5,
+	"==": 4,
+	"!=": 4,
+	"&&": 3,
+	"||": 2,
+	"?": 1,
+	"?:": 1
+}, OPENERS = ["(", "?"], TERMINATORS = {
+	")": ["("],
+	":": ["?", "?:"]
+}, PATTERN = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/;
+/**
+* Given a C expression, returns the equivalent postfix (Reverse Polish)
+* notation terms as an array.
+*
+* If a postfix string is desired, simply `.join( ' ' )` the result.
+*
+* @example
+*
+* ```js
+* import postfix from '@tannin/postfix';
+*
+* postfix( 'n > 1' );
+* // ⇒ [ 'n', '1', '>' ]
+* ```
+*
+* @param {string} expression C expression.
+*
+* @return {string[]} Postfix terms.
+*/
+function postfix(expression) {
+	var terms = [], stack = [], match, operator, term, element;
+	while (match = expression.match(PATTERN)) {
+		operator = match[0];
+		term = expression.substr(0, match.index).trim();
+		if (term) terms.push(term);
+		while (element = stack.pop()) {
+			if (TERMINATORS[operator]) {
+				if (TERMINATORS[operator][0] === element) {
+					operator = TERMINATORS[operator][1] || operator;
+					break;
+				}
+			} else if (OPENERS.indexOf(element) >= 0 || PRECEDENCE[element] < PRECEDENCE[operator]) {
+				stack.push(element);
+				break;
+			}
+			terms.push(element);
+		}
+		if (!TERMINATORS[operator]) stack.push(operator);
+		expression = expression.substr(match.index + operator.length);
+	}
+	expression = expression.trim();
+	if (expression) terms.push(expression);
+	return terms.concat(stack.reverse());
+}
+//#endregion
+//#region node_modules/@tannin/evaluate/index.js
+/**
+* Operator callback functions.
+*
+* @type {Object}
+*/
+var OPERATORS = {
+	"!": function(a) {
+		return !a;
+	},
+	"*": function(a, b) {
+		return a * b;
+	},
+	"/": function(a, b) {
+		return a / b;
+	},
+	"%": function(a, b) {
+		return a % b;
+	},
+	"+": function(a, b) {
+		return a + b;
+	},
+	"-": function(a, b) {
+		return a - b;
+	},
+	"<": function(a, b) {
+		return a < b;
+	},
+	"<=": function(a, b) {
+		return a <= b;
+	},
+	">": function(a, b) {
+		return a > b;
+	},
+	">=": function(a, b) {
+		return a >= b;
+	},
+	"==": function(a, b) {
+		return a === b;
+	},
+	"!=": function(a, b) {
+		return a !== b;
+	},
+	"&&": function(a, b) {
+		return a && b;
+	},
+	"||": function(a, b) {
+		return a || b;
+	},
+	"?:": function(a, b, c) {
+		if (a) throw b;
+		return c;
+	}
+};
+/**
+* Given an array of postfix terms and operand variables, returns the result of
+* the postfix evaluation.
+*
+* @example
+*
+* ```js
+* import evaluate from '@tannin/evaluate';
+*
+* // 3 + 4 * 5 / 6 ⇒ '3 4 5 * 6 / +'
+* const terms = [ '3', '4', '5', '*', '6', '/', '+' ];
+*
+* evaluate( terms, {} );
+* // ⇒ 6.333333333333334
+* ```
+*
+* @param {string[]} postfix   Postfix terms.
+* @param {Object}   variables Operand variables.
+*
+* @return {*} Result of evaluation.
+*/
+function evaluate(postfix, variables) {
+	var stack = [], i, j, args, getOperatorResult, term, value;
+	for (i = 0; i < postfix.length; i++) {
+		term = postfix[i];
+		getOperatorResult = OPERATORS[term];
+		if (getOperatorResult) {
+			j = getOperatorResult.length;
+			args = Array(j);
+			while (j--) args[j] = stack.pop();
+			try {
+				value = getOperatorResult.apply(null, args);
+			} catch (earlyReturn) {
+				return earlyReturn;
+			}
+		} else if (variables.hasOwnProperty(term)) value = variables[term];
+		else value = +term;
+		stack.push(value);
+	}
+	return stack[0];
+}
+//#endregion
+//#region node_modules/@tannin/compile/index.js
+/**
+* Given a C expression, returns a function which can be called to evaluate its
+* result.
+*
+* @example
+*
+* ```js
+* import compile from '@tannin/compile';
+*
+* const evaluate = compile( 'n > 1' );
+*
+* evaluate( { n: 2 } );
+* // ⇒ true
+* ```
+*
+* @param {string} expression C expression.
+*
+* @return {(variables?:{[variable:string]:*})=>*} Compiled evaluator.
+*/
+function compile(expression) {
+	var terms = postfix(expression);
+	return function(variables) {
+		return evaluate(terms, variables);
+	};
+}
+//#endregion
+//#region node_modules/@tannin/plural-forms/index.js
+/**
+* Given a C expression, returns a function which, when called with a value,
+* evaluates the result with the value assumed to be the "n" variable of the
+* expression. The result will be coerced to its numeric equivalent.
+*
+* @param {string} expression C expression.
+*
+* @return {Function} Evaluator function.
+*/
+function pluralForms(expression) {
+	var evaluate = compile(expression);
+	return function(n) {
+		return +evaluate({ n });
+	};
+}
+//#endregion
+//#region node_modules/tannin/index.js
+/**
+* Tannin constructor options.
+*
+* @typedef {Object} TanninOptions
+*
+* @property {string}   [contextDelimiter] Joiner in string lookup with context.
+* @property {Function} [onMissingKey]     Callback to invoke when key missing.
+*/
+/**
+* Domain metadata.
+*
+* @typedef {Object} TanninDomainMetadata
+*
+* @property {string}            [domain]       Domain name.
+* @property {string}            [lang]         Language code.
+* @property {(string|Function)} [plural_forms] Plural forms expression or
+*                                              function evaluator.
+*/
+/**
+* Domain translation pair respectively representing the singular and plural
+* translation.
+*
+* @typedef {[string,string]} TanninTranslation
+*/
+/**
+* Locale data domain. The key is used as reference for lookup, the value an
+* array of two string entries respectively representing the singular and plural
+* translation.
+*
+* @typedef {{[key:string]:TanninDomainMetadata|TanninTranslation,'':TanninDomainMetadata|TanninTranslation}} TanninLocaleDomain
+*/
+/**
+* Jed-formatted locale data.
+*
+* @see http://messageformat.github.io/Jed/
+*
+* @typedef {{[domain:string]:TanninLocaleDomain}} TanninLocaleData
+*/
+/**
+* Default Tannin constructor options.
+*
+* @type {TanninOptions}
+*/
+var DEFAULT_OPTIONS = {
+	contextDelimiter: "",
+	onMissingKey: null
+};
+/**
+* Given a specific locale data's config `plural_forms` value, returns the
+* expression.
+*
+* @example
+*
+* ```
+* getPluralExpression( 'nplurals=2; plural=(n != 1);' ) === '(n != 1)'
+* ```
+*
+* @param {string} pf Locale data plural forms.
+*
+* @return {string} Plural forms expression.
+*/
+function getPluralExpression(pf) {
+	var parts = pf.split(";"), i, part;
+	for (i = 0; i < parts.length; i++) {
+		part = parts[i].trim();
+		if (part.indexOf("plural=") === 0) return part.substr(7);
+	}
+}
+/**
+* Tannin constructor.
+*
+* @class
+*
+* @param {TanninLocaleData} data      Jed-formatted locale data.
+* @param {TanninOptions}    [options] Tannin options.
+*/
+function Tannin(data, options) {
+	var key;
+	/**
+	* Jed-formatted locale data.
+	*
+	* @name Tannin#data
+	* @type {TanninLocaleData}
+	*/
+	this.data = data;
+	/**
+	* Plural forms function cache, keyed by plural forms string.
+	*
+	* @name Tannin#pluralForms
+	* @type {Object<string,Function>}
+	*/
+	this.pluralForms = {};
+	/**
+	* Effective options for instance, including defaults.
+	*
+	* @name Tannin#options
+	* @type {TanninOptions}
+	*/
+	this.options = {};
+	for (key in DEFAULT_OPTIONS) this.options[key] = options !== void 0 && key in options ? options[key] : DEFAULT_OPTIONS[key];
+}
+/**
+* Returns the plural form index for the given domain and value.
+*
+* @param {string} domain Domain on which to calculate plural form.
+* @param {number} n      Value for which plural form is to be calculated.
+*
+* @return {number} Plural form index.
+*/
+Tannin.prototype.getPluralForm = function(domain, n) {
+	var getPluralForm = this.pluralForms[domain], config, plural, pf;
+	if (!getPluralForm) {
+		config = this.data[domain][""];
+		pf = config["Plural-Forms"] || config["plural-forms"] || config.plural_forms;
+		if (typeof pf !== "function") {
+			plural = getPluralExpression(config["Plural-Forms"] || config["plural-forms"] || config.plural_forms);
+			pf = pluralForms(plural);
+		}
+		getPluralForm = this.pluralForms[domain] = pf;
+	}
+	return getPluralForm(n);
+};
+/**
+* Translate a string.
+*
+* @param {string}      domain   Translation domain.
+* @param {string|void} context  Context distinguishing terms of the same name.
+* @param {string}      singular Primary key for translation lookup.
+* @param {string=}     plural   Fallback value used for non-zero plural
+*                               form index.
+* @param {number=}     n        Value to use in calculating plural form.
+*
+* @return {string} Translated string.
+*/
+Tannin.prototype.dcnpgettext = function(domain, context, singular, plural, n) {
+	var index, key, entry;
+	if (n === void 0) index = 0;
+	else index = this.getPluralForm(domain, n);
+	key = singular;
+	if (context) key = context + this.options.contextDelimiter + singular;
+	entry = this.data[domain][key];
+	if (entry && entry[index]) return entry[index];
+	if (this.options.onMissingKey) this.options.onMissingKey(singular, domain);
+	return index === 0 ? singular : plural;
+};
+//#endregion
+//#region node_modules/@wordpress/i18n/build-module/create-i18n.mjs
+var DEFAULT_LOCALE_DATA = { "": { plural_forms(n) {
+	return n === 1 ? 0 : 1;
+} } };
+var I18N_HOOK_REGEXP = /^i18n\.(n?gettext|has_translation)(_|$)/;
+var createI18n = (initialData, initialDomain, hooks) => {
+	const tannin = new Tannin({});
+	const listeners = new Set();
+	const notifyListeners = () => {
+		listeners.forEach((listener) => listener());
+	};
+	const subscribe = (callback) => {
+		listeners.add(callback);
+		return () => listeners.delete(callback);
+	};
+	const getLocaleData = (domain = "default") => tannin.data[domain];
+	const doSetLocaleData = (data, domain = "default") => {
+		tannin.data[domain] = {
+			...tannin.data[domain],
+			...data
+		};
+		tannin.data[domain][""] = {
+			...DEFAULT_LOCALE_DATA[""],
+			...tannin.data[domain]?.[""]
+		};
+		delete tannin.pluralForms[domain];
+	};
+	const setLocaleData = (data, domain) => {
+		doSetLocaleData(data, domain);
+		notifyListeners();
+	};
+	const addLocaleData = (data, domain = "default") => {
+		tannin.data[domain] = {
+			...tannin.data[domain],
+			...data,
+			"": {
+				...DEFAULT_LOCALE_DATA[""],
+				...tannin.data[domain]?.[""],
+				...data?.[""]
+			}
+		};
+		delete tannin.pluralForms[domain];
+		notifyListeners();
+	};
+	const resetLocaleData = (data, domain) => {
+		tannin.data = {};
+		tannin.pluralForms = {};
+		setLocaleData(data, domain);
+	};
+	const dcnpgettext = (domain = "default", context, single, plural, number) => {
+		if (!tannin.data[domain]) doSetLocaleData(void 0, domain);
+		return tannin.dcnpgettext(domain, context, single, plural, number);
+	};
+	const getFilterDomain = (domain) => domain || "default";
+	const __ = (text, domain) => {
+		let translation = dcnpgettext(domain, void 0, text);
+		if (!hooks) return translation;
+		translation = hooks.applyFilters("i18n.gettext", translation, text, domain);
+		return hooks.applyFilters("i18n.gettext_" + getFilterDomain(domain), translation, text, domain);
+	};
+	const _x = (text, context, domain) => {
+		let translation = dcnpgettext(domain, context, text);
+		if (!hooks) return translation;
+		translation = hooks.applyFilters("i18n.gettext_with_context", translation, text, context, domain);
+		return hooks.applyFilters("i18n.gettext_with_context_" + getFilterDomain(domain), translation, text, context, domain);
+	};
+	const _n = (single, plural, number, domain) => {
+		let translation = dcnpgettext(domain, void 0, single, plural, number);
+		if (!hooks) return translation;
+		translation = hooks.applyFilters("i18n.ngettext", translation, single, plural, number, domain);
+		return hooks.applyFilters("i18n.ngettext_" + getFilterDomain(domain), translation, single, plural, number, domain);
+	};
+	const _nx = (single, plural, number, context, domain) => {
+		let translation = dcnpgettext(domain, context, single, plural, number);
+		if (!hooks) return translation;
+		translation = hooks.applyFilters("i18n.ngettext_with_context", translation, single, plural, number, context, domain);
+		return hooks.applyFilters("i18n.ngettext_with_context_" + getFilterDomain(domain), translation, single, plural, number, context, domain);
+	};
+	const isRTL = () => {
+		return "rtl" === _x("ltr", "text direction");
+	};
+	const hasTranslation = (single, context, domain) => {
+		const key = context ? context + "" + single : single;
+		let result = !!tannin.data?.[domain ?? "default"]?.[key];
+		if (hooks) {
+			result = hooks.applyFilters("i18n.has_translation", result, single, context, domain);
+			result = hooks.applyFilters("i18n.has_translation_" + getFilterDomain(domain), result, single, context, domain);
+		}
+		return result;
+	};
+	if (initialData) setLocaleData(initialData, initialDomain);
+	if (hooks) {
+		const onHookAddedOrRemoved = (hookName) => {
+			if (I18N_HOOK_REGEXP.test(hookName)) notifyListeners();
+		};
+		hooks.addAction("hookAdded", "core/i18n", onHookAddedOrRemoved);
+		hooks.addAction("hookRemoved", "core/i18n", onHookAddedOrRemoved);
+	}
+	return {
+		getLocaleData,
+		setLocaleData,
+		addLocaleData,
+		resetLocaleData,
+		subscribe,
+		__,
+		_x,
+		_n,
+		_nx,
+		isRTL,
+		hasTranslation
+	};
+};
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/validateNamespace.mjs
+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;
+}
+var validateNamespace_default = validateNamespace;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/validateHookName.mjs
+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;
+}
+var validateHookName_default = validateHookName;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createAddHook.mjs
+function createAddHook(hooks, storeKey) {
+	return function addHook(hookName, namespace, callback, priority = 10) {
+		const hooksStore = hooks[storeKey];
+		if (!validateHookName_default(hookName)) return;
+		if (!validateNamespace_default(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);
+	};
+}
+var createAddHook_default = createAddHook;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createRemoveHook.mjs
+function createRemoveHook(hooks, storeKey, removeAll = false) {
+	return function removeHook(hookName, namespace) {
+		const hooksStore = hooks[storeKey];
+		if (!validateHookName_default(hookName)) return;
+		if (!removeAll && !validateNamespace_default(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;
+	};
+}
+var createRemoveHook_default = createRemoveHook;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createHasHook.mjs
+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;
+	};
+}
+var createHasHook_default = createHasHook;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createRunHook.mjs
+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 ("production" !== process.env.NODE_ENV) {
+			if ("hookAdded" !== hookName && hooksStore.all) handlers.push(...hooksStore.all.handlers);
+		}
+		if (!handlers || !handlers.length) return returnFirstArg ? args[0] : void 0;
+		const hookInfo = {
+			name: hookName,
+			currentIndex: 0
+		};
+		async function asyncRunner() {
+			try {
+				hooksStore.__current.add(hookInfo);
+				let result = returnFirstArg ? args[0] : void 0;
+				while (hookInfo.currentIndex < handlers.length) {
+					result = await handlers[hookInfo.currentIndex].callback.apply(null, args);
+					if (returnFirstArg) args[0] = result;
+					hookInfo.currentIndex++;
+				}
+				return returnFirstArg ? result : void 0;
+			} finally {
+				hooksStore.__current.delete(hookInfo);
+			}
+		}
+		function syncRunner() {
+			try {
+				hooksStore.__current.add(hookInfo);
+				let result = returnFirstArg ? args[0] : void 0;
+				while (hookInfo.currentIndex < handlers.length) {
+					result = handlers[hookInfo.currentIndex].callback.apply(null, args);
+					if (returnFirstArg) args[0] = result;
+					hookInfo.currentIndex++;
+				}
+				return returnFirstArg ? result : void 0;
+			} finally {
+				hooksStore.__current.delete(hookInfo);
+			}
+		}
+		return (async ? asyncRunner : syncRunner)();
+	};
+}
+var createRunHook_default = createRunHook;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createCurrentHook.mjs
+function createCurrentHook(hooks, storeKey) {
+	return function currentHook() {
+		const hooksStore = hooks[storeKey];
+		return Array.from(hooksStore.__current).at(-1)?.name ?? null;
+	};
+}
+var createCurrentHook_default = createCurrentHook;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createDoingHook.mjs
+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);
+	};
+}
+var createDoingHook_default = createDoingHook;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createDidHook.mjs
+function createDidHook(hooks, storeKey) {
+	return function didHook(hookName) {
+		const hooksStore = hooks[storeKey];
+		if (!validateHookName_default(hookName)) return;
+		return hooksStore[hookName] && hooksStore[hookName].runs ? hooksStore[hookName].runs : 0;
+	};
+}
+var createDidHook_default = createDidHook;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/createHooks.mjs
+var _Hooks = class {
+	actions;
+	filters;
+	addAction;
+	addFilter;
+	removeAction;
+	removeFilter;
+	hasAction;
+	hasFilter;
+	removeAllActions;
+	removeAllFilters;
+	doAction;
+	doActionAsync;
+	applyFilters;
+	applyFiltersAsync;
+	currentAction;
+	currentFilter;
+	doingAction;
+	doingFilter;
+	didAction;
+	didFilter;
+	constructor() {
+		this.actions = Object.create(null);
+		this.actions.__current = new Set();
+		this.filters = Object.create(null);
+		this.filters.__current = new Set();
+		this.addAction = createAddHook_default(this, "actions");
+		this.addFilter = createAddHook_default(this, "filters");
+		this.removeAction = createRemoveHook_default(this, "actions");
+		this.removeFilter = createRemoveHook_default(this, "filters");
+		this.hasAction = createHasHook_default(this, "actions");
+		this.hasFilter = createHasHook_default(this, "filters");
+		this.removeAllActions = createRemoveHook_default(this, "actions", true);
+		this.removeAllFilters = createRemoveHook_default(this, "filters", true);
+		this.doAction = createRunHook_default(this, "actions", false, false);
+		this.doActionAsync = createRunHook_default(this, "actions", false, true);
+		this.applyFilters = createRunHook_default(this, "filters", true, false);
+		this.applyFiltersAsync = createRunHook_default(this, "filters", true, true);
+		this.currentAction = createCurrentHook_default(this, "actions");
+		this.currentFilter = createCurrentHook_default(this, "filters");
+		this.doingAction = createDoingHook_default(this, "actions");
+		this.doingFilter = createDoingHook_default(this, "filters");
+		this.didAction = createDidHook_default(this, "actions");
+		this.didFilter = createDidHook_default(this, "filters");
+	}
+};
+function createHooks() {
+	return new _Hooks();
+}
+var createHooks_default = createHooks;
+//#endregion
+//#region node_modules/@wordpress/hooks/build-module/index.mjs
+var defaultHooks = createHooks_default();
+var { addAction, addFilter, removeAction, removeFilter, hasAction, hasFilter, removeAllActions, removeAllFilters, doAction, doActionAsync, applyFilters, applyFiltersAsync, currentAction, currentFilter, doingAction, doingFilter, didAction, didFilter, actions, filters } = defaultHooks;
+//#endregion
+//#region node_modules/@wordpress/i18n/build-module/default-i18n.mjs
+var i18n = createI18n(void 0, void 0, defaultHooks);
+var getLocaleData = i18n.getLocaleData.bind(i18n);
+var setLocaleData = i18n.setLocaleData.bind(i18n);
+var resetLocaleData = i18n.resetLocaleData.bind(i18n);
+var subscribe = i18n.subscribe.bind(i18n);
+var __ = i18n.__.bind(i18n);
+var _x = i18n._x.bind(i18n);
+var _n = i18n._n.bind(i18n);
+var _nx = i18n._nx.bind(i18n);
+var isRTL = i18n.isRTL.bind(i18n);
+var hasTranslation = i18n.hasTranslation.bind(i18n);
+//#endregion
+export { _n as n, sprintf as r, __ as t };