vendor: 13,222 bytes, lines 1-332
1this["wp"] = this["wp"] || {}; this["wp"]["i18n"] = 2/******/ (function(modules) { // webpackBootstrap 3/******/ // The module cache 4/******/ var installedModules = {}; 5/******/ 6/******/ // The require function 7/******/ function __webpack_require__(moduleId) { 8/******/ 9/******/ // Check if module is in cache 10/******/ if(installedModules[moduleId]) { 11/******/ return installedModules[moduleId].exports; 12/******/ } 13/******/ // Create a new module (and put it into the cache) 14/******/ var module = installedModules[moduleId] = { 15/******/ i: moduleId, 16/******/ l: false, 17/******/ exports: {} 18/******/ }; 19/******/ 20/******/ // Execute the module function 21/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 22/******/ 23/******/ // Flag the module as loaded 24/******/ module.l = true; 25/******/ 26/******/ // Return the exports of the module 27/******/ return module.exports; 28/******/ } 29/******/ 30/******/ 31/******/ // expose the modules object (__webpack_modules__) 32/******/ __webpack_require__.m = modules; 33/******/ 34/******/ // expose the module cache 35/******/ __webpack_require__.c = installedModules; 36/******/ 37/******/ // define getter function for harmony exports 38/******/ __webpack_require__.d = function(exports, name, getter) { 39/******/ if(!__webpack_require__.o(exports, name)) { 40/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); 41/******/ } 42/******/ }; 43/******/ 44/******/ // define __esModule on exports 45/******/ __webpack_require__.r = function(exports) { 46/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 47/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 48/******/ } 49/******/ Object.defineProperty(exports, '__esModule', { value: true }); 50/******/ }; 51/******/ 52/******/ // create a fake namespace object 53/******/ // mode & 1: value is a module id, require it 54/******/ // mode & 2: merge all properties of value into the ns 55/******/ // mode & 4: return value when already ns object 56/******/ // mode & 8|1: behave like require 57/******/ __webpack_require__.t = function(value, mode) { 58/******/ if(mode & 1) value = __webpack_require__(value); 59/******/ if(mode & 8) return value; 60/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; 61/******/ var ns = Object.create(null); 62/******/ __webpack_require__.r(ns); 63/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); 64/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); 65/******/ return ns; 66/******/ }; 67/******/ 68/******/ // getDefaultExport function for compatibility with non-harmony modules 69/******/ __webpack_require__.n = function(module) { 70/******/ var getter = module && module.__esModule ? 71/******/ function getDefault() { return module['default']; } : 72/******/ function getModuleExports() { return module; }; 73/******/ __webpack_require__.d(getter, 'a', getter); 74/******/ return getter; 75/******/ }; 76/******/ 77/******/ // Object.prototype.hasOwnProperty.call 78/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 79/******/ 80/******/ // __webpack_public_path__ 81/******/ __webpack_require__.p = ""; 82/******/ 83/******/ 84/******/ // Load entry module and return exports 85/******/ return __webpack_require__(__webpack_require__.s = 452); 86/******/ }) 87/************************************************************************/ 88/******/ ({ 89 90/***/ 197: 91/***/ (function(module, exports, __webpack_require__) { 92 93var __WEBPACK_AMD_DEFINE_RESULT__;/* global window, exports, define */ 94 95!function() { 96 'use strict' 97 98 var re = { 99 not_string: /[^s]/, 100 not_bool: /[^t]/, 101 not_type: /[^T]/, 102 not_primitive: /[^v]/, 103 number: /[diefg]/, 104 numeric_arg: /[bcdiefguxX]/, 105 json: /[j]/, 106 not_json: /[^j]/, 107 text: /^[^\x25]+/, 108 modulo: /^\x25{2}/, 109 placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/, 110 key: /^([a-z_][a-z_\d]*)/i, 111 key_access: /^\.([a-z_][a-z_\d]*)/i, 112 index_access: /^\[(\d+)\]/, 113 sign: /^[+-]/ 114 } 115 116 function sprintf(key) { 117 // `arguments` is not an array, but should be fine for this call 118 return sprintf_format(sprintf_parse(key), arguments) 119 } 120 121 function vsprintf(fmt, argv) { 122 return sprintf.apply(null, [fmt].concat(argv || [])) 123 } 124 125 function sprintf_format(parse_tree, argv) { 126 var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign 127 for (i = 0; i < tree_length; i++) { 128 if (typeof parse_tree[i] === 'string') { 129 output += parse_tree[i] 130 } 131 else if (typeof parse_tree[i] === 'object') { 132 ph = parse_tree[i] // convenience purposes only 133 if (ph.keys) { // keyword argument 134 arg = argv[cursor] 135 for (k = 0; k < ph.keys.length; k++) { 136 if (arg == undefined) { 137 throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1])) 138 } 139 arg = arg[ph.keys[k]] 140 } 141 } 142 else if (ph.param_no) { // positional argument (explicit) 143 arg = argv[ph.param_no] 144 } 145 else { // positional argument (implicit) 146 arg = argv[cursor++] 147 } 148 149 if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) { 150 arg = arg() 151 } 152 153 if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) { 154 throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg)) 155 } 156 157 if (re.number.test(ph.type)) { 158 is_positive = arg >= 0 159 } 160 161 switch (ph.type) { 162 case 'b': 163 arg = parseInt(arg, 10).toString(2) 164 break 165 case 'c': 166 arg = String.fromCharCode(parseInt(arg, 10)) 167 break 168 case 'd': 169 case 'i': 170 arg = parseInt(arg, 10) 171 break 172 case 'j': 173 arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0) 174 break 175 case 'e': 176 arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential() 177 break 178 case 'f': 179 arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg) 180 break 181 case 'g': 182 arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg) 183 break 184 case 'o': 185 arg = (parseInt(arg, 10) >>> 0).toString(8) 186 break 187 case 's': 188 arg = String(arg) 189 arg = (ph.precision ? arg.substring(0, ph.precision) : arg) 190 break 191 case 't': 192 arg = String(!!arg) 193 arg = (ph.precision ? arg.substring(0, ph.precision) : arg) 194 break 195 case 'T': 196 arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase() 197 arg = (ph.precision ? arg.substring(0, ph.precision) : arg) 198 break 199 case 'u': 200 arg = parseInt(arg, 10) >>> 0 201 break 202 case 'v': 203 arg = arg.valueOf() 204 arg = (ph.precision ? arg.substring(0, ph.precision) : arg) 205 break 206 case 'x': 207 arg = (parseInt(arg, 10) >>> 0).toString(16) 208 break 209 case 'X': 210 arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase() 211 break 212 } 213 if (re.json.test(ph.type)) { 214 output += arg 215 } 216 else { 217 if (re.number.test(ph.type) && (!is_positive || ph.sign)) { 218 sign = is_positive ? '+' : '-' 219 arg = arg.toString().replace(re.sign, '') 220 } 221 else { 222 sign = '' 223 } 224 pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' ' 225 pad_length = ph.width - (sign + arg).length 226 pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : '' 227 output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg) 228 } 229 } 230 } 231 return output 232 } 233 234 var sprintf_cache = Object.create(null) 235 236 function sprintf_parse(fmt) { 237 if (sprintf_cache[fmt]) { 238 return sprintf_cache[fmt] 239 } 240 241 var _fmt = fmt, match, parse_tree = [], arg_names = 0 242 while (_fmt) { 243 if ((match = re.text.exec(_fmt)) !== null) { 244 parse_tree.push(match[0]) 245 } 246 else if ((match = re.modulo.exec(_fmt)) !== null) { 247 parse_tree.push('%') 248 } 249 else if ((match = re.placeholder.exec(_fmt)) !== null) { 250 if (match[2]) { 251 arg_names |= 1 252 var field_list = [], replacement_field = match[2], field_match = [] 253 if ((field_match = re.key.exec(replacement_field)) !== null) { 254 field_list.push(field_match[1]) 255 while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') { 256 if ((field_match = re.key_access.exec(replacement_field)) !== null) { 257 field_list.push(field_match[1]) 258 } 259 else if ((field_match = re.index_access.exec(replacement_field)) !== null) { 260 field_list.push(field_match[1]) 261 } 262 else { 263 throw new SyntaxError('[sprintf] failed to parse named argument key') 264 } 265 } 266 } 267 else { 268 throw new SyntaxError('[sprintf] failed to parse named argument key') 269 } 270 match[2] = field_list 271 } 272 else { 273 arg_names |= 2 274 } 275 if (arg_names === 3) { 276 throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported') 277 } 278 279 parse_tree.push( 280 { 281 placeholder: match[0], 282 param_no: match[1], 283 keys: match[2], 284 sign: match[3], 285 pad_char: match[4], 286 align: match[5], 287 width: match[6], 288 precision: match[7], 289 type: match[8] 290 } 291 ) 292 } 293 else { 294 throw new SyntaxError('[sprintf] unexpected placeholder') 295 } 296 _fmt = _fmt.substring(match[0].length) 297 } 298 return sprintf_cache[fmt] = parse_tree 299 } 300 301 /** 302 * export to either browser or node.js 303 */ 304 /* eslint-disable quote-props */ 305 if (true) { 306 exports['sprintf'] = sprintf 307 exports['vsprintf'] = vsprintf 308 } 309 if (typeof window !== 'undefined') { 310 window['sprintf'] = sprintf 311 window['vsprintf'] = vsprintf 312 313 if (true) { 314 !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { 315 return { 316 'sprintf': sprintf, 317 'vsprintf': vsprintf 318 } 319 }).call(exports, __webpack_require__, exports, module), 320 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) 321 } 322 } 323 /* eslint-enable quote-props */ 324}(); // eslint-disable-line 325 326 327/***/ }), 328 329/***/ 452: 330/***/ (function(module, __webpack_exports__, __webpack_require__) { 331 332"use strict";
333// ESM COMPAT FLAG 334__webpack_require__.r(__webpack_exports__); 335 336// EXPORTS 337__webpack_require__.d(__webpack_exports__, "sprintf", function() { return /* reexport */ sprintf_sprintf; }); 338__webpack_require__.d(__webpack_exports__, "createI18n", function() { return /* reexport */ create_i18n_createI18n; }); 339__webpack_require__.d(__webpack_exports__, "setLocaleData", function() { return /* reexport */ default_i18n_setLocaleData; }); 340__webpack_require__.d(__webpack_exports__, "__", function() { return /* reexport */ default_i18n_; }); 341__webpack_require__.d(__webpack_exports__, "_x", function() { return /* reexport */ default_i18n_x; }); 342__webpack_require__.d(__webpack_exports__, "_n", function() { return /* reexport */ default_i18n_n; }); 343__webpack_require__.d(__webpack_exports__, "_nx", function() { return /* reexport */ default_i18n_nx; }); 344__webpack_require__.d(__webpack_exports__, "isRTL", function() { return /* reexport */ default_i18n_isRTL; }); 345 346// EXTERNAL MODULE: ./node_modules/memize/index.js 347var memize = __webpack_require__(60); 348var memize_default = /*#__PURE__*/__webpack_require__.n(memize); 349 350// EXTERNAL MODULE: ./node_modules/sprintf-js/src/sprintf.js 351var sprintf = __webpack_require__(197); 352var sprintf_default = /*#__PURE__*/__webpack_require__.n(sprintf); 353 354// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/sprintf.js 355/** 356 * External dependencies 357 */ 358 359 360/** 361 * Log to console, once per message; or more precisely, per referentially equal 362 * argument set. Because Jed throws errors, we log these to the console instead 363 * to avoid crashing the application. 364 * 365 * @param {...*} args Arguments to pass to `console.error` 366 */ 367 368var logErrorOnce = memize_default()(console.error); // eslint-disable-line no-console 369 370/** 371 * Returns a formatted string. If an error occurs in applying the format, the 372 * original format string is returned. 373 * 374 * @param {string} format The format of the string to generate. 375 * @param {...*} args Arguments to apply to the format. 376 * 377 * @see http://www.diveintojavascript.com/projects/javascript-sprintf 378 * 379 * @return {string} The formatted string. 380 */ 381 382function sprintf_sprintf(format) { 383 try { 384 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 385 args[_key - 1] = arguments[_key]; 386 } 387 388 return sprintf_default.a.sprintf.apply(sprintf_default.a, [format].concat(args)); 389 } catch (error) { 390 logErrorOnce('sprintf error: \n\n' + error.toString()); 391 return format; 392 } 393} 394 395// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js 396var defineProperty = __webpack_require__(5); 397 398// CONCATENATED MODULE: ./node_modules/@tannin/postfix/index.js 399var PRECEDENCE, OPENERS, TERMINATORS, PATTERN; 400 401/** 402 * Operator precedence mapping. 403 * 404 * @type {Object} 405 */ 406PRECEDENCE = { 407 '(': 9, 408 '!': 8, 409 '*': 7, 410 '/': 7, 411 '%': 7,
412 '+': 6, 413 '-': 6, 414 '<': 5, 415 '<=': 5, 416 '>': 5, 417 '>=': 5, 418 '==': 4, 419 '!=': 4, 420 '&&': 3, 421 '||': 2, 422 '?': 1, 423 '?:': 1, 424}; 425 426/** 427 * Characters which signal pair opening, to be terminated by terminators. 428 * 429 * @type {string[]} 430 */ 431OPENERS = [ '(', '?' ]; 432 433/** 434 * Characters which signal pair termination, the value an array with the 435 * opener as its first member. The second member is an optional operator 436 * replacement to push to the stack. 437 * 438 * @type {string[]} 439 */ 440TERMINATORS = { 441 ')': [ '(' ], 442 ':': [ '?', '?:' ], 443}; 444 445/** 446 * Pattern matching operators and openers. 447 * 448 * @type {RegExp} 449 */ 450PATTERN = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/; 451 452/** 453 * Given a C expression, returns the equivalent postfix (Reverse Polish) 454 * notation terms as an array. 455 * 456 * If a postfix string is desired, simply `.join( ' ' )` the result. 457 * 458 * @example 459 * 460 * ```js 461 * import postfix from '@tannin/postfix'; 462 * 463 * postfix( 'n > 1' ); 464 * // â [ 'n', '1', '>' ] 465 * ``` 466 * 467 * @param {string} expression C expression. 468 * 469 * @return {string[]} Postfix terms. 470 */ 471function postfix( expression ) { 472 var terms = [], 473 stack = [], 474 match, operator, term, element; 475 476 while ( ( match = expression.match( PATTERN ) ) ) { 477 operator = match[ 0 ]; 478 479 // Term is the string preceding the operator match. It may contain 480 // whitespace, and may be empty (if operator is at beginning). 481 term = expression.substr( 0, match.index ).trim(); 482 if ( term ) { 483 terms.push( term ); 484 } 485 486 while ( ( element = stack.pop() ) ) { 487 if ( TERMINATORS[ operator ] ) { 488 if ( TERMINATORS[ operator ][ 0 ] === element ) { 489 // Substitution works here under assumption that because 490 // the assigned operator will no longer be a terminator, it 491 // will be pushed to the stack during the condition below. 492 operator = TERMINATORS[ operator ][ 1 ] || operator; 493 break; 494 } 495 } else if ( OPENERS.indexOf( element ) >= 0 || PRECEDENCE[ element ] < PRECEDENCE[ operator ] ) { 496 // Push to stack if either an opener or when pop reveals an 497 // element of lower precedence. 498 stack.push( element ); 499 break; 500 } 501 502 // For each popped from stack, push to terms. 503 terms.push( element ); 504 } 505 506 if ( ! TERMINATORS[ operator ] ) { 507 stack.push( operator ); 508 } 509 510 // Slice matched fragment from expression to continue match. 511 expression = expression.substr( match.index + operator.length ); 512 } 513 514 // Push remainder of operand, if exists, to terms. 515 expression = expression.trim(); 516 if ( expression ) { 517 terms.push( expression ); 518 } 519 520 // Pop remaining items from stack into terms. 521 return terms.concat( stack.reverse() ); 522} 523 524// CONCATENATED MODULE: ./node_modules/@tannin/evaluate/index.js 525/** 526 * Operator callback functions. 527 * 528 * @type {Object} 529 */ 530var OPERATORS = { 531 '!': function( a ) { 532 return ! a; 533 }, 534 '*': function( a, b ) { 535 return a * b; 536 }, 537 '/': function( a, b ) { 538 return a / b; 539 }, 540 '%': function( a, b ) { 541 return a % b; 542 }, 543 '+': function( a, b ) { 544 return a + b; 545 }, 546 '-': function( a, b ) { 547 return a - b; 548 }, 549 '<': function( a, b ) { 550 return a < b; 551 }, 552 '<=': function( a, b ) { 553 return a <= b; 554 }, 555 '>': function( a, b ) { 556 return a > b; 557 }, 558 '>=': function( a, b ) { 559 return a >= b; 560 }, 561 '==': function( a, b ) { 562 return a === b; 563 }, 564 '!=': function( a, b ) { 565 return a !== b; 566 }, 567 '&&': function( a, b ) { 568 return a && b; 569 }, 570 '||': function( a, b ) { 571 return a || b; 572 }, 573 '?:': function( a, b, c ) { 574 if ( a ) { 575 throw b; 576 } 577 578 return c; 579 }, 580}; 581 582/** 583 * Given an array of postfix terms and operand variables, returns the result of 584 * the postfix evaluation. 585 * 586 * @example 587 * 588 * ```js 589 * import evaluate from '@tannin/evaluate'; 590 * 591 * // 3 + 4 * 5 / 6 â '3 4 5 * 6 / +' 592 * const terms = [ '3', '4', '5', '*', '6', '/', '+' ]; 593 * 594 * evaluate( terms, {} ); 595 * // â 6.333333333333334 596 * ``` 597 * 598 * @param {string[]} postfix Postfix terms. 599 * @param {Object} variables Operand variables. 600 * 601 * @return {*} Result of evaluation. 602 */ 603function evaluate_evaluate( postfix, variables ) { 604 var stack = [], 605 i, j, args, getOperatorResult, term, value; 606 607 for ( i = 0; i < postfix.length; i++ ) { 608 term = postfix[ i ]; 609 610 getOperatorResult = OPERATORS[ term ]; 611 if ( getOperatorResult ) { 612 // Pop from stack by number of function arguments. 613 j = getOperatorResult.length; 614 args = Array( j ); 615 while ( j-- ) { 616 args[ j ] = stack.pop(); 617 } 618 619 try { 620 value = getOperatorResult.apply( null, args ); 621 } catch ( earlyReturn ) { 622 return earlyReturn; 623 } 624 } else if ( variables.hasOwnProperty( term ) ) { 625 value = variables[ term ]; 626 } else { 627 value = +term; 628 } 629 630 stack.push( value ); 631 } 632 633 return stack[ 0 ]; 634} 635 636// CONCATENATED MODULE: ./node_modules/@tannin/compile/index.js 637 638 639 640/** 641 * Given a C expression, returns a function which can be called to evaluate its 642 * result. 643 * 644 * @example 645 * 646 * ```js 647 * import compile from '@tannin/compile'; 648 * 649 * const evaluate = compile( 'n > 1' ); 650 * 651 * evaluate( { n: 2 } ); 652 * // â true 653 * ``` 654 * 655 * @param {string} expression C expression. 656 * 657 * @return {(variables?:{[variable:string]:*})=>*} Compiled evaluator. 658 */ 659function compile( expression ) { 660 var terms = postfix( expression ); 661 662 return function( variables ) { 663 return evaluate_evaluate( terms, variables ); 664 }; 665} 666 667// CONCATENATED MODULE: ./node_modules/@tannin/plural-forms/index.js 668 669 670/** 671 * Given a C expression, returns a function which, when called with a value, 672 * evaluates the result with the value assumed to be the "n" variable of the 673 * expression. The result will be coerced to its numeric equivalent. 674 * 675 * @param {string} expression C expression. 676 * 677 * @return {Function} Evaluator function. 678 */ 679function pluralForms( expression ) { 680 var evaluate = compile( expression ); 681 682 return function( n ) { 683 return +evaluate( { n: n } ); 684 }; 685} 686 687// CONCATENATED MODULE: ./node_modules/tannin/index.js 688 689 690/** 691 * Tannin constructor options. 692 * 693 * @typedef {Object} TanninOptions 694 * 695 * @property {string} [contextDelimiter] Joiner in string lookup with context. 696 * @property {Function} [onMissingKey] Callback to invoke when key missing. 697 */ 698 699/** 700 * Domain metadata. 701 * 702 * @typedef {Object} TanninDomainMetadata 703 * 704 * @property {string} [domain] Domain name. 705 * @property {string} [lang] Language code. 706 * @property {(string|Function)} [plural_forms] Plural forms expression or 707 * function evaluator. 708 */ 709 710/** 711 * Domain translation pair respectively representing the singular and plural 712 * translation. 713 * 714 * @typedef {[string,string]} TanninTranslation 715 */ 716 717/** 718 * Locale data domain. The key is used as reference for lookup, the value an 719 * array of two string entries respectively representing the singular and plural 720 * translation. 721 * 722 * @typedef {{[key:string]:TanninDomainMetadata|TanninTranslation,'':TanninDomainMetadata|TanninTranslation}} TanninLocaleDomain 723 */ 724 725/** 726 * Jed-formatted locale data. 727 * 728 * @see http://messageformat.github.io/Jed/ 729 * 730 * @typedef {{[domain:string]:TanninLocaleDomain}} TanninLocaleData 731 */ 732 733/** 734 * Default Tannin constructor options. 735 * 736 * @type {TanninOptions} 737 */ 738var DEFAULT_OPTIONS = { 739 contextDelimiter: '\u0004', 740 onMissingKey: null, 741}; 742 743/** 744 * Given a specific locale data's config `plural_forms` value, returns the 745 * expression. 746 * 747 * @example 748 * 749 * ``` 750 * getPluralExpression( 'nplurals=2; plural=(n != 1);' ) === '(n != 1)' 751 * ``` 752 * 753 * @param {string} pf Locale data plural forms. 754 * 755 * @return {string} Plural forms expression. 756 */ 757function getPluralExpression( pf ) { 758 var parts, i, part; 759 760 parts = pf.split( ';' ); 761 762 for ( i = 0; i < parts.length; i++ ) { 763 part = parts[ i ].trim(); 764 if ( part.indexOf( 'plural=' ) === 0 ) { 765 return part.substr( 7 ); 766 } 767 } 768} 769 770/** 771 * Tannin constructor. 772 * 773 * @class 774 * 775 * @param {TanninLocaleData} data Jed-formatted locale data. 776 * @param {TanninOptions} [options] Tannin options. 777 */ 778function Tannin( data, options ) { 779 var key; 780 781 /** 782 * Jed-formatted locale data. 783 * 784 * @name Tannin#data 785 * @type {TanninLocaleData} 786 */ 787 this.data = data; 788 789 /** 790 * Plural forms function cache, keyed by plural forms string. 791 * 792 * @name Tannin#pluralForms 793 * @type {Object<string,Function>} 794 */ 795 this.pluralForms = {}; 796 797 /** 798 * Effective options for instance, including defaults. 799 * 800 * @name Tannin#options 801 * @type {TanninOptions} 802 */ 803 this.options = {}; 804 805 for ( key in DEFAULT_OPTIONS ) { 806 this.options[ key ] = options !== undefined && key in options 807 ? options[ key ] 808 : DEFAULT_OPTIONS[ key ]; 809 } 810} 811 812/** 813 * Returns the plural form index for the given domain and value. 814 * 815 * @param {string} domain Domain on which to calculate plural form. 816 * @param {number} n Value for which plural form is to be calculated. 817 * 818 * @return {number} Plural form index. 819 */ 820Tannin.prototype.getPluralForm = function( domain, n ) { 821 var getPluralForm = this.pluralForms[ domain ], 822 config, plural, pf; 823 824 if ( ! getPluralForm ) { 825 config = this.data[ domain ][ '' ]; 826 827 pf = ( 828 config[ 'Plural-Forms' ] || 829 config[ 'plural-forms' ] || 830 // Ignore reason: As known, there's no way to document the empty 831 // string property on a key to guarantee this as metadata. 832 // @ts-ignore 833 config.plural_forms 834 ); 835 836 if ( typeof pf !== 'function' ) { 837 plural = getPluralExpression( 838 config[ 'Plural-Forms' ] || 839 config[ 'plural-forms' ] || 840 // Ignore reason: As known, there's no way to document the empty 841 // string property on a key to guarantee this as metadata. 842 // @ts-ignore 843 config.plural_forms 844 ); 845 846 pf = pluralForms( plural ); 847 } 848 849 getPluralForm = this.pluralForms[ domain ] = pf; 850 } 851 852 return getPluralForm( n ); 853}; 854 855/** 856 * Translate a string. 857 * 858 * @param {string} domain Translation domain. 859 * @param {string|void} context Context distinguishing terms of the same name. 860 * @param {string} singular Primary key for translation lookup. 861 * @param {string=} plural Fallback value used for non-zero plural 862 * form index. 863 * @param {number=} n Value to use in calculating plural form. 864 * 865 * @return {string} Translated string. 866 */ 867Tannin.prototype.dcnpgettext = function( domain, context, singular, plural, n ) { 868 var index, key, entry; 869 870 if ( n === undefined ) { 871 // Default to singular. 872 index = 0; 873 } else { 874 // Find index by evaluating plural form for value. 875 index = this.getPluralForm( domain, n ); 876 } 877 878 key = singular; 879 880 // If provided, context is prepended to key with delimiter. 881 if ( context ) { 882 key = context + this.options.contextDelimiter + singular; 883 } 884 885 entry = this.data[ domain ][ key ]; 886
887 // Verify not only that entry exists, but that the intended index is within 888 // range and non-empty. 889 if ( entry && entry[ index ] ) { 890 return entry[ index ]; 891 } 892 893 if ( this.options.onMissingKey ) { 894 this.options.onMissingKey( singular, domain ); 895 } 896 897 // If entry not found, fall back to singular vs. plural with zero index 898 // representing the singular value. 899 return index === 0 ? singular : plural; 900}; 901 902// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/create-i18n.js 903 904 905function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } 906 907function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { Object(defineProperty["a" /* default */])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } 908 909/** 910 * External dependencies 911 */ 912 913/** 914 * @typedef {Record<string,any>} LocaleData 915 */ 916 917/** 918 * Default locale data to use for Tannin domain when not otherwise provided. 919 * Assumes an English plural forms expression. 920 * 921 * @type {LocaleData} 922 */ 923 924var DEFAULT_LOCALE_DATA = { 925 '': { 926 /** @param {number} n */ 927 plural_forms: function plural_forms(n) { 928 return n === 1 ? 0 : 1; 929 } 930 } 931}; 932/** 933 * An i18n instance 934 * 935 * @typedef {Object} I18n 936 * @property {Function} setLocaleData Merges locale data into the Tannin instance by domain. Accepts data in a 937 * Jed-formatted JSON object shape. 938 * @property {Function} __ Retrieve the translation of text. 939 * @property {Function} _x Retrieve translated string with gettext context. 940 * @property {Function} _n Translates and retrieves the singular or plural form based on the supplied 941 * number. 942 * @property {Function} _nx Translates and retrieves the singular or plural form based on the supplied 943 * number, with gettext context. 944 * @property {Function} isRTL Check if current locale is RTL. 945 */ 946 947/** 948 * Create an i18n instance 949 * 950 * @param {LocaleData} [initialData] Locale data configuration. 951 * @param {string} [initialDomain] Domain for which configuration applies. 952 * @return {I18n} I18n instance 953 */ 954 955var create_i18n_createI18n = function createI18n(initialData, initialDomain) { 956 /** 957 * The underlying instance of Tannin to which exported functions interface. 958 * 959 * @type {Tannin} 960 */ 961 var tannin = new Tannin({}); 962 /** 963 * Merges locale data into the Tannin instance by domain. Accepts data in a 964 * Jed-formatted JSON object shape. 965 * 966 * @see http://messageformat.github.io/Jed/ 967 * 968 * @param {LocaleData} [data] Locale data configuration. 969 * @param {string} [domain] Domain for which configuration applies. 970 */ 971 972 var setLocaleData = function setLocaleData(data) { 973 var domain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default'; 974 tannin.data[domain] = _objectSpread({}, DEFAULT_LOCALE_DATA, {}, tannin.data[domain], {}, data); // Populate default domain configuration (supported locale date which omits 975 // a plural forms expression). 976 977 tannin.data[domain][''] = _objectSpread({}, DEFAULT_LOCALE_DATA[''], {}, tannin.data[domain]['']); 978 }; 979 /** 980 * Wrapper for Tannin's `dcnpgettext`. Populates default locale data if not 981 * otherwise previously assigned. 982 * 983 * @param {string|undefined} domain Domain to retrieve the translated text. 984 * @param {string|undefined} context Context information for the translators. 985 * @param {string} single Text to translate if non-plural. Used as 986 * fallback return value on a caught error. 987 * @param {string} [plural] The text to be used if the number is 988 * plural. 989 * @param {number} [number] The number to compare against to use 990 * either the singular or plural form. 991 * 992 * @return {string} The translated string. 993 */ 994 995 996 var dcnpgettext = function dcnpgettext() { 997 var domain = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'default'; 998 var context = arguments.length > 1 ? arguments[1] : undefined; 999 var single = arguments.length > 2 ? arguments[2] : undefined; 1000 var plural = arguments.length > 3 ? arguments[3] : undefined; 1001 var number = arguments.length > 4 ? arguments[4] : undefined; 1002 1003 if (!tannin.data[domain]) { 1004 setLocaleData(undefined, domain); 1005 } 1006 1007 return tannin.dcnpgettext(domain, context, single, plural, number); 1008 }; 1009 /** 1010 * Retrieve the translation of text. 1011 * 1012 * @see https://developer.wordpress.org/reference/functions/__/ 1013 * 1014 * @param {string} text Text to translate. 1015 * @param {string} [domain] Domain to retrieve the translated text. 1016 * 1017 * @return {string} Translated text. 1018 */ 1019 1020 1021 var __ = function __(text, domain) { 1022 return dcnpgettext(domain, undefined, text); 1023 }; 1024 /** 1025 * Retrieve translated string with gettext context. 1026 * 1027 * @see https://developer.wordpress.org/reference/functions/_x/ 1028 * 1029 * @param {string} text Text to translate. 1030 * @param {string} context Context information for the translators. 1031 * @param {string} [domain] Domain to retrieve the translated text. 1032 * 1033 * @return {string} Translated context string without pipe. 1034 */ 1035 1036 1037 var _x = function _x(text, context, domain) { 1038 return dcnpgettext(domain, context, text); 1039 }; 1040 /** 1041 * Translates and retrieves the singular or plural form based on the supplied 1042 * number. 1043 * 1044 * @see https://developer.wordpress.org/reference/functions/_n/ 1045 * 1046 * @param {string} single The text to be used if the number is singular. 1047 * @param {string} plural The text to be used if the number is plural. 1048 * @param {number} number The number to compare against to use either the 1049 * singular or plural form. 1050 * @param {string} [domain] Domain to retrieve the translated text. 1051 * 1052 * @return {string} The translated singular or plural form. 1053 */ 1054 1055 1056 var _n = function _n(single, plural, number, domain) { 1057 return dcnpgettext(domain, undefined, single, plural, number); 1058 }; 1059 /** 1060 * Translates and retrieves the singular or plural form based on the supplied 1061 * number, with gettext context. 1062 * 1063 * @see https://developer.wordpress.org/reference/functions/_nx/ 1064 * 1065 * @param {string} single The text to be used if the number is singular. 1066 * @param {string} plural The text to be used if the number is plural. 1067 * @param {number} number The number to compare against to use either the 1068 * singular or plural form. 1069 * @param {string} context Context information for the translators. 1070 * @param {string} [domain] Domain to retrieve the translated text. 1071 * 1072 * @return {string} The translated singular or plural form. 1073 */ 1074 1075
1076 var _nx = function _nx(single, plural, number, context, domain) { 1077 return dcnpgettext(domain, context, single, plural, number); 1078 }; 1079 /** 1080 * Check if current locale is RTL. 1081 * 1082 * **RTL (Right To Left)** is a locale property indicating that text is written from right to left. 1083 * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common 1084 * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages, 1085 * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`). 1086 * 1087 * @return {boolean} Whether locale is RTL. 1088 */ 1089 1090 1091 var isRTL = function isRTL() { 1092 return 'rtl' === _x('ltr', 'text direction'); 1093 }; 1094 1095 if (initialData) { 1096 setLocaleData(initialData, initialDomain); 1097 } 1098 1099 return { 1100 setLocaleData: setLocaleData, 1101 __: __, 1102 _x: _x, 1103 _n: _n, 1104 _nx: _nx, 1105 isRTL: isRTL 1106 }; 1107}; 1108 1109// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/default-i18n.js 1110/** 1111 * Internal dependencies 1112 */ 1113 1114var i18n = create_i18n_createI18n(); 1115/* 1116 * Comments in this file are duplicated from ./i18n due to 1117 * https://github.com/WordPress/gutenberg/pull/20318#issuecomment-590837722 1118 */ 1119 1120/** 1121 * @typedef {import('./create-i18n').LocaleData} LocaleData 1122 */ 1123 1124/** 1125 * Merges locale data into the Tannin instance by domain. Accepts data in a 1126 * Jed-formatted JSON object shape. 1127 * 1128 * @see http://messageformat.github.io/Jed/ 1129 * 1130 * @param {LocaleData} [data] Locale data configuration. 1131 * @param {string} [domain] Domain for which configuration applies. 1132 */ 1133 1134var default_i18n_setLocaleData = i18n.setLocaleData.bind(i18n); 1135/** 1136 * Retrieve the translation of text. 1137 * 1138 * @see https://developer.wordpress.org/reference/functions/__/ 1139 * 1140 * @param {string} text Text to translate. 1141 * @param {string} [domain] Domain to retrieve the translated text. 1142 * 1143 * @return {string} Translated text. 1144 */ 1145 1146var default_i18n_ = i18n.__.bind(i18n); 1147/** 1148 * Retrieve translated string with gettext context. 1149 * 1150 * @see https://developer.wordpress.org/reference/functions/_x/ 1151 * 1152 * @param {string} text Text to translate. 1153 * @param {string} context Context information for the translators. 1154 * @param {string} [domain] Domain to retrieve the translated text. 1155 * 1156 * @return {string} Translated context string without pipe. 1157 */ 1158 1159var default_i18n_x = i18n._x.bind(i18n); 1160/** 1161 * Translates and retrieves the singular or plural form based on the supplied 1162 * number. 1163 * 1164 * @see https://developer.wordpress.org/reference/functions/_n/ 1165 * 1166 * @param {string} single The text to be used if the number is singular. 1167 * @param {string} plural The text to be used if the number is plural. 1168 * @param {number} number The number to compare against to use either the 1169 * singular or plural form. 1170 * @param {string} [domain] Domain to retrieve the translated text. 1171 * 1172 * @return {string} The translated singular or plural form. 1173 */ 1174 1175var default_i18n_n = i18n._n.bind(i18n); 1176/** 1177 * Translates and retrieves the singular or plural form based on the supplied 1178 * number, with gettext context. 1179 * 1180 * @see https://developer.wordpress.org/reference/functions/_nx/ 1181 * 1182 * @param {string} single The text to be used if the number is singular. 1183 * @param {string} plural The text to be used if the number is plural. 1184 * @param {number} number The number to compare against to use either the 1185 * singular or plural form. 1186 * @param {string} context Context information for the translators. 1187 * @param {string} [domain] Domain to retrieve the translated text. 1188 * 1189 * @return {string} The translated singular or plural form. 1190 */ 1191 1192var default_i18n_nx = i18n._nx.bind(i18n); 1193/** 1194 * Check if current locale is RTL. 1195 * 1196 * **RTL (Right To Left)** is a locale property indicating that text is written from right to left. 1197 * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common 1198 * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages, 1199 * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`). 1200 * 1201 * @return {boolean} Whether locale is RTL. 1202 */ 1203 1204var default_i18n_isRTL = i18n.isRTL.bind(i18n); 1205 1206// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/index.js 1207 1208 1209 1210 1211 1212/***/ }), 1213 1214/***/ 5: 1215/***/ (function(module, __webpack_exports__, __webpack_require__) { 1216 1217"use strict"; 1218/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); 1219function _defineProperty(obj, key, value) { 1220 if (key in obj) { 1221 Object.defineProperty(obj, key, { 1222 value: value, 1223 enumerable: true, 1224 configurable: true, 1225 writable: true 1226 }); 1227 } else { 1228 obj[key] = value; 1229 } 1230 1231 return obj; 1232} 1233 1234/***/ }), 1235 1236/***/ 60: 1237/***/ (function(module, exports, __webpack_require__) { 1238 1239/** 1240 * Memize options object. 1241 * 1242 * @typedef MemizeOptions 1243 * 1244 * @property {number} [maxSize] Maximum size of the cache. 1245 */ 1246 1247/**
1248 * Internal cache entry. 1249 * 1250 * @typedef MemizeCacheNode 1251 * 1252 * @property {?MemizeCacheNode|undefined} [prev] Previous node. 1253 * @property {?MemizeCacheNode|undefined} [next] Next node. 1254 * @property {Array<*>} args Function arguments for cache 1255 * entry. 1256 * @property {*} val Function result. 1257 */ 1258 1259/** 1260 * Properties of the enhanced function for controlling cache. 1261 * 1262 * @typedef MemizeMemoizedFunction 1263 * 1264 * @property {()=>void} clear Clear the cache. 1265 */ 1266 1267/** 1268 * Accepts a function to be memoized, and returns a new memoized function, with 1269 * optional options. 1270 * 1271 * @template {Function} F 1272 * 1273 * @param {F} fn Function to memoize. 1274 * @param {MemizeOptions} [options] Options object. 1275 * 1276 * @return {F & MemizeMemoizedFunction} Memoized function. 1277 */ 1278function memize( fn, options ) { 1279 var size = 0; 1280 1281 /** @type {?MemizeCacheNode|undefined} */ 1282 var head; 1283 1284 /** @type {?MemizeCacheNode|undefined} */ 1285 var tail; 1286 1287 options = options || {}; 1288 1289 function memoized( /* ...args */ ) { 1290 var node = head, 1291 len = arguments.length, 1292 args, i; 1293 1294 searchCache: while ( node ) { 1295 // Perform a shallow equality test to confirm that whether the node 1296 // under test is a candidate for the arguments passed. Two arrays 1297 // are shallowly equal if their length matches and each entry is 1298 // strictly equal between the two sets. Avoid abstracting to a 1299 // function which could incur an arguments leaking deoptimization. 1300 1301 // Check whether node arguments match arguments length 1302 if ( node.args.length !== arguments.length ) { 1303 node = node.next; 1304 continue; 1305 } 1306 1307 // Check whether node arguments match arguments values 1308 for ( i = 0; i < len; i++ ) { 1309 if ( node.args[ i ] !== arguments[ i ] ) { 1310 node = node.next; 1311 continue searchCache; 1312 } 1313 } 1314 1315 // At this point we can assume we've found a match 1316 1317 // Surface matched node to head if not already 1318 if ( node !== head ) { 1319 // As tail, shift to previous. Must only shift if not also 1320 // head, since if both head and tail, there is no previous. 1321 if ( node === tail ) { 1322 tail = node.prev; 1323 } 1324 1325 // Adjust siblings to point to each other. If node was tail, 1326 // this also handles new tail's empty `next` assignment. 1327 /** @type {MemizeCacheNode} */ ( node.prev ).next = node.next; 1328 if ( node.next ) { 1329 node.next.prev = node.prev; 1330 } 1331 1332 node.next = head; 1333 node.prev = null; 1334 /** @type {MemizeCacheNode} */ ( head ).prev = node; 1335 head = node; 1336 } 1337 1338 // Return immediately 1339 return node.val; 1340 } 1341 1342 // No cached value found. Continue to insertion phase: 1343 1344 // Create a copy of arguments (avoid leaking deoptimization) 1345 args = new Array( len ); 1346 for ( i = 0; i < len; i++ ) { 1347 args[ i ] = arguments[ i ]; 1348 } 1349 1350 node = { 1351 args: args, 1352 1353 // Generate the result from original function 1354 val: fn.apply( null, args ), 1355 }; 1356 1357 // Don't need to check whether node is already head, since it would 1358 // have been returned above already if it was 1359 1360 // Shift existing head down list 1361 if ( head ) { 1362 head.prev = node; 1363 node.next = head; 1364 } else { 1365 // If no head, follows that there's no tail (at initial or reset) 1366 tail = node; 1367 } 1368 1369 // Trim tail if we're reached max size and are pending cache insertion 1370 if ( size === /** @type {MemizeOptions} */ ( options ).maxSize ) { 1371 tail = /** @type {MemizeCacheNode} */ ( tail ).prev; 1372 /** @type {MemizeCacheNode} */ ( tail ).next = null; 1373 } else { 1374 size++; 1375 } 1376 1377 head = node; 1378 1379 return node.val; 1380 } 1381 1382 memoized.clear = function() { 1383 head = null; 1384 tail = null; 1385 size = 0; 1386 }; 1387 1388 if ( false ) {} 1389 1390 // Ignore reason: There's not a clear solution to create an intersection of 1391 // the function with additional properties, where the goal is to retain the 1392 // function signature of the incoming argument and add control properties 1393 // on the return value. 1394 1395 // @ts-ignore 1396 return memoized; 1397} 1398 1399module.exports = memize; 1400 1401 1402/***/ }) 1403 1404/******/ });
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.