vendor: 13,335 bytes, lines 1-340
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 = "Vhyj"); 86/******/ }) 87/************************************************************************/ 88/******/ ({ 89 90/***/ "4Z/T": 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/***/ "4eJC": 330/***/ (function(module, exports, __webpack_require__) { 331 332/** 333 * Memize options object. 334 * 335 * @typedef MemizeOptions 336 * 337 * @property {number} [maxSize] Maximum size of the cache. 338 */ 339 340/**
341 * Internal cache entry. 342 * 343 * @typedef MemizeCacheNode 344 * 345 * @property {?MemizeCacheNode|undefined} [prev] Previous node. 346 * @property {?MemizeCacheNode|undefined} [next] Next node. 347 * @property {Array<*>} args Function arguments for cache 348 * entry. 349 * @property {*} val Function result. 350 */ 351 352/** 353 * Properties of the enhanced function for controlling cache. 354 * 355 * @typedef MemizeMemoizedFunction 356 * 357 * @property {()=>void} clear Clear the cache. 358 */ 359 360/** 361 * Accepts a function to be memoized, and returns a new memoized function, with 362 * optional options. 363 * 364 * @template {Function} F 365 * 366 * @param {F} fn Function to memoize. 367 * @param {MemizeOptions} [options] Options object. 368 * 369 * @return {F & MemizeMemoizedFunction} Memoized function. 370 */ 371function memize( fn, options ) { 372 var size = 0; 373 374 /** @type {?MemizeCacheNode|undefined} */ 375 var head; 376 377 /** @type {?MemizeCacheNode|undefined} */ 378 var tail; 379 380 options = options || {}; 381 382 function memoized( /* ...args */ ) { 383 var node = head, 384 len = arguments.length, 385 args, i; 386 387 searchCache: while ( node ) { 388 // Perform a shallow equality test to confirm that whether the node 389 // under test is a candidate for the arguments passed. Two arrays 390 // are shallowly equal if their length matches and each entry is 391 // strictly equal between the two sets. Avoid abstracting to a 392 // function which could incur an arguments leaking deoptimization. 393 394 // Check whether node arguments match arguments length 395 if ( node.args.length !== arguments.length ) { 396 node = node.next; 397 continue; 398 } 399 400 // Check whether node arguments match arguments values 401 for ( i = 0; i < len; i++ ) { 402 if ( node.args[ i ] !== arguments[ i ] ) { 403 node = node.next; 404 continue searchCache; 405 } 406 } 407 408 // At this point we can assume we've found a match 409 410 // Surface matched node to head if not already 411 if ( node !== head ) { 412 // As tail, shift to previous. Must only shift if not also 413 // head, since if both head and tail, there is no previous. 414 if ( node === tail ) { 415 tail = node.prev; 416 } 417 418 // Adjust siblings to point to each other. If node was tail, 419 // this also handles new tail's empty `next` assignment. 420 /** @type {MemizeCacheNode} */ ( node.prev ).next = node.next; 421 if ( node.next ) { 422 node.next.prev = node.prev; 423 } 424 425 node.next = head; 426 node.prev = null; 427 /** @type {MemizeCacheNode} */ ( head ).prev = node; 428 head = node; 429 } 430 431 // Return immediately 432 return node.val; 433 } 434 435 // No cached value found. Continue to insertion phase: 436 437 // Create a copy of arguments (avoid leaking deoptimization) 438 args = new Array( len ); 439 for ( i = 0; i < len; i++ ) { 440 args[ i ] = arguments[ i ]; 441 } 442 443 node = { 444 args: args, 445 446 // Generate the result from original function 447 val: fn.apply( null, args ), 448 }; 449 450 // Don't need to check whether node is already head, since it would 451 // have been returned above already if it was 452 453 // Shift existing head down list 454 if ( head ) { 455 head.prev = node; 456 node.next = head; 457 } else { 458 // If no head, follows that there's no tail (at initial or reset) 459 tail = node; 460 } 461 462 // Trim tail if we're reached max size and are pending cache insertion 463 if ( size === /** @type {MemizeOptions} */ ( options ).maxSize ) { 464 tail = /** @type {MemizeCacheNode} */ ( tail ).prev; 465 /** @type {MemizeCacheNode} */ ( tail ).next = null; 466 } else { 467 size++; 468 } 469 470 head = node; 471 472 return node.val; 473 } 474 475 memoized.clear = function() { 476 head = null; 477 tail = null; 478 size = 0; 479 }; 480 481 if ( false ) {} 482 483 // Ignore reason: There's not a clear solution to create an intersection of 484 // the function with additional properties, where the goal is to retain the 485 // function signature of the incoming argument and add control properties 486 // on the return value. 487 488 // @ts-ignore 489 return memoized; 490} 491 492module.exports = memize; 493 494 495/***/ }), 496 497/***/ "Vhyj": 498/***/ (function(module, __webpack_exports__, __webpack_require__) { 499 500"use strict";
501// ESM COMPAT FLAG 502__webpack_require__.r(__webpack_exports__); 503 504// EXPORTS 505__webpack_require__.d(__webpack_exports__, "sprintf", function() { return /* reexport */ sprintf_sprintf; }); 506__webpack_require__.d(__webpack_exports__, "createI18n", function() { return /* reexport */ create_i18n_createI18n; }); 507__webpack_require__.d(__webpack_exports__, "setLocaleData", function() { return /* reexport */ default_i18n_setLocaleData; }); 508__webpack_require__.d(__webpack_exports__, "__", function() { return /* reexport */ default_i18n_; }); 509__webpack_require__.d(__webpack_exports__, "_x", function() { return /* reexport */ default_i18n_x; }); 510__webpack_require__.d(__webpack_exports__, "_n", function() { return /* reexport */ default_i18n_n; }); 511__webpack_require__.d(__webpack_exports__, "_nx", function() { return /* reexport */ default_i18n_nx; }); 512__webpack_require__.d(__webpack_exports__, "isRTL", function() { return /* reexport */ default_i18n_isRTL; }); 513 514// EXTERNAL MODULE: ./node_modules/memize/index.js 515var memize = __webpack_require__("4eJC"); 516var memize_default = /*#__PURE__*/__webpack_require__.n(memize); 517 518// EXTERNAL MODULE: ./node_modules/sprintf-js/src/sprintf.js 519var sprintf = __webpack_require__("4Z/T"); 520var sprintf_default = /*#__PURE__*/__webpack_require__.n(sprintf); 521 522// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/sprintf.js 523/** 524 * External dependencies 525 */ 526 527 528/** 529 * Log to console, once per message; or more precisely, per referentially equal 530 * argument set. Because Jed throws errors, we log these to the console instead 531 * to avoid crashing the application. 532 * 533 * @param {...*} args Arguments to pass to `console.error` 534 */ 535 536var logErrorOnce = memize_default()(console.error); // eslint-disable-line no-console 537 538/** 539 * Returns a formatted string. If an error occurs in applying the format, the 540 * original format string is returned. 541 * 542 * @param {string} format The format of the string to generate. 543 * @param {...*} args Arguments to apply to the format. 544 * 545 * @see http://www.diveintojavascript.com/projects/javascript-sprintf 546 * 547 * @return {string} The formatted string. 548 */ 549 550function sprintf_sprintf(format) { 551 try { 552 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 553 args[_key - 1] = arguments[_key]; 554 } 555 556 return sprintf_default.a.sprintf.apply(sprintf_default.a, [format].concat(args)); 557 } catch (error) { 558 logErrorOnce('sprintf error: \n\n' + error.toString()); 559 return format; 560 } 561} 562 563// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js 564var defineProperty = __webpack_require__("rePB"); 565 566// CONCATENATED MODULE: ./node_modules/@tannin/postfix/index.js 567var PRECEDENCE, OPENERS, TERMINATORS, PATTERN; 568 569/** 570 * Operator precedence mapping. 571 * 572 * @type {Object} 573 */ 574PRECEDENCE = { 575 '(': 9, 576 '!': 8, 577 '*': 7, 578 '/': 7, 579 '%': 7,
580 '+': 6, 581 '-': 6, 582 '<': 5, 583 '<=': 5, 584 '>': 5, 585 '>=': 5, 586 '==': 4, 587 '!=': 4, 588 '&&': 3, 589 '||': 2, 590 '?': 1, 591 '?:': 1, 592}; 593 594/** 595 * Characters which signal pair opening, to be terminated by terminators. 596 * 597 * @type {string[]} 598 */ 599OPENERS = [ '(', '?' ]; 600 601/** 602 * Characters which signal pair termination, the value an array with the 603 * opener as its first member. The second member is an optional operator 604 * replacement to push to the stack. 605 * 606 * @type {string[]} 607 */ 608TERMINATORS = { 609 ')': [ '(' ], 610 ':': [ '?', '?:' ], 611}; 612 613/** 614 * Pattern matching operators and openers. 615 * 616 * @type {RegExp} 617 */ 618PATTERN = /<=|>=|==|!=|&&|\|\||\?:|\(|!|\*|\/|%|\+|-|<|>|\?|\)|:/; 619 620/** 621 * Given a C expression, returns the equivalent postfix (Reverse Polish) 622 * notation terms as an array. 623 * 624 * If a postfix string is desired, simply `.join( ' ' )` the result. 625 * 626 * @example 627 * 628 * ```js 629 * import postfix from '@tannin/postfix'; 630 * 631 * postfix( 'n > 1' ); 632 * // ⇒ [ 'n', '1', '>' ] 633 * ``` 634 * 635 * @param {string} expression C expression. 636 * 637 * @return {string[]} Postfix terms. 638 */ 639function postfix( expression ) { 640 var terms = [], 641 stack = [], 642 match, operator, term, element; 643 644 while ( ( match = expression.match( PATTERN ) ) ) { 645 operator = match[ 0 ]; 646 647 // Term is the string preceding the operator match. It may contain 648 // whitespace, and may be empty (if operator is at beginning). 649 term = expression.substr( 0, match.index ).trim(); 650 if ( term ) { 651 terms.push( term ); 652 } 653 654 while ( ( element = stack.pop() ) ) { 655 if ( TERMINATORS[ operator ] ) { 656 if ( TERMINATORS[ operator ][ 0 ] === element ) { 657 // Substitution works here under assumption that because 658 // the assigned operator will no longer be a terminator, it 659 // will be pushed to the stack during the condition below. 660 operator = TERMINATORS[ operator ][ 1 ] || operator; 661 break; 662 } 663 } else if ( OPENERS.indexOf( element ) >= 0 || PRECEDENCE[ element ] < PRECEDENCE[ operator ] ) { 664 // Push to stack if either an opener or when pop reveals an 665 // element of lower precedence. 666 stack.push( element ); 667 break; 668 } 669 670 // For each popped from stack, push to terms. 671 terms.push( element ); 672 } 673 674 if ( ! TERMINATORS[ operator ] ) { 675 stack.push( operator ); 676 } 677 678 // Slice matched fragment from expression to continue match. 679 expression = expression.substr( match.index + operator.length ); 680 } 681 682 // Push remainder of operand, if exists, to terms. 683 expression = expression.trim(); 684 if ( expression ) { 685 terms.push( expression ); 686 } 687 688 // Pop remaining items from stack into terms. 689 return terms.concat( stack.reverse() ); 690} 691 692// CONCATENATED MODULE: ./node_modules/@tannin/evaluate/index.js 693/** 694 * Operator callback functions. 695 * 696 * @type {Object} 697 */ 698var OPERATORS = { 699 '!': function( a ) { 700 return ! a; 701 }, 702 '*': function( a, b ) { 703 return a * b; 704 }, 705 '/': function( a, b ) { 706 return a / b; 707 }, 708 '%': function( a, b ) { 709 return a % b; 710 }, 711 '+': function( a, b ) { 712 return a + b; 713 }, 714 '-': function( a, b ) { 715 return a - b; 716 }, 717 '<': function( a, b ) { 718 return a < b; 719 }, 720 '<=': function( a, b ) { 721 return a <= b; 722 }, 723 '>': function( a, b ) { 724 return a > b; 725 }, 726 '>=': function( a, b ) { 727 return a >= b; 728 }, 729 '==': function( a, b ) { 730 return a === b; 731 }, 732 '!=': function( a, b ) { 733 return a !== b; 734 }, 735 '&&': function( a, b ) { 736 return a && b; 737 }, 738 '||': function( a, b ) { 739 return a || b; 740 }, 741 '?:': function( a, b, c ) { 742 if ( a ) { 743 throw b; 744 } 745 746 return c; 747 }, 748}; 749 750/** 751 * Given an array of postfix terms and operand variables, returns the result of 752 * the postfix evaluation. 753 * 754 * @example 755 * 756 * ```js 757 * import evaluate from '@tannin/evaluate'; 758 * 759 * // 3 + 4 * 5 / 6 ⇒ '3 4 5 * 6 / +' 760 * const terms = [ '3', '4', '5', '*', '6', '/', '+' ]; 761 * 762 * evaluate( terms, {} ); 763 * // ⇒ 6.333333333333334 764 * ``` 765 * 766 * @param {string[]} postfix Postfix terms. 767 * @param {Object} variables Operand variables. 768 * 769 * @return {*} Result of evaluation. 770 */ 771function evaluate_evaluate( postfix, variables ) { 772 var stack = [], 773 i, j, args, getOperatorResult, term, value; 774 775 for ( i = 0; i < postfix.length; i++ ) { 776 term = postfix[ i ]; 777 778 getOperatorResult = OPERATORS[ term ]; 779 if ( getOperatorResult ) { 780 // Pop from stack by number of function arguments. 781 j = getOperatorResult.length; 782 args = Array( j ); 783 while ( j-- ) { 784 args[ j ] = stack.pop(); 785 } 786 787 try { 788 value = getOperatorResult.apply( null, args ); 789 } catch ( earlyReturn ) { 790 return earlyReturn; 791 } 792 } else if ( variables.hasOwnProperty( term ) ) { 793 value = variables[ term ]; 794 } else { 795 value = +term; 796 } 797 798 stack.push( value ); 799 } 800 801 return stack[ 0 ]; 802} 803 804// CONCATENATED MODULE: ./node_modules/@tannin/compile/index.js 805 806 807 808/** 809 * Given a C expression, returns a function which can be called to evaluate its 810 * result. 811 * 812 * @example 813 * 814 * ```js 815 * import compile from '@tannin/compile'; 816 * 817 * const evaluate = compile( 'n > 1' ); 818 * 819 * evaluate( { n: 2 } ); 820 * // ⇒ true 821 * ``` 822 * 823 * @param {string} expression C expression. 824 * 825 * @return {(variables?:{[variable:string]:*})=>*} Compiled evaluator. 826 */ 827function compile( expression ) { 828 var terms = postfix( expression ); 829 830 return function( variables ) { 831 return evaluate_evaluate( terms, variables ); 832 }; 833} 834 835// CONCATENATED MODULE: ./node_modules/@tannin/plural-forms/index.js 836 837 838/** 839 * Given a C expression, returns a function which, when called with a value, 840 * evaluates the result with the value assumed to be the "n" variable of the 841 * expression. The result will be coerced to its numeric equivalent. 842 * 843 * @param {string} expression C expression. 844 * 845 * @return {Function} Evaluator function. 846 */ 847function pluralForms( expression ) { 848 var evaluate = compile( expression ); 849 850 return function( n ) { 851 return +evaluate( { n: n } ); 852 }; 853} 854 855// CONCATENATED MODULE: ./node_modules/tannin/index.js 856 857 858/** 859 * Tannin constructor options. 860 * 861 * @typedef {Object} TanninOptions 862 * 863 * @property {string} [contextDelimiter] Joiner in string lookup with context. 864 * @property {Function} [onMissingKey] Callback to invoke when key missing. 865 */ 866 867/** 868 * Domain metadata. 869 * 870 * @typedef {Object} TanninDomainMetadata 871 * 872 * @property {string} [domain] Domain name. 873 * @property {string} [lang] Language code. 874 * @property {(string|Function)} [plural_forms] Plural forms expression or 875 * function evaluator. 876 */ 877 878/** 879 * Domain translation pair respectively representing the singular and plural 880 * translation. 881 * 882 * @typedef {[string,string]} TanninTranslation 883 */ 884 885/** 886 * Locale data domain. The key is used as reference for lookup, the value an 887 * array of two string entries respectively representing the singular and plural 888 * translation. 889 * 890 * @typedef {{[key:string]:TanninDomainMetadata|TanninTranslation,'':TanninDomainMetadata|TanninTranslation}} TanninLocaleDomain 891 */ 892 893/** 894 * Jed-formatted locale data. 895 * 896 * @see http://messageformat.github.io/Jed/ 897 * 898 * @typedef {{[domain:string]:TanninLocaleDomain}} TanninLocaleData 899 */ 900 901/** 902 * Default Tannin constructor options. 903 * 904 * @type {TanninOptions} 905 */ 906var DEFAULT_OPTIONS = { 907 contextDelimiter: '\u0004', 908 onMissingKey: null, 909}; 910 911/** 912 * Given a specific locale data's config `plural_forms` value, returns the 913 * expression. 914 * 915 * @example 916 * 917 * ``` 918 * getPluralExpression( 'nplurals=2; plural=(n != 1);' ) === '(n != 1)' 919 * ``` 920 * 921 * @param {string} pf Locale data plural forms. 922 * 923 * @return {string} Plural forms expression. 924 */ 925function getPluralExpression( pf ) { 926 var parts, i, part; 927 928 parts = pf.split( ';' ); 929 930 for ( i = 0; i < parts.length; i++ ) { 931 part = parts[ i ].trim(); 932 if ( part.indexOf( 'plural=' ) === 0 ) { 933 return part.substr( 7 ); 934 } 935 } 936} 937 938/** 939 * Tannin constructor. 940 * 941 * @class 942 * 943 * @param {TanninLocaleData} data Jed-formatted locale data. 944 * @param {TanninOptions} [options] Tannin options. 945 */ 946function Tannin( data, options ) { 947 var key; 948 949 /** 950 * Jed-formatted locale data. 951 * 952 * @name Tannin#data 953 * @type {TanninLocaleData} 954 */ 955 this.data = data; 956 957 /** 958 * Plural forms function cache, keyed by plural forms string. 959 * 960 * @name Tannin#pluralForms 961 * @type {Object<string,Function>} 962 */ 963 this.pluralForms = {}; 964 965 /** 966 * Effective options for instance, including defaults. 967 * 968 * @name Tannin#options 969 * @type {TanninOptions} 970 */ 971 this.options = {}; 972 973 for ( key in DEFAULT_OPTIONS ) { 974 this.options[ key ] = options !== undefined && key in options 975 ? options[ key ] 976 : DEFAULT_OPTIONS[ key ]; 977 } 978} 979 980/** 981 * Returns the plural form index for the given domain and value. 982 * 983 * @param {string} domain Domain on which to calculate plural form. 984 * @param {number} n Value for which plural form is to be calculated. 985 * 986 * @return {number} Plural form index. 987 */ 988Tannin.prototype.getPluralForm = function( domain, n ) { 989 var getPluralForm = this.pluralForms[ domain ], 990 config, plural, pf; 991 992 if ( ! getPluralForm ) { 993 config = this.data[ domain ][ '' ]; 994 995 pf = ( 996 config[ 'Plural-Forms' ] || 997 config[ 'plural-forms' ] || 998 // Ignore reason: As known, there's no way to document the empty 999 // string property on a key to guarantee this as metadata. 1000 // @ts-ignore 1001 config.plural_forms 1002 ); 1003 1004 if ( typeof pf !== 'function' ) { 1005 plural = getPluralExpression( 1006 config[ 'Plural-Forms' ] || 1007 config[ 'plural-forms' ] || 1008 // Ignore reason: As known, there's no way to document the empty 1009 // string property on a key to guarantee this as metadata. 1010 // @ts-ignore 1011 config.plural_forms 1012 ); 1013 1014 pf = pluralForms( plural ); 1015 } 1016 1017 getPluralForm = this.pluralForms[ domain ] = pf; 1018 } 1019 1020 return getPluralForm( n ); 1021}; 1022 1023/** 1024 * Translate a string. 1025 * 1026 * @param {string} domain Translation domain. 1027 * @param {string|void} context Context distinguishing terms of the same name. 1028 * @param {string} singular Primary key for translation lookup. 1029 * @param {string=} plural Fallback value used for non-zero plural 1030 * form index. 1031 * @param {number=} n Value to use in calculating plural form. 1032 * 1033 * @return {string} Translated string. 1034 */ 1035Tannin.prototype.dcnpgettext = function( domain, context, singular, plural, n ) { 1036 var index, key, entry; 1037 1038 if ( n === undefined ) { 1039 // Default to singular. 1040 index = 0; 1041 } else { 1042 // Find index by evaluating plural form for value. 1043 index = this.getPluralForm( domain, n ); 1044 } 1045 1046 key = singular; 1047 1048 // If provided, context is prepended to key with delimiter. 1049 if ( context ) { 1050 key = context + this.options.contextDelimiter + singular; 1051 } 1052 1053 entry = this.data[ domain ][ key ]; 1054
1055 // Verify not only that entry exists, but that the intended index is within 1056 // range and non-empty. 1057 if ( entry && entry[ index ] ) { 1058 return entry[ index ]; 1059 } 1060 1061 if ( this.options.onMissingKey ) { 1062 this.options.onMissingKey( singular, domain ); 1063 } 1064 1065 // If entry not found, fall back to singular vs. plural with zero index 1066 // representing the singular value. 1067 return index === 0 ? singular : plural; 1068}; 1069 1070// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/create-i18n.js 1071 1072 1073function 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; } 1074 1075function _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; } 1076 1077/** 1078 * External dependencies 1079 */ 1080 1081/** 1082 * @typedef {Record<string,any>} LocaleData 1083 */ 1084 1085/** 1086 * Default locale data to use for Tannin domain when not otherwise provided. 1087 * Assumes an English plural forms expression. 1088 * 1089 * @type {LocaleData} 1090 */ 1091 1092var DEFAULT_LOCALE_DATA = { 1093 '': { 1094 /** @param {number} n */ 1095 plural_forms: function plural_forms(n) { 1096 return n === 1 ? 0 : 1; 1097 } 1098 } 1099}; 1100/* eslint-disable jsdoc/valid-types */ 1101 1102/** 1103 * @typedef {(data?: LocaleData, domain?: string) => void} SetLocaleData 1104 * Merges locale data into the Tannin instance by domain. Accepts data in a 1105 * Jed-formatted JSON object shape. 1106 * 1107 * @see http://messageformat.github.io/Jed/ 1108 */ 1109 1110/** 1111 * @typedef {(domain?: string) => string} GetFilterDomain 1112 * Retrieve the domain to use when calling domain-specific filters. 1113 */ 1114 1115/** 1116 * @typedef {(text: string, domain?: string) => string} __ 1117 * 1118 * Retrieve the translation of text. 1119 * 1120 * @see https://developer.wordpress.org/reference/functions/__/ 1121 */ 1122 1123/** 1124 * @typedef {(text: string, context: string, domain?: string) => string} _x 1125 * 1126 * Retrieve translated string with gettext context. 1127 * 1128 * @see https://developer.wordpress.org/reference/functions/_x/ 1129 */ 1130 1131/** 1132 * @typedef {(single: string, plural: string, number: number, domain?: string) => string} _n 1133 * 1134 * Translates and retrieves the singular or plural form based on the supplied 1135 * number. 1136 * 1137 * @see https://developer.wordpress.org/reference/functions/_n/ 1138 */ 1139 1140/** 1141 * @typedef {(single: string, plural: string, number: number, context: string, domain?: string) => string} _nx 1142 * 1143 * Translates and retrieves the singular or plural form based on the supplied 1144 * number, with gettext context. 1145 * 1146 * @see https://developer.wordpress.org/reference/functions/_nx/ 1147 */ 1148 1149/** 1150 * @typedef {() => boolean} IsRtl 1151 * 1152 * Check if current locale is RTL. 1153 * 1154 * **RTL (Right To Left)** is a locale property indicating that text is written from right to left. 1155 * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common 1156 * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages, 1157 * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`). 1158 */ 1159 1160/** 1161 * @typedef {{ applyFilters: (hookName:string, ...args: unknown[]) => unknown}} ApplyFiltersInterface 1162 */ 1163 1164/* eslint-enable jsdoc/valid-types */ 1165 1166/** 1167 * An i18n instance 1168 * 1169 * @typedef I18n 1170 * @property {SetLocaleData} setLocaleData Merges locale data into the Tannin instance by domain. Accepts data in a 1171 * Jed-formatted JSON object shape. 1172 * @property {__} __ Retrieve the translation of text. 1173 * @property {_x} _x Retrieve translated string with gettext context. 1174 * @property {_n} _n Translates and retrieves the singular or plural form based on the supplied 1175 * number. 1176 * @property {_nx} _nx Translates and retrieves the singular or plural form based on the supplied 1177 * number, with gettext context. 1178 * @property {IsRtl} isRTL Check if current locale is RTL. 1179 */ 1180 1181/** 1182 * Create an i18n instance 1183 * 1184 * @param {LocaleData} [initialData] Locale data configuration. 1185 * @param {string} [initialDomain] Domain for which configuration applies. 1186 * @param {ApplyFiltersInterface} [hooks] Hooks implementation. 1187 * @return {I18n} I18n instance 1188 */ 1189 1190var create_i18n_createI18n = function createI18n(initialData, initialDomain, hooks) { 1191 /** 1192 * The underlying instance of Tannin to which exported functions interface. 1193 * 1194 * @type {Tannin} 1195 */ 1196 var tannin = new Tannin({}); 1197 /** @type {SetLocaleData} */ 1198 1199 var setLocaleData = function setLocaleData(data) { 1200 var domain = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'default'; 1201 tannin.data[domain] = _objectSpread(_objectSpread(_objectSpread({}, DEFAULT_LOCALE_DATA), tannin.data[domain]), data); // Populate default domain configuration (supported locale date which omits 1202 // a plural forms expression). 1203 1204 tannin.data[domain][''] = _objectSpread(_objectSpread({}, DEFAULT_LOCALE_DATA['']), tannin.data[domain]['']); 1205 }; 1206 /** 1207 * Wrapper for Tannin's `dcnpgettext`. Populates default locale data if not 1208 * otherwise previously assigned. 1209 * 1210 * @param {string|undefined} domain Domain to retrieve the translated text. 1211 * @param {string|undefined} context Context information for the translators. 1212 * @param {string} single Text to translate if non-plural. Used as 1213 * fallback return value on a caught error. 1214 * @param {string} [plural] The text to be used if the number is 1215 * plural. 1216 * @param {number} [number] The number to compare against to use 1217 * either the singular or plural form. 1218 * 1219 * @return {string} The translated string. 1220 */ 1221 1222 1223 var dcnpgettext = function dcnpgettext() { 1224 var domain = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'default'; 1225 var context = arguments.length > 1 ? arguments[1] : undefined; 1226 var single = arguments.length > 2 ? arguments[2] : undefined; 1227 var plural = arguments.length > 3 ? arguments[3] : undefined; 1228 var number = arguments.length > 4 ? arguments[4] : undefined; 1229 1230 if (!tannin.data[domain]) { 1231 setLocaleData(undefined, domain); 1232 } 1233 1234 return tannin.dcnpgettext(domain, context, single, plural, number); 1235 }; 1236 /** @type {GetFilterDomain} */ 1237 1238 1239 var getFilterDomain = function getFilterDomain(domain) { 1240 if (typeof domain === 'undefined') { 1241 return 'default'; 1242 } 1243 1244 return domain; 1245 }; 1246 /** @type {__} */ 1247 1248 1249 var __ = function __(text, domain) { 1250 var translation = dcnpgettext(domain, undefined, text); 1251 /** 1252 * Filters text with its translation. 1253 * 1254 * @param {string} translation Translated text. 1255 * @param {string} text Text to translate. 1256 * @param {string} domain Text domain. Unique identifier for retrieving translated strings. 1257 */ 1258 1259 if (typeof hooks === 'undefined') { 1260 return translation; 1261 } 1262 1263 translation = 1264 /** @type {string} */ 1265 1266 /** @type {*} */ 1267 hooks.applyFilters('i18n.gettext', translation, text, domain); 1268 return ( 1269 /** @type {string} */ 1270 1271 /** @type {*} */ 1272 hooks.applyFilters('i18n.gettext_' + getFilterDomain(domain), translation, text, domain) 1273 ); 1274 }; 1275 /** @type {_x} */ 1276 1277 1278 var _x = function _x(text, context, domain) { 1279 var translation = dcnpgettext(domain, context, text); 1280 /** 1281 * Filters text with its translation based on context information. 1282 * 1283 * @param {string} translation Translated text. 1284 * @param {string} text Text to translate. 1285 * @param {string} context Context information for the translators. 1286 * @param {string} domain Text domain. Unique identifier for retrieving translated strings. 1287 */ 1288 1289 if (typeof hooks === 'undefined') { 1290 return translation; 1291 } 1292 1293 translation = 1294 /** @type {string} */ 1295 1296 /** @type {*} */ 1297 hooks.applyFilters('i18n.gettext_with_context', translation, text, context, domain); 1298 return ( 1299 /** @type {string} */ 1300 1301 /** @type {*} */ 1302 hooks.applyFilters('i18n.gettext_with_context_' + getFilterDomain(domain), translation, text, context, domain) 1303 ); 1304 }; 1305 /** @type {_n} */ 1306 1307 1308 var _n = function _n(single, plural, number, domain) { 1309 var translation = dcnpgettext(domain, undefined, single, plural, number); 1310 1311 if (typeof hooks === 'undefined') { 1312 return translation; 1313 } 1314 /** 1315 * Filters the singular or plural form of a string. 1316 * 1317 * @param {string} translation Translated text. 1318 * @param {string} single The text to be used if the number is singular. 1319 * @param {string} plural The text to be used if the number is plural. 1320 * @param {string} number The number to compare against to use either the singular or plural form. 1321 * @param {string} domain Text domain. Unique identifier for retrieving translated strings. 1322 */ 1323 1324 1325 translation = 1326 /** @type {string} */ 1327 1328 /** @type {*} */ 1329 hooks.applyFilters('i18n.ngettext', translation, single, plural, number, domain); 1330 return ( 1331 /** @type {string} */ 1332 1333 /** @type {*} */ 1334 hooks.applyFilters('i18n.ngettext_' + getFilterDomain(domain), translation, single, plural, number, domain) 1335 ); 1336 }; 1337 /** @type {_nx} */ 1338 1339
1340 var _nx = function _nx(single, plural, number, context, domain) { 1341 var translation = dcnpgettext(domain, context, single, plural, number); 1342 1343 if (typeof hooks === 'undefined') { 1344 return translation; 1345 } 1346 /** 1347 * Filters the singular or plural form of a string with gettext context. 1348 * 1349 * @param {string} translation Translated text. 1350 * @param {string} single The text to be used if the number is singular. 1351 * @param {string} plural The text to be used if the number is plural. 1352 * @param {string} number The number to compare against to use either the singular or plural form. 1353 * @param {string} context Context information for the translators. 1354 * @param {string} domain Text domain. Unique identifier for retrieving translated strings. 1355 */ 1356 1357 1358 translation = 1359 /** @type {string} */ 1360 1361 /** @type {*} */ 1362 hooks.applyFilters('i18n.ngettext_with_context', translation, single, plural, number, context, domain); 1363 return ( 1364 /** @type {string} */ 1365 1366 /** @type {*} */ 1367 hooks.applyFilters('i18n.ngettext_with_context_' + getFilterDomain(domain), translation, single, plural, number, context, domain) 1368 ); 1369 }; 1370 /** @type {IsRtl} */ 1371 1372 1373 var isRTL = function isRTL() { 1374 return 'rtl' === _x('ltr', 'text direction'); 1375 }; 1376 1377 if (initialData) { 1378 setLocaleData(initialData, initialDomain); 1379 } 1380 1381 return { 1382 setLocaleData: setLocaleData, 1383 __: __, 1384 _x: _x, 1385 _n: _n, 1386 _nx: _nx, 1387 isRTL: isRTL 1388 }; 1389}; 1390 1391// EXTERNAL MODULE: external ["wp","hooks"] 1392var external_wp_hooks_ = __webpack_require__("g56x"); 1393 1394// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/default-i18n.js 1395/** 1396 * WordPress dependencies 1397 */ 1398 1399/** 1400 * Internal dependencies 1401 */ 1402 1403 1404var i18n = create_i18n_createI18n(undefined, undefined, { 1405 applyFilters: external_wp_hooks_["applyFilters"] 1406}); 1407/* 1408 * Comments in this file are duplicated from ./i18n due to 1409 * https://github.com/WordPress/gutenberg/pull/20318#issuecomment-590837722 1410 */ 1411 1412/** 1413 * @typedef {import('./create-i18n').LocaleData} LocaleData 1414 */ 1415 1416/** 1417 * Merges locale data into the Tannin instance by domain. Accepts data in a 1418 * Jed-formatted JSON object shape. 1419 * 1420 * @see http://messageformat.github.io/Jed/ 1421 * 1422 * @param {LocaleData} [data] Locale data configuration. 1423 * @param {string} [domain] Domain for which configuration applies. 1424 */ 1425 1426var default_i18n_setLocaleData = i18n.setLocaleData.bind(i18n); 1427/** 1428 * Retrieve the translation of text. 1429 * 1430 * @see https://developer.wordpress.org/reference/functions/__/ 1431 * 1432 * @param {string} text Text to translate. 1433 * @param {string} [domain] Domain to retrieve the translated text. 1434 * 1435 * @return {string} Translated text. 1436 */ 1437 1438var default_i18n_ = i18n.__.bind(i18n); 1439/** 1440 * Retrieve translated string with gettext context. 1441 * 1442 * @see https://developer.wordpress.org/reference/functions/_x/ 1443 * 1444 * @param {string} text Text to translate. 1445 * @param {string} context Context information for the translators. 1446 * @param {string} [domain] Domain to retrieve the translated text. 1447 * 1448 * @return {string} Translated context string without pipe. 1449 */ 1450 1451var default_i18n_x = i18n._x.bind(i18n); 1452/** 1453 * Translates and retrieves the singular or plural form based on the supplied 1454 * number. 1455 * 1456 * @see https://developer.wordpress.org/reference/functions/_n/ 1457 * 1458 * @param {string} single The text to be used if the number is singular. 1459 * @param {string} plural The text to be used if the number is plural. 1460 * @param {number} number The number to compare against to use either the 1461 * singular or plural form. 1462 * @param {string} [domain] Domain to retrieve the translated text. 1463 * 1464 * @return {string} The translated singular or plural form. 1465 */ 1466 1467var default_i18n_n = i18n._n.bind(i18n); 1468/** 1469 * Translates and retrieves the singular or plural form based on the supplied 1470 * number, with gettext context. 1471 * 1472 * @see https://developer.wordpress.org/reference/functions/_nx/ 1473 * 1474 * @param {string} single The text to be used if the number is singular. 1475 * @param {string} plural The text to be used if the number is plural. 1476 * @param {number} number The number to compare against to use either the 1477 * singular or plural form. 1478 * @param {string} context Context information for the translators. 1479 * @param {string} [domain] Domain to retrieve the translated text. 1480 * 1481 * @return {string} The translated singular or plural form. 1482 */ 1483 1484var default_i18n_nx = i18n._nx.bind(i18n); 1485/** 1486 * Check if current locale is RTL. 1487 * 1488 * **RTL (Right To Left)** is a locale property indicating that text is written from right to left. 1489 * For example, the `he` locale (for Hebrew) specifies right-to-left. Arabic (ar) is another common 1490 * language written RTL. The opposite of RTL, LTR (Left To Right) is used in other languages, 1491 * including English (`en`, `en-US`, `en-GB`, etc.), Spanish (`es`), and French (`fr`). 1492 * 1493 * @return {boolean} Whether locale is RTL. 1494 */ 1495 1496var default_i18n_isRTL = i18n.isRTL.bind(i18n); 1497 1498// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/index.js 1499 1500 1501 1502 1503 1504/***/ }), 1505 1506/***/ "g56x":
1507/***/ (function(module, exports) { 1508 1509(function() { module.exports = window["wp"]["hooks"]; }()); 1510 1511/***/ }), 1512 1513/***/ "rePB": 1514/***/ (function(module, __webpack_exports__, __webpack_require__) { 1515 1516"use strict"; 1517/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; }); 1518function _defineProperty(obj, key, value) { 1519 if (key in obj) { 1520 Object.defineProperty(obj, key, { 1521 value: value, 1522 enumerable: true, 1523 configurable: true, 1524 writable: true 1525 }); 1526 } else { 1527 obj[key] = value; 1528 } 1529 1530 return obj; 1531} 1532 1533/***/ }) 1534 1535/******/ });
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.