diff options
Diffstat (limited to 'wp-includes/js/dist/i18n.js')
| -rw-r--r-- | wp-includes/js/dist/i18n.js | 1609 |
1 files changed, 1609 insertions, 0 deletions
diff --git a/wp-includes/js/dist/i18n.js b/wp-includes/js/dist/i18n.js new file mode 100644 index 0000000..142072d --- /dev/null +++ b/wp-includes/js/dist/i18n.js @@ -0,0 +1,1609 @@ +/******/ (function() { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 124: +/***/ (function(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 */ +/******/ !function() { +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function() { return module['default']; } : +/******/ function() { return module; }; +/******/ __webpack_require__.d(getter, { a: getter }); +/******/ return getter; +/******/ }; +/******/ }(); +/******/ +/******/ /* webpack/runtime/define property getters */ +/******/ !function() { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = function(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 */ +/******/ !function() { +/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); } +/******/ }(); +/******/ +/******/ /* webpack/runtime/make namespace object */ +/******/ !function() { +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(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. +!function() { +"use strict"; +// ESM COMPAT FLAG +__webpack_require__.r(__webpack_exports__); + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + __: function() { return /* reexport */ __; }, + _n: function() { return /* reexport */ _n; }, + _nx: function() { return /* reexport */ _nx; }, + _x: function() { return /* reexport */ _x; }, + createI18n: function() { return /* reexport */ createI18n; }, + defaultI18n: function() { return /* reexport */ default_i18n; }, + getLocaleData: function() { return /* reexport */ getLocaleData; }, + hasTranslation: function() { return /* reexport */ hasTranslation; }, + isRTL: function() { return /* reexport */ isRTL; }, + resetLocaleData: function() { return /* reexport */ resetLocaleData; }, + setLocaleData: function() { return /* reexport */ setLocaleData; }, + sprintf: function() { return /* reexport */ sprintf_sprintf; }, + subscribe: function() { return /* 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__(124); +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"] +var 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 */ var 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__; +/******/ })() +;
\ No newline at end of file |