vendor: 4,131 bytes, lines 1-97
1/******/ (() => { // webpackBootstrap 2/******/ "use strict"; 3/******/ // The require scope 4/******/ var __webpack_require__ = {}; 5/******/ 6/************************************************************************/ 7/******/ /* webpack/runtime/define property getters */ 8/******/ (() => { 9/******/ // define getter functions for harmony exports 10/******/ __webpack_require__.d = (exports, definition) => { 11/******/ for(var key in definition) { 12/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 13/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 14/******/ } 15/******/ } 16/******/ }; 17/******/ })(); 18/******/ 19/******/ /* webpack/runtime/hasOwnProperty shorthand */ 20/******/ (() => { 21/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 22/******/ })(); 23/******/ 24/******/ /* webpack/runtime/make namespace object */ 25/******/ (() => { 26/******/ // define __esModule on exports 27/******/ __webpack_require__.r = (exports) => { 28/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 29/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 30/******/ } 31/******/ Object.defineProperty(exports, '__esModule', { value: true }); 32/******/ }; 33/******/ })(); 34/******/ 35/************************************************************************/ 36var __webpack_exports__ = {}; 37// ESM COMPAT FLAG 38__webpack_require__.r(__webpack_exports__); 39 40// EXPORTS 41__webpack_require__.d(__webpack_exports__, { 42 __: () => (/* reexport */ __), 43 _n: () => (/* reexport */ _n), 44 _nx: () => (/* reexport */ _nx), 45 _x: () => (/* reexport */ _x), 46 createI18n: () => (/* reexport */ createI18n), 47 defaultI18n: () => (/* reexport */ default_i18n_default), 48 getLocaleData: () => (/* reexport */ getLocaleData), 49 hasTranslation: () => (/* reexport */ hasTranslation), 50 isRTL: () => (/* reexport */ isRTL), 51 resetLocaleData: () => (/* reexport */ resetLocaleData), 52 setLocaleData: () => (/* reexport */ setLocaleData), 53 sprintf: () => (/* reexport */ sprintf_sprintf), 54 subscribe: () => (/* reexport */ subscribe) 55}); 56 57;// ./node_modules/@tannin/sprintf/src/index.js 58/** 59 * Regular expression matching format placeholder syntax. 60 * 61 * The pattern for matching named arguments is a naive and incomplete matcher 62 * against valid JavaScript identifier names. 63 * 64 * via Mathias Bynens: 65 * 66 * >An identifier must start with $, _, or any character in the Unicode 67 * >categories âUppercase letter (Lu)â, âLowercase letter (Ll)â, âTitlecase 68 * >letter (Lt)â, âModifier letter (Lm)â, âOther letter (Lo)â, or âLetter 69 * >number (Nl)â. 70 * > 71 * >The rest of the string can contain the same characters, plus any U+200C zero 72 * >width non-joiner characters, U+200D zero width joiner characters, and 73 * >characters in the Unicode categories âNon-spacing mark (Mn)â, âSpacing 74 * >combining mark (Mc)â, âDecimal digit number (Nd)â, or âConnector 75 * >punctuation (Pc)â. 76 * 77 * If browser support is constrained to those supporting ES2015, this could be 78 * made more accurate using the `u` flag: 79 * 80 * ``` 81 * /^[$_\p{L}\p{Nl}][$_\p{L}\p{Nl}\u200C\u200D\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/u; 82 * ``` 83 * 84 * @see http://www.pixelbeat.org/programming/gcc/format_specs.html 85 * @see https://mathiasbynens.be/notes/javascript-identifiers#valid-identifier-names 86 * 87 * @type {RegExp} 88 */ 89var PATTERN = 90 /%(((\d+)\$)|(\(([$_a-zA-Z][$_a-zA-Z0-9]*)\)))?[ +0#-]*\d*(\.(\d+|\*))?(ll|[lhqL])?([cduxXefgsp%])/g; 91// â² â² â² â² â² â² â² type 92// â â â â â â Length (unsupported) 93// â â â â â Precision / max width 94// â â â â Min width (unsupported) 95// â â â Flags (unsupported) 96// â Index â Name (for named arguments) 97/**
98 * Given a format string, returns string with arguments interpolatation. 99 * Arguments can either be provided directly via function arguments spread, or 100 * with an array as the second argument. 101 * 102 * @see https://en.wikipedia.org/wiki/Printf_format_string 103 * 104 * @example 105 * 106 * ```js 107 * import sprintf from '@tannin/sprintf'; 108 * 109 * sprintf( 'Hello %s!', 'world' ); 110 * // â 'Hello world!' 111 * ``` 112 * @template {string} T 113 * @overload 114 * @param {T} string - string printf format string 115 * @param {...import('../types').SprintfArgs<T>} args - arguments to interpolate 116 * 117 * @return {string} Formatted string. 118 */ 119 120/** 121 * Given a format string, returns string with arguments interpolatation. 122 * Arguments can either be provided directly via function arguments spread, or 123 * with an array as the second argument. 124 * 125 * @see https://en.wikipedia.org/wiki/Printf_format_string 126 * 127 * @example 128 * 129 * ```js 130 * import sprintf from '@tannin/sprintf'; 131 * 132 * sprintf( 'Hello %s!', 'world' ); 133 * // â 'Hello world!' 134 * ``` 135 * @template {string} T 136 * @overload 137 * @param {T} string - string printf format string 138 * @param {import('../types').SprintfArgs<T>} args - arguments to interpolate 139 * 140 * @return {string} Formatted string. 141 */ 142 143/** 144 * Given a format string, returns string with arguments interpolatation. 145 * Arguments can either be provided directly via function arguments spread, or 146 * with an array as the second argument. 147 * 148 * @see https://en.wikipedia.org/wiki/Printf_format_string 149 * 150 * @example 151 * 152 * ```js 153 * import sprintf from '@tannin/sprintf'; 154 * 155 * sprintf( 'Hello %s!', 'world' ); 156 * // â 'Hello world!' 157 * ``` 158 * @template {string} T 159 * @param {T} string - string printf format string 160 * @param {...import('../types').SprintfArgs<T>} args - arguments to interpolate 161 * 162 * @return {string} Formatted string. 163 */ 164function sprintf(string, ...args) { 165 var i = 0; 166 if (Array.isArray(args[0])) { 167 args = /** @type {import('../types').SprintfArgs<T>[]} */ ( 168 /** @type {unknown} */ args[0] 169 ); 170 } 171 172 return string.replace(PATTERN, function () { 173 var index, 174 // name needs to be documented as `string | undefined` else value will have tpye unknown. 175 /** 176 * Name of the argument to substitute, if any. 177 * 178 * @type {string | undefined} 179 */ 180 name, 181 precision, 182 type, 183 value; 184 185 index = arguments[3]; 186 name = arguments[5]; 187 precision = arguments[7]; 188 type = arguments[9]; 189 190 // There's no placeholder substitution in the explicit "%", meaning it 191 // is not necessary to increment argument index. 192 if (type === '%') { 193 return '%'; 194 } 195 196 // Asterisk precision determined by peeking / shifting next argument. 197 if (precision === '*') { 198 precision = args[i]; 199 i++; 200 } 201 202 if (name === undefined) { 203 // If not a positional argument, use counter value. 204 if (index === undefined) { 205 index = i + 1; 206 } 207 208 i++; 209 210 // Positional argument. 211 value = args[index - 1]; 212 } else if ( 213 args[0] && 214 typeof args[0] === 'object' && 215 args[0].hasOwnProperty(name) 216 ) { 217 // If it's a named argument, use name. 218 value = args[0][name]; 219 } 220 221 // Parse as type. 222 if (type === 'f') { 223 value = parseFloat(value) || 0; 224 } else if (type === 'd') { 225 value = parseInt(value) || 0; 226 } 227 228 // Apply precision. 229 if (precision !== undefined) { 230 if (type === 'f') { 231 value = value.toFixed(precision); 232 } else if (type === 's') { 233 value = value.substr(0, precision); 234 } 235 } 236 237 // To avoid "undefined" concatenation, return empty string if no 238 // placeholder substitution can be performed. 239 return value !== undefined && value !== null ? value : ''; 240 }); 241} 242 243;// ./node_modules/@wordpress/i18n/build-module/sprintf.js 244 245function sprintf_sprintf(format, ...args) { 246 return sprintf(format, ...args); 247} 248 249 250;// ./node_modules/@tannin/postfix/index.js 251var PRECEDENCE, OPENERS, TERMINATORS, postfix_PATTERN; 252 253/** 254 * Operator precedence mapping. 255 * 256 * @type {Object} 257 */ 258PRECEDENCE = { 259 '(': 9, 260 '!': 8, 261 '*': 7, 262 '/': 7, 263 '%': 7,
264 '+': 6, 265 '-': 6, 266 '<': 5, 267 '<=': 5, 268 '>': 5, 269 '>=': 5, 270 '==': 4, 271 '!=': 4, 272 '&&': 3, 273 '||': 2, 274 '?': 1, 275 '?:': 1, 276}; 277 278/** 279 * Characters which signal pair opening, to be terminated by terminators. 280 * 281 * @type {string[]} 282 */ 283OPENERS = [ '(', '?' ]; 284 285/** 286 * Characters which signal pair termination, the value an array with the 287 * opener as its first member. The second member is an optional operator 288 * replacement to push to the stack. 289 * 290 * @type {string[]} 291 */ 292TERMINATORS = { 293 ')': [ '(' ], 294 ':': [ '?', '?:' ], 295}; 296 297/** 298 * Pattern matching operators and openers. 299 * 300 * @type {RegExp} 301 */ 302postfix_PATTERN = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/; 303 304/** 305 * Given a C expression, returns the equivalent postfix (Reverse Polish) 306 * notation terms as an array. 307 * 308 * If a postfix string is desired, simply `.join( ' ' )` the result. 309 * 310 * @example 311 * 312 * ```js 313 * import postfix from '@tannin/postfix'; 314 * 315 * postfix( 'n > 1' ); 316 * // â [ 'n', '1', '>' ] 317 * ``` 318 * 319 * @param {string} expression C expression. 320 * 321 * @return {string[]} Postfix terms. 322 */ 323function postfix( expression ) { 324 var terms = [], 325 stack = [], 326 match, operator, term, element; 327 328 while ( ( match = expression.match( postfix_PATTERN ) ) ) { 329 operator = match[ 0 ]; 330 331 // Term is the string preceding the operator match. It may contain 332 // whitespace, and may be empty (if operator is at beginning). 333 term = expression.substr( 0, match.index ).trim(); 334 if ( term ) { 335 terms.push( term ); 336 } 337 338 while ( ( element = stack.pop() ) ) { 339 if ( TERMINATORS[ operator ] ) { 340 if ( TERMINATORS[ operator ][ 0 ] === element ) { 341 // Substitution works here under assumption that because 342 // the assigned operator will no longer be a terminator, it 343 // will be pushed to the stack during the condition below. 344 operator = TERMINATORS[ operator ][ 1 ] || operator; 345 break; 346 } 347 } else if ( OPENERS.indexOf( element ) >= 0 || PRECEDENCE[ element ] < PRECEDENCE[ operator ] ) { 348 // Push to stack if either an opener or when pop reveals an 349 // element of lower precedence. 350 stack.push( element ); 351 break; 352 } 353 354 // For each popped from stack, push to terms. 355 terms.push( element ); 356 } 357 358 if ( ! TERMINATORS[ operator ] ) { 359 stack.push( operator ); 360 } 361 362 // Slice matched fragment from expression to continue match. 363 expression = expression.substr( match.index + operator.length ); 364 } 365 366 // Push remainder of operand, if exists, to terms. 367 expression = expression.trim(); 368 if ( expression ) { 369 terms.push( expression ); 370 } 371 372 // Pop remaining items from stack into terms. 373 return terms.concat( stack.reverse() ); 374} 375 376;// ./node_modules/@tannin/evaluate/index.js 377/** 378 * Operator callback functions. 379 * 380 * @type {Object} 381 */ 382var OPERATORS = { 383 '!': function( a ) { 384 return ! a; 385 }, 386 '*': function( a, b ) { 387 return a * b; 388 }, 389 '/': function( a, b ) { 390 return a / b; 391 }, 392 '%': function( a, b ) { 393 return a % b; 394 }, 395 '+': function( a, b ) { 396 return a + b; 397 }, 398 '-': function( a, b ) { 399 return a - b; 400 }, 401 '<': function( a, b ) { 402 return a < b; 403 }, 404 '<=': function( a, b ) { 405 return a <= b; 406 }, 407 '>': function( a, b ) { 408 return a > b; 409 }, 410 '>=': function( a, b ) { 411 return a >= b; 412 }, 413 '==': function( a, b ) { 414 return a === b; 415 }, 416 '!=': function( a, b ) { 417 return a !== b; 418 }, 419 '&&': function( a, b ) { 420 return a && b; 421 }, 422 '||': function( a, b ) { 423 return a || b; 424 }, 425 '?:': function( a, b, c ) { 426 if ( a ) { 427 throw b; 428 } 429 430 return c; 431 }, 432}; 433 434/** 435 * Given an array of postfix terms and operand variables, returns the result of 436 * the postfix evaluation. 437 * 438 * @example 439 * 440 * ```js 441 * import evaluate from '@tannin/evaluate'; 442 * 443 * // 3 + 4 * 5 / 6 â '3 4 5 * 6 / +' 444 * const terms = [ '3', '4', '5', '*', '6', '/', '+' ]; 445 * 446 * evaluate( terms, {} ); 447 * // â 6.333333333333334 448 * ``` 449 * 450 * @param {string[]} postfix Postfix terms. 451 * @param {Object} variables Operand variables. 452 * 453 * @return {*} Result of evaluation. 454 */ 455function evaluate( postfix, variables ) { 456 var stack = [], 457 i, j, args, getOperatorResult, term, value; 458 459 for ( i = 0; i < postfix.length; i++ ) { 460 term = postfix[ i ]; 461 462 getOperatorResult = OPERATORS[ term ]; 463 if ( getOperatorResult ) { 464 // Pop from stack by number of function arguments. 465 j = getOperatorResult.length; 466 args = Array( j ); 467 while ( j-- ) { 468 args[ j ] = stack.pop(); 469 } 470 471 try { 472 value = getOperatorResult.apply( null, args ); 473 } catch ( earlyReturn ) { 474 return earlyReturn; 475 } 476 } else if ( variables.hasOwnProperty( term ) ) { 477 value = variables[ term ]; 478 } else { 479 value = +term; 480 } 481 482 stack.push( value ); 483 } 484 485 return stack[ 0 ]; 486} 487 488;// ./node_modules/@tannin/compile/index.js 489 490 491 492/** 493 * Given a C expression, returns a function which can be called to evaluate its 494 * result. 495 * 496 * @example 497 * 498 * ```js 499 * import compile from '@tannin/compile'; 500 * 501 * const evaluate = compile( 'n > 1' ); 502 * 503 * evaluate( { n: 2 } ); 504 * // â true 505 * ``` 506 * 507 * @param {string} expression C expression. 508 * 509 * @return {(variables?:{[variable:string]:*})=>*} Compiled evaluator. 510 */ 511function compile( expression ) { 512 var terms = postfix( expression ); 513 514 return function( variables ) { 515 return evaluate( terms, variables ); 516 }; 517} 518 519;// ./node_modules/@tannin/plural-forms/index.js 520 521 522/** 523 * Given a C expression, returns a function which, when called with a value, 524 * evaluates the result with the value assumed to be the "n" variable of the 525 * expression. The result will be coerced to its numeric equivalent. 526 * 527 * @param {string} expression C expression. 528 * 529 * @return {Function} Evaluator function. 530 */ 531function pluralForms( expression ) { 532 var evaluate = compile( expression ); 533 534 return function( n ) { 535 return +evaluate( { n: n } ); 536 }; 537} 538 539;// ./node_modules/tannin/index.js 540 541 542/** 543 * Tannin constructor options. 544 * 545 * @typedef {Object} TanninOptions 546 * 547 * @property {string} [contextDelimiter] Joiner in string lookup with context. 548 * @property {Function} [onMissingKey] Callback to invoke when key missing. 549 */ 550 551/** 552 * Domain metadata. 553 * 554 * @typedef {Object} TanninDomainMetadata 555 * 556 * @property {string} [domain] Domain name. 557 * @property {string} [lang] Language code. 558 * @property {(string|Function)} [plural_forms] Plural forms expression or 559 * function evaluator. 560 */ 561 562/** 563 * Domain translation pair respectively representing the singular and plural 564 * translation. 565 * 566 * @typedef {[string,string]} TanninTranslation 567 */ 568 569/** 570 * Locale data domain. The key is used as reference for lookup, the value an 571 * array of two string entries respectively representing the singular and plural 572 * translation. 573 * 574 * @typedef {{[key:string]:TanninDomainMetadata|TanninTranslation,'':TanninDomainMetadata|TanninTranslation}} TanninLocaleDomain 575 */ 576 577/** 578 * Jed-formatted locale data. 579 * 580 * @see http://messageformat.github.io/Jed/ 581 * 582 * @typedef {{[domain:string]:TanninLocaleDomain}} TanninLocaleData 583 */ 584 585/** 586 * Default Tannin constructor options. 587 * 588 * @type {TanninOptions} 589 */ 590var DEFAULT_OPTIONS = { 591 contextDelimiter: '\u0004', 592 onMissingKey: null, 593}; 594 595/** 596 * Given a specific locale data's config `plural_forms` value, returns the 597 * expression. 598 * 599 * @example 600 * 601 * ``` 602 * getPluralExpression( 'nplurals=2; plural=(n != 1);' ) === '(n != 1)' 603 * ``` 604 * 605 * @param {string} pf Locale data plural forms. 606 * 607 * @return {string} Plural forms expression. 608 */ 609function getPluralExpression( pf ) { 610 var parts, i, part; 611 612 parts = pf.split( ';' ); 613 614 for ( i = 0; i < parts.length; i++ ) { 615 part = parts[ i ].trim(); 616 if ( part.indexOf( 'plural=' ) === 0 ) { 617 return part.substr( 7 ); 618 } 619 } 620} 621 622/** 623 * Tannin constructor. 624 * 625 * @class 626 * 627 * @param {TanninLocaleData} data Jed-formatted locale data. 628 * @param {TanninOptions} [options] Tannin options. 629 */ 630function Tannin( data, options ) { 631 var key; 632 633 /** 634 * Jed-formatted locale data. 635 * 636 * @name Tannin#data 637 * @type {TanninLocaleData} 638 */ 639 this.data = data; 640 641 /** 642 * Plural forms function cache, keyed by plural forms string. 643 * 644 * @name Tannin#pluralForms 645 * @type {Object<string,Function>} 646 */ 647 this.pluralForms = {}; 648 649 /** 650 * Effective options for instance, including defaults. 651 * 652 * @name Tannin#options 653 * @type {TanninOptions} 654 */ 655 this.options = {}; 656 657 for ( key in DEFAULT_OPTIONS ) { 658 this.options[ key ] = options !== undefined && key in options 659 ? options[ key ] 660 : DEFAULT_OPTIONS[ key ]; 661 } 662} 663 664/** 665 * Returns the plural form index for the given domain and value. 666 * 667 * @param {string} domain Domain on which to calculate plural form. 668 * @param {number} n Value for which plural form is to be calculated. 669 * 670 * @return {number} Plural form index. 671 */ 672Tannin.prototype.getPluralForm = function( domain, n ) { 673 var getPluralForm = this.pluralForms[ domain ], 674 config, plural, pf; 675 676 if ( ! getPluralForm ) { 677 config = this.data[ domain ][ '' ]; 678 679 pf = ( 680 config[ 'Plural-Forms' ] || 681 config[ 'plural-forms' ] || 682 // Ignore reason: As known, there's no way to document the empty 683 // string property on a key to guarantee this as metadata. 684 // @ts-ignore 685 config.plural_forms 686 ); 687 688 if ( typeof pf !== 'function' ) { 689 plural = getPluralExpression( 690 config[ 'Plural-Forms' ] || 691 config[ 'plural-forms' ] || 692 // Ignore reason: As known, there's no way to document the empty 693 // string property on a key to guarantee this as metadata. 694 // @ts-ignore 695 config.plural_forms 696 ); 697 698 pf = pluralForms( plural ); 699 } 700 701 getPluralForm = this.pluralForms[ domain ] = pf; 702 } 703 704 return getPluralForm( n ); 705}; 706 707/** 708 * Translate a string. 709 * 710 * @param {string} domain Translation domain. 711 * @param {string|void} context Context distinguishing terms of the same name. 712 * @param {string} singular Primary key for translation lookup. 713 * @param {string=} plural Fallback value used for non-zero plural 714 * form index. 715 * @param {number=} n Value to use in calculating plural form. 716 * 717 * @return {string} Translated string. 718 */ 719Tannin.prototype.dcnpgettext = function( domain, context, singular, plural, n ) { 720 var index, key, entry; 721 722 if ( n === undefined ) { 723 // Default to singular. 724 index = 0; 725 } else { 726 // Find index by evaluating plural form for value. 727 index = this.getPluralForm( domain, n ); 728 } 729 730 key = singular; 731 732 // If provided, context is prepended to key with delimiter. 733 if ( context ) { 734 key = context + this.options.contextDelimiter + singular; 735 } 736 737 entry = this.data[ domain ][ key ]; 738
739 // Verify not only that entry exists, but that the intended index is within 740 // range and non-empty. 741 if ( entry && entry[ index ] ) { 742 return entry[ index ]; 743 } 744 745 if ( this.options.onMissingKey ) { 746 this.options.onMissingKey( singular, domain ); 747 } 748 749 // If entry not found, fall back to singular vs. plural with zero index 750 // representing the singular value. 751 return index === 0 ? singular : plural; 752}; 753 754;// ./node_modules/@wordpress/i18n/build-module/create-i18n.js 755 756const DEFAULT_LOCALE_DATA = { 757 "": { 758 plural_forms(n) { 759 return n === 1 ? 0 : 1; 760 } 761 } 762}; 763const I18N_HOOK_REGEXP = /^i18n\.(n?gettext|has_translation)(_|$)/; 764const createI18n = (initialData, initialDomain, hooks) => { 765 const tannin = new Tannin({}); 766 const listeners = /* @__PURE__ */ new Set(); 767 const notifyListeners = () => { 768 listeners.forEach((listener) => listener()); 769 }; 770 const subscribe = (callback) => { 771 listeners.add(callback); 772 return () => listeners.delete(callback); 773 }; 774 const getLocaleData = (domain = "default") => tannin.data[domain]; 775 const doSetLocaleData = (data, domain = "default") => { 776 tannin.data[domain] = { 777 ...tannin.data[domain], 778 ...data 779 }; 780 tannin.data[domain][""] = { 781 ...DEFAULT_LOCALE_DATA[""], 782 ...tannin.data[domain]?.[""] 783 }; 784 delete tannin.pluralForms[domain]; 785 }; 786 const setLocaleData = (data, domain) => { 787 doSetLocaleData(data, domain); 788 notifyListeners(); 789 }; 790 const addLocaleData = (data, domain = "default") => { 791 tannin.data[domain] = { 792 ...tannin.data[domain], 793 ...data, 794 // Populate default domain configuration (supported locale date which omits 795 // a plural forms expression). 796 "": { 797 ...DEFAULT_LOCALE_DATA[""], 798 ...tannin.data[domain]?.[""], 799 ...data?.[""] 800 } 801 }; 802 delete tannin.pluralForms[domain]; 803 notifyListeners(); 804 }; 805 const resetLocaleData = (data, domain) => { 806 tannin.data = {}; 807 tannin.pluralForms = {}; 808 setLocaleData(data, domain); 809 }; 810 const dcnpgettext = (domain = "default", context, single, plural, number) => { 811 if (!tannin.data[domain]) { 812 doSetLocaleData(void 0, domain); 813 } 814 return tannin.dcnpgettext(domain, context, single, plural, number); 815 }; 816 const getFilterDomain = (domain) => domain || "default"; 817 const __ = (text, domain) => { 818 let translation = dcnpgettext(domain, void 0, text); 819 if (!hooks) { 820 return translation; 821 } 822 translation = hooks.applyFilters( 823 "i18n.gettext", 824 translation, 825 text, 826 domain 827 ); 828 return hooks.applyFilters( 829 "i18n.gettext_" + getFilterDomain(domain), 830 translation, 831 text, 832 domain 833 ); 834 }; 835 const _x = (text, context, domain) => { 836 let translation = dcnpgettext(domain, context, text); 837 if (!hooks) { 838 return translation; 839 } 840 translation = hooks.applyFilters( 841 "i18n.gettext_with_context", 842 translation, 843 text, 844 context, 845 domain 846 ); 847 return hooks.applyFilters( 848 "i18n.gettext_with_context_" + getFilterDomain(domain), 849 translation, 850 text, 851 context, 852 domain 853 ); 854 }; 855 const _n = (single, plural, number, domain) => { 856 let translation = dcnpgettext( 857 domain, 858 void 0, 859 single, 860 plural, 861 number 862 ); 863 if (!hooks) { 864 return translation; 865 } 866 translation = hooks.applyFilters( 867 "i18n.ngettext", 868 translation, 869 single, 870 plural, 871 number, 872 domain 873 ); 874 return hooks.applyFilters( 875 "i18n.ngettext_" + getFilterDomain(domain), 876 translation, 877 single, 878 plural, 879 number, 880 domain 881 ); 882 }; 883 const _nx = (single, plural, number, context, domain) => { 884 let translation = dcnpgettext( 885 domain, 886 context, 887 single, 888 plural, 889 number 890 ); 891 if (!hooks) { 892 return translation; 893 } 894 translation = hooks.applyFilters( 895 "i18n.ngettext_with_context", 896 translation, 897 single, 898 plural, 899 number, 900 context, 901 domain 902 ); 903 return hooks.applyFilters( 904 "i18n.ngettext_with_context_" + getFilterDomain(domain), 905 translation, 906 single, 907 plural, 908 number, 909 context, 910 domain 911 ); 912 }; 913 const isRTL = () => { 914 return "rtl" === _x("ltr", "text direction"); 915 }; 916 const hasTranslation = (single, context, domain) => {
917 const key = context ? context + "�" + single : single; 918 let result = !!tannin.data?.[domain ?? "default"]?.[key]; 919 if (hooks) { 920 result = hooks.applyFilters( 921 "i18n.has_translation", 922 result, 923 single, 924 context, 925 domain 926 ); 927 result = hooks.applyFilters( 928 "i18n.has_translation_" + getFilterDomain(domain), 929 result, 930 single, 931 context, 932 domain 933 ); 934 } 935 return result; 936 }; 937 if (initialData) { 938 setLocaleData(initialData, initialDomain); 939 } 940 if (hooks) { 941 const onHookAddedOrRemoved = (hookName) => { 942 if (I18N_HOOK_REGEXP.test(hookName)) { 943 notifyListeners(); 944 } 945 }; 946 hooks.addAction("hookAdded", "core/i18n", onHookAddedOrRemoved); 947 hooks.addAction("hookRemoved", "core/i18n", onHookAddedOrRemoved); 948 } 949 return { 950 getLocaleData, 951 setLocaleData, 952 addLocaleData, 953 resetLocaleData, 954 subscribe, 955 __, 956 _x, 957 _n, 958 _nx, 959 isRTL, 960 hasTranslation 961 }; 962}; 963 964 965;// external ["wp","hooks"] 966const external_wp_hooks_namespaceObject = window["wp"]["hooks"]; 967;// ./node_modules/@wordpress/i18n/build-module/default-i18n.js 968 969 970const i18n = createI18n(void 0, void 0, external_wp_hooks_namespaceObject.defaultHooks); 971var default_i18n_default = i18n; 972const getLocaleData = i18n.getLocaleData.bind(i18n); 973const setLocaleData = i18n.setLocaleData.bind(i18n); 974const resetLocaleData = i18n.resetLocaleData.bind(i18n); 975const subscribe = i18n.subscribe.bind(i18n); 976const __ = i18n.__.bind(i18n); 977const _x = i18n._x.bind(i18n); 978const _n = i18n._n.bind(i18n); 979const _nx = i18n._nx.bind(i18n); 980const isRTL = i18n.isRTL.bind(i18n); 981const hasTranslation = i18n.hasTranslation.bind(i18n); 982 983 984;// ./node_modules/@wordpress/i18n/build-module/index.js 985 986 987 988 989 990(window.wp = window.wp || {}).i18n = __webpack_exports__; 991/******/ })() 992;
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.