You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1113 lines
32 KiB
1113 lines
32 KiB
this["wp"] = this["wp"] || {}; this["wp"]["i18n"] = |
|
/******/ (function(modules) { // webpackBootstrap |
|
/******/ // The module cache |
|
/******/ var installedModules = {}; |
|
/******/ |
|
/******/ // The require function |
|
/******/ function __webpack_require__(moduleId) { |
|
/******/ |
|
/******/ // Check if module is in cache |
|
/******/ if(installedModules[moduleId]) { |
|
/******/ return installedModules[moduleId].exports; |
|
/******/ } |
|
/******/ // Create a new module (and put it into the cache) |
|
/******/ var module = installedModules[moduleId] = { |
|
/******/ i: moduleId, |
|
/******/ l: false, |
|
/******/ exports: {} |
|
/******/ }; |
|
/******/ |
|
/******/ // Execute the module function |
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
|
/******/ |
|
/******/ // Flag the module as loaded |
|
/******/ module.l = true; |
|
/******/ |
|
/******/ // Return the exports of the module |
|
/******/ return module.exports; |
|
/******/ } |
|
/******/ |
|
/******/ |
|
/******/ // expose the modules object (__webpack_modules__) |
|
/******/ __webpack_require__.m = modules; |
|
/******/ |
|
/******/ // expose the module cache |
|
/******/ __webpack_require__.c = installedModules; |
|
/******/ |
|
/******/ // define getter function for harmony exports |
|
/******/ __webpack_require__.d = function(exports, name, getter) { |
|
/******/ if(!__webpack_require__.o(exports, name)) { |
|
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); |
|
/******/ } |
|
/******/ }; |
|
/******/ |
|
/******/ // 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 }); |
|
/******/ }; |
|
/******/ |
|
/******/ // create a fake namespace object |
|
/******/ // mode & 1: value is a module id, require it |
|
/******/ // mode & 2: merge all properties of value into the ns |
|
/******/ // mode & 4: return value when already ns object |
|
/******/ // mode & 8|1: behave like require |
|
/******/ __webpack_require__.t = function(value, mode) { |
|
/******/ if(mode & 1) value = __webpack_require__(value); |
|
/******/ if(mode & 8) return value; |
|
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; |
|
/******/ var ns = Object.create(null); |
|
/******/ __webpack_require__.r(ns); |
|
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); |
|
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); |
|
/******/ return ns; |
|
/******/ }; |
|
/******/ |
|
/******/ // getDefaultExport function for compatibility with non-harmony modules |
|
/******/ __webpack_require__.n = function(module) { |
|
/******/ var getter = module && module.__esModule ? |
|
/******/ function getDefault() { return module['default']; } : |
|
/******/ function getModuleExports() { return module; }; |
|
/******/ __webpack_require__.d(getter, 'a', getter); |
|
/******/ return getter; |
|
/******/ }; |
|
/******/ |
|
/******/ // Object.prototype.hasOwnProperty.call |
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; |
|
/******/ |
|
/******/ // __webpack_public_path__ |
|
/******/ __webpack_require__.p = ""; |
|
/******/ |
|
/******/ |
|
/******/ // Load entry module and return exports |
|
/******/ return __webpack_require__(__webpack_require__.s = 319); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ({ |
|
|
|
/***/ 125: |
|
/***/ (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, match, 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 (Array.isArray(parse_tree[i])) { |
|
match = parse_tree[i] // convenience purposes only |
|
if (match[2]) { // keyword argument |
|
arg = argv[cursor] |
|
for (k = 0; k < match[2].length; k++) { |
|
if (!arg.hasOwnProperty(match[2][k])) { |
|
throw new Error(sprintf('[sprintf] property "%s" does not exist', match[2][k])) |
|
} |
|
arg = arg[match[2][k]] |
|
} |
|
} |
|
else if (match[1]) { // positional argument (explicit) |
|
arg = argv[match[1]] |
|
} |
|
else { // positional argument (implicit) |
|
arg = argv[cursor++] |
|
} |
|
|
|
if (re.not_type.test(match[8]) && re.not_primitive.test(match[8]) && arg instanceof Function) { |
|
arg = arg() |
|
} |
|
|
|
if (re.numeric_arg.test(match[8]) && (typeof arg !== 'number' && isNaN(arg))) { |
|
throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg)) |
|
} |
|
|
|
if (re.number.test(match[8])) { |
|
is_positive = arg >= 0 |
|
} |
|
|
|
switch (match[8]) { |
|
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, match[6] ? parseInt(match[6]) : 0) |
|
break |
|
case 'e': |
|
arg = match[7] ? parseFloat(arg).toExponential(match[7]) : parseFloat(arg).toExponential() |
|
break |
|
case 'f': |
|
arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg) |
|
break |
|
case 'g': |
|
arg = match[7] ? String(Number(arg.toPrecision(match[7]))) : parseFloat(arg) |
|
break |
|
case 'o': |
|
arg = (parseInt(arg, 10) >>> 0).toString(8) |
|
break |
|
case 's': |
|
arg = String(arg) |
|
arg = (match[7] ? arg.substring(0, match[7]) : arg) |
|
break |
|
case 't': |
|
arg = String(!!arg) |
|
arg = (match[7] ? arg.substring(0, match[7]) : arg) |
|
break |
|
case 'T': |
|
arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase() |
|
arg = (match[7] ? arg.substring(0, match[7]) : arg) |
|
break |
|
case 'u': |
|
arg = parseInt(arg, 10) >>> 0 |
|
break |
|
case 'v': |
|
arg = arg.valueOf() |
|
arg = (match[7] ? arg.substring(0, match[7]) : 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(match[8])) { |
|
output += arg |
|
} |
|
else { |
|
if (re.number.test(match[8]) && (!is_positive || match[3])) { |
|
sign = is_positive ? '+' : '-' |
|
arg = arg.toString().replace(re.sign, '') |
|
} |
|
else { |
|
sign = '' |
|
} |
|
pad_character = match[4] ? match[4] === '0' ? '0' : match[4].charAt(1) : ' ' |
|
pad_length = match[6] - (sign + arg).length |
|
pad = match[6] ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : '' |
|
output += match[5] ? 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(match) |
|
} |
|
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 */ |
|
}() |
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 15: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); |
|
function _defineProperty(obj, key, value) { |
|
if (key in obj) { |
|
Object.defineProperty(obj, key, { |
|
value: value, |
|
enumerable: true, |
|
configurable: true, |
|
writable: true |
|
}); |
|
} else { |
|
obj[key] = value; |
|
} |
|
|
|
return obj; |
|
} |
|
|
|
/***/ }), |
|
|
|
/***/ 319: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
__webpack_require__.r(__webpack_exports__); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js |
|
var objectSpread = __webpack_require__(8); |
|
|
|
// 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_evaluate( postfix, variables ) { |
|
var stack = [], |
|
i, getOperatorResult, term, value; |
|
|
|
for ( i = 0; i < postfix.length; i++ ) { |
|
term = postfix[ i ]; |
|
|
|
getOperatorResult = OPERATORS[ term ]; |
|
if ( getOperatorResult ) { |
|
try { |
|
// Pop from stack by number of function arguments. |
|
value = getOperatorResult.apply( |
|
null, |
|
stack.splice( -1 * getOperatorResult.length ) |
|
); |
|
} 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 {Function} Compiled evaluator. |
|
*/ |
|
function compile( expression ) { |
|
var terms = postfix( expression ); |
|
|
|
return function( variables ) { |
|
return evaluate_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. |
|
* |
|
* @property {?string} contextDelimiter Joiner in string lookup with context. |
|
* @property {?Function} onMissingKey Callback to invoke when key missing. |
|
* |
|
* @type {Object} |
|
* |
|
* @typedef {TanninOptions} |
|
*/ |
|
|
|
/** |
|
* 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. |
|
* |
|
* @param {Object} data Jed-formatted locale data. |
|
* @param {TanninOptions} options Tannin options. |
|
*/ |
|
function Tannin( data, options ) { |
|
var key; |
|
|
|
this.data = data; |
|
this.pluralForms = {}; |
|
|
|
options = options || {}; |
|
this.options = {}; |
|
for ( key in DEFAULT_OPTIONS ) { |
|
this.options[ key ] = 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; |
|
|
|
if ( ! getPluralForm ) { |
|
config = this.data[ domain ][ '' ]; |
|
plural = getPluralExpression( |
|
config[ 'Plural-Forms' ] || |
|
config[ 'plural-forms' ] || |
|
config.plural_forms |
|
); |
|
|
|
getPluralForm = this.pluralForms[ domain ] = pluralForms( plural ); |
|
} |
|
|
|
return getPluralForm( n ); |
|
}; |
|
|
|
/** |
|
* Translate a string. |
|
* |
|
* @param {string} domain Translation domain. |
|
* @param {string} 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; |
|
}; |
|
|
|
// EXTERNAL MODULE: ./node_modules/memize/index.js |
|
var memize = __webpack_require__(41); |
|
var memize_default = /*#__PURE__*/__webpack_require__.n(memize); |
|
|
|
// EXTERNAL MODULE: ./node_modules/@wordpress/i18n/node_modules/sprintf-js/src/sprintf.js |
|
var sprintf = __webpack_require__(125); |
|
var sprintf_default = /*#__PURE__*/__webpack_require__.n(sprintf); |
|
|
|
// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/index.js |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setLocaleData", function() { return setLocaleData; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__", function() { return __; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_x", function() { return _x; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_n", function() { return _n; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "_nx", function() { return _nx; }); |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sprintf", function() { return build_module_sprintf; }); |
|
|
|
|
|
/** |
|
* External dependencies |
|
*/ |
|
|
|
|
|
|
|
/** |
|
* Default locale data to use for Tannin domain when not otherwise provided. |
|
* Assumes an English plural forms expression. |
|
* |
|
* @type {Object} |
|
*/ |
|
|
|
var DEFAULT_LOCALE_DATA = { |
|
'': { |
|
plural_forms: 'plural=(n!=1)' |
|
} |
|
}; |
|
/** |
|
* 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` |
|
*/ |
|
|
|
var logErrorOnce = memize_default()(console.error); // eslint-disable-line no-console |
|
|
|
/** |
|
* The underlying instance of Tannin to which exported functions interface. |
|
* |
|
* @type {Tannin} |
|
*/ |
|
|
|
var i18n = new Tannin({}); |
|
/** |
|
* 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 {?Object} data Locale data configuration. |
|
* @param {?string} domain Domain for which configuration applies. |
|
*/ |
|
|
|
function setLocaleData(data) { |
|
var domain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default'; |
|
i18n.data[domain] = Object(objectSpread["a" /* default */])({}, DEFAULT_LOCALE_DATA, i18n.data[domain], data); // Populate default domain configuration (supported locale date which omits |
|
// a plural forms expression). |
|
|
|
i18n.data[domain][''] = Object(objectSpread["a" /* default */])({}, DEFAULT_LOCALE_DATA[''], i18n.data[domain]['']); |
|
} |
|
/** |
|
* Wrapper for Tannin's `dcnpgettext`. Populates default locale data if not |
|
* otherwise previously assigned. |
|
* |
|
* @param {?string} domain Domain to retrieve the translated text. |
|
* @param {?string} 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. |
|
*/ |
|
|
|
function dcnpgettext() { |
|
var domain = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'default'; |
|
var context = arguments.length > 1 ? arguments[1] : undefined; |
|
var single = arguments.length > 2 ? arguments[2] : undefined; |
|
var plural = arguments.length > 3 ? arguments[3] : undefined; |
|
var number = arguments.length > 4 ? arguments[4] : undefined; |
|
|
|
if (!i18n.data[domain]) { |
|
setLocaleData(undefined, domain); |
|
} |
|
|
|
return i18n.dcnpgettext(domain, context, single, plural, number); |
|
} |
|
/** |
|
* 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. |
|
*/ |
|
|
|
|
|
function __(text, domain) { |
|
return dcnpgettext(domain, undefined, text); |
|
} |
|
/** |
|
* 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. |
|
*/ |
|
|
|
function _x(text, context, domain) { |
|
return dcnpgettext(domain, context, text); |
|
} |
|
/** |
|
* 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. |
|
*/ |
|
|
|
function _n(single, plural, number, domain) { |
|
return dcnpgettext(domain, undefined, single, plural, number); |
|
} |
|
/** |
|
* 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. |
|
*/ |
|
|
|
function _nx(single, plural, number, context, domain) { |
|
return dcnpgettext(domain, context, single, plural, number); |
|
} |
|
/** |
|
* 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 {string[]} ...args Arguments to apply to the format. |
|
* |
|
* @see http://www.diveintojavascript.com/projects/javascript-sprintf |
|
* |
|
* @return {string} The formatted string. |
|
*/ |
|
|
|
function build_module_sprintf(format) { |
|
try { |
|
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
|
args[_key - 1] = arguments[_key]; |
|
} |
|
|
|
return sprintf_default.a.sprintf.apply(sprintf_default.a, [format].concat(args)); |
|
} catch (error) { |
|
logErrorOnce('sprintf error: \n\n' + error.toString()); |
|
return format; |
|
} |
|
} |
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 41: |
|
/***/ (function(module, exports, __webpack_require__) { |
|
|
|
module.exports = function memize( fn, options ) { |
|
var size = 0, |
|
maxSize, head, tail; |
|
|
|
if ( options && options.maxSize ) { |
|
maxSize = options.maxSize; |
|
} |
|
|
|
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. |
|
node.prev.next = node.next; |
|
if ( node.next ) { |
|
node.next.prev = node.prev; |
|
} |
|
|
|
node.next = head; |
|
node.prev = null; |
|
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 === maxSize ) { |
|
tail = tail.prev; |
|
tail.next = null; |
|
} else { |
|
size++; |
|
} |
|
|
|
head = node; |
|
|
|
return node.val; |
|
} |
|
|
|
memoized.clear = function() { |
|
head = null; |
|
tail = null; |
|
size = 0; |
|
}; |
|
|
|
if ( false ) {} |
|
|
|
return memoized; |
|
}; |
|
|
|
|
|
/***/ }), |
|
|
|
/***/ 8: |
|
/***/ (function(module, __webpack_exports__, __webpack_require__) { |
|
|
|
"use strict"; |
|
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; }); |
|
/* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15); |
|
|
|
function _objectSpread(target) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
var source = arguments[i] != null ? arguments[i] : {}; |
|
var ownKeys = Object.keys(source); |
|
|
|
if (typeof Object.getOwnPropertySymbols === 'function') { |
|
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { |
|
return Object.getOwnPropertyDescriptor(source, sym).enumerable; |
|
})); |
|
} |
|
|
|
ownKeys.forEach(function (key) { |
|
Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]); |
|
}); |
|
} |
|
|
|
return target; |
|
} |
|
|
|
/***/ }) |
|
|
|
/******/ }); |