Edit File by line

/******/ (() => { // webpackBootstrap

[0] Fix | Delete

/******/ var __webpack_modules__ = ({

[1] Fix | Delete

[2] Fix | Delete

/***/ 2058:

[3] Fix | Delete

/***/ ((module, exports, __webpack_require__) => {

[4] Fix | Delete

[5] Fix | Delete

var __WEBPACK_AMD_DEFINE_RESULT__;/* global window, exports, define */

[6] Fix | Delete

[7] Fix | Delete

!function() {

[8] Fix | Delete

'use strict'

[9] Fix | Delete

[10] Fix | Delete

var re = {

[11] Fix | Delete

not_string: /[^s]/,

[12] Fix | Delete

not_bool: /[^t]/,

[13] Fix | Delete

not_type: /[^T]/,

[14] Fix | Delete

not_primitive: /[^v]/,

[15] Fix | Delete

number: /[diefg]/,

[16] Fix | Delete

numeric_arg: /[bcdiefguxX]/,

[17] Fix | Delete

json: /[j]/,

[18] Fix | Delete

not_json: /[^j]/,

[19] Fix | Delete

text: /^[^\x25]+/,

[20] Fix | Delete

modulo: /^\x25{2}/,

[21] Fix | Delete

placeholder: /^\x25(?:([1-9]\d*)\$|$([^)]+)$)?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,

[22] Fix | Delete

key: /^([a-z_][a-z_\d]*)/i,

[23] Fix | Delete

key_access: /^\.([a-z_][a-z_\d]*)/i,

[24] Fix | Delete

index_access: /^\[(\d+)\]/,

[25] Fix | Delete

sign: /^[+-]/

[26] Fix | Delete

}

[27] Fix | Delete

[28] Fix | Delete

function sprintf(key) {

[29] Fix | Delete

// `arguments` is not an array, but should be fine for this call

[30] Fix | Delete

return sprintf_format(sprintf_parse(key), arguments)

[31] Fix | Delete

}

[32] Fix | Delete

[33] Fix | Delete

function vsprintf(fmt, argv) {

[34] Fix | Delete

return sprintf.apply(null, [fmt].concat(argv || []))

[35] Fix | Delete

}

[36] Fix | Delete

[37] Fix | Delete

function sprintf_format(parse_tree, argv) {

[38] Fix | Delete

var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign

[39] Fix | Delete

for (i = 0; i < tree_length; i++) {

[40] Fix | Delete

if (typeof parse_tree[i] === 'string') {

[41] Fix | Delete

output += parse_tree[i]

[42] Fix | Delete

}

[43] Fix | Delete

else if (typeof parse_tree[i] === 'object') {

[44] Fix | Delete

ph = parse_tree[i] // convenience purposes only

[45] Fix | Delete

if (ph.keys) { // keyword argument

[46] Fix | Delete

arg = argv[cursor]

[47] Fix | Delete

for (k = 0; k < ph.keys.length; k++) {

[48] Fix | Delete

if (arg == undefined) {

[49] Fix | Delete

throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))

[50] Fix | Delete

}

[51] Fix | Delete

arg = arg[ph.keys[k]]

[52] Fix | Delete

}

[53] Fix | Delete

}

[54] Fix | Delete

else if (ph.param_no) { // positional argument (explicit)

[55] Fix | Delete

arg = argv[ph.param_no]

[56] Fix | Delete

}

[57] Fix | Delete

else { // positional argument (implicit)

[58] Fix | Delete

arg = argv[cursor++]

[59] Fix | Delete

}

[60] Fix | Delete

[61] Fix | Delete

if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {

[62] Fix | Delete

arg = arg()

[63] Fix | Delete

}

[64] Fix | Delete

[65] Fix | Delete

if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {

[66] Fix | Delete

throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))

[67] Fix | Delete

}

[68] Fix | Delete

[69] Fix | Delete

if (re.number.test(ph.type)) {

[70] Fix | Delete

is_positive = arg >= 0

[71] Fix | Delete

}

[72] Fix | Delete

[73] Fix | Delete

switch (ph.type) {

[74] Fix | Delete

case 'b':

[75] Fix | Delete

arg = parseInt(arg, 10).toString(2)

[76] Fix | Delete

break

[77] Fix | Delete

case 'c':

[78] Fix | Delete

arg = String.fromCharCode(parseInt(arg, 10))

[79] Fix | Delete

break

[80] Fix | Delete

case 'd':

[81] Fix | Delete

case 'i':

[82] Fix | Delete

arg = parseInt(arg, 10)

[83] Fix | Delete

break

[84] Fix | Delete

case 'j':

[85] Fix | Delete

arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)

[86] Fix | Delete

break

[87] Fix | Delete

case 'e':

[88] Fix | Delete

arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()

[89] Fix | Delete

break

[90] Fix | Delete

case 'f':

[91] Fix | Delete

arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)

[92] Fix | Delete

break

[93] Fix | Delete

case 'g':

[94] Fix | Delete

arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)

[95] Fix | Delete

break

[96] Fix | Delete

case 'o':

[97] Fix | Delete

arg = (parseInt(arg, 10) >>> 0).toString(8)

[98] Fix | Delete

break

[99] Fix | Delete

case 's':

[100] Fix | Delete

arg = String(arg)

[101] Fix | Delete

arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

[102] Fix | Delete

break

[103] Fix | Delete

case 't':

[104] Fix | Delete

arg = String(!!arg)

[105] Fix | Delete

arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

[106] Fix | Delete

break

[107] Fix | Delete

case 'T':

[108] Fix | Delete

arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()

[109] Fix | Delete

arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

[110] Fix | Delete

break

[111] Fix | Delete

case 'u':

[112] Fix | Delete

arg = parseInt(arg, 10) >>> 0

[113] Fix | Delete

break

[114] Fix | Delete

case 'v':

[115] Fix | Delete

arg = arg.valueOf()

[116] Fix | Delete

arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

[117] Fix | Delete

break

[118] Fix | Delete

case 'x':

[119] Fix | Delete

arg = (parseInt(arg, 10) >>> 0).toString(16)

[120] Fix | Delete

break

[121] Fix | Delete

case 'X':

[122] Fix | Delete

arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()

[123] Fix | Delete

break

[124] Fix | Delete

}

[125] Fix | Delete

if (re.json.test(ph.type)) {

[126] Fix | Delete

output += arg

[127] Fix | Delete

}

[128] Fix | Delete

else {

[129] Fix | Delete

if (re.number.test(ph.type) && (!is_positive || ph.sign)) {

[130] Fix | Delete

sign = is_positive ? '+' : '-'

[131] Fix | Delete

arg = arg.toString().replace(re.sign, '')

[132] Fix | Delete

}

[133] Fix | Delete

else {

[134] Fix | Delete

sign = ''

[135] Fix | Delete

}

[136] Fix | Delete

pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '

[137] Fix | Delete

pad_length = ph.width - (sign + arg).length

[138] Fix | Delete

pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''

[139] Fix | Delete

output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)

[140] Fix | Delete

}

[141] Fix | Delete

}

[142] Fix | Delete

}

[143] Fix | Delete

return output

[144] Fix | Delete

}

[145] Fix | Delete

[146] Fix | Delete

var sprintf_cache = Object.create(null)

[147] Fix | Delete

[148] Fix | Delete

function sprintf_parse(fmt) {

[149] Fix | Delete

if (sprintf_cache[fmt]) {

[150] Fix | Delete

return sprintf_cache[fmt]

[151] Fix | Delete

}

[152] Fix | Delete

[153] Fix | Delete

var _fmt = fmt, match, parse_tree = [], arg_names = 0

[154] Fix | Delete

while (_fmt) {

[155] Fix | Delete

if ((match = re.text.exec(_fmt)) !== null) {

[156] Fix | Delete

parse_tree.push(match[0])

[157] Fix | Delete

}

[158] Fix | Delete

else if ((match = re.modulo.exec(_fmt)) !== null) {

[159] Fix | Delete

parse_tree.push('%')

[160] Fix | Delete

}

[161] Fix | Delete

else if ((match = re.placeholder.exec(_fmt)) !== null) {

[162] Fix | Delete

if (match[2]) {

[163] Fix | Delete

arg_names |= 1

[164] Fix | Delete

var field_list = [], replacement_field = match[2], field_match = []

[165] Fix | Delete

if ((field_match = re.key.exec(replacement_field)) !== null) {

[166] Fix | Delete

field_list.push(field_match[1])

[167] Fix | Delete

while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {

[168] Fix | Delete

if ((field_match = re.key_access.exec(replacement_field)) !== null) {

[169] Fix | Delete

field_list.push(field_match[1])

[170] Fix | Delete

}

[171] Fix | Delete

else if ((field_match = re.index_access.exec(replacement_field)) !== null) {

[172] Fix | Delete

field_list.push(field_match[1])

[173] Fix | Delete

}

[174] Fix | Delete

else {

[175] Fix | Delete

throw new SyntaxError('[sprintf] failed to parse named argument key')

[176] Fix | Delete

}

[177] Fix | Delete

}

[178] Fix | Delete

}

[179] Fix | Delete

else {

[180] Fix | Delete

throw new SyntaxError('[sprintf] failed to parse named argument key')

[181] Fix | Delete

}

[182] Fix | Delete

match[2] = field_list

[183] Fix | Delete

}

[184] Fix | Delete

else {

[185] Fix | Delete

arg_names |= 2

[186] Fix | Delete

}

[187] Fix | Delete

if (arg_names === 3) {

[188] Fix | Delete

throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')

[189] Fix | Delete

}

[190] Fix | Delete

[191] Fix | Delete

parse_tree.push(

[192] Fix | Delete

{

[193] Fix | Delete

placeholder: match[0],

[194] Fix | Delete

param_no: match[1],

[195] Fix | Delete

keys: match[2],

[196] Fix | Delete

sign: match[3],

[197] Fix | Delete

pad_char: match[4],

[198] Fix | Delete

align: match[5],

[199] Fix | Delete

width: match[6],

[200] Fix | Delete

precision: match[7],

[201] Fix | Delete

type: match[8]

[202] Fix | Delete

}

[203] Fix | Delete

)

[204] Fix | Delete

}

[205] Fix | Delete

else {

[206] Fix | Delete

throw new SyntaxError('[sprintf] unexpected placeholder')

[207] Fix | Delete

}

[208] Fix | Delete

_fmt = _fmt.substring(match[0].length)

[209] Fix | Delete

}

[210] Fix | Delete

return sprintf_cache[fmt] = parse_tree

[211] Fix | Delete

}

[212] Fix | Delete

[213] Fix | Delete

/**

[214] Fix | Delete

* export to either browser or node.js

[215] Fix | Delete

[216] Fix | Delete

/* eslint-disable quote-props */

[217] Fix | Delete

if (true) {

[218] Fix | Delete

exports.sprintf = sprintf

[219] Fix | Delete

exports.vsprintf = vsprintf

[220] Fix | Delete

}

[221] Fix | Delete

if (typeof window !== 'undefined') {

[222] Fix | Delete

window['sprintf'] = sprintf

[223] Fix | Delete

window['vsprintf'] = vsprintf

[224] Fix | Delete

[225] Fix | Delete

if (true) {

[226] Fix | Delete

!(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {

[227] Fix | Delete

return {

[228] Fix | Delete

'sprintf': sprintf,

[229] Fix | Delete

'vsprintf': vsprintf

[230] Fix | Delete

}

[231] Fix | Delete

}).call(exports, __webpack_require__, exports, module),

[232] Fix | Delete

__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))

[233] Fix | Delete

}

[234] Fix | Delete

}

[235] Fix | Delete

/* eslint-enable quote-props */

[236] Fix | Delete

}(); // eslint-disable-line

[237] Fix | Delete

[238] Fix | Delete

[239] Fix | Delete

/***/ })

[240] Fix | Delete

[241] Fix | Delete

/******/ });

[242] Fix | Delete

/************************************************************************/

[243] Fix | Delete

/******/ // The module cache

[244] Fix | Delete

/******/ var __webpack_module_cache__ = {};

[245] Fix | Delete

/******/

[246] Fix | Delete

/******/ // The require function

[247] Fix | Delete

/******/ function __webpack_require__(moduleId) {

[248] Fix | Delete

/******/ // Check if module is in cache

[249] Fix | Delete

/******/ var cachedModule = __webpack_module_cache__[moduleId];

[250] Fix | Delete

/******/ if (cachedModule !== undefined) {

[251] Fix | Delete

/******/ return cachedModule.exports;

[252] Fix | Delete

/******/ }

[253] Fix | Delete

/******/ // Create a new module (and put it into the cache)

[254] Fix | Delete

/******/ var module = __webpack_module_cache__[moduleId] = {

[255] Fix | Delete

/******/ // no module.id needed

[256] Fix | Delete

/******/ // no module.loaded needed

[257] Fix | Delete

/******/ exports: {}

[258] Fix | Delete

/******/ };

[259] Fix | Delete

/******/

[260] Fix | Delete

/******/ // Execute the module function

[261] Fix | Delete

/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);

[262] Fix | Delete

/******/

[263] Fix | Delete

/******/ // Return the exports of the module

[264] Fix | Delete

/******/ return module.exports;

[265] Fix | Delete

/******/ }

[266] Fix | Delete

/******/

[267] Fix | Delete

/************************************************************************/

[268] Fix | Delete

/******/ /* webpack/runtime/compat get default export */

[269] Fix | Delete

/******/ (() => {

[270] Fix | Delete

/******/ // getDefaultExport function for compatibility with non-harmony modules

[271] Fix | Delete

/******/ __webpack_require__.n = (module) => {

[272] Fix | Delete

/******/ var getter = module && module.__esModule ?

[273] Fix | Delete

/******/ () => (module['default']) :

[274] Fix | Delete

/******/ () => (module);

[275] Fix | Delete

/******/ __webpack_require__.d(getter, { a: getter });

[276] Fix | Delete

/******/ return getter;

[277] Fix | Delete

/******/ };

[278] Fix | Delete

/******/ })();

[279] Fix | Delete

/******/

[280] Fix | Delete

/******/ /* webpack/runtime/define property getters */

[281] Fix | Delete

/******/ (() => {

[282] Fix | Delete

/******/ // define getter functions for harmony exports

[283] Fix | Delete

/******/ __webpack_require__.d = (exports, definition) => {

[284] Fix | Delete

/******/ for(var key in definition) {

[285] Fix | Delete

/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {

[286] Fix | Delete

/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });

[287] Fix | Delete

/******/ }

[288] Fix | Delete

/******/ }

[289] Fix | Delete

/******/ };

[290] Fix | Delete

/******/ })();

[291] Fix | Delete

/******/

[292] Fix | Delete

/******/ /* webpack/runtime/hasOwnProperty shorthand */

[293] Fix | Delete

/******/ (() => {

[294] Fix | Delete

/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))

[295] Fix | Delete

/******/ })();

[296] Fix | Delete

/******/

[297] Fix | Delete

/******/ /* webpack/runtime/make namespace object */

[298] Fix | Delete

/******/ (() => {

[299] Fix | Delete

/******/ // define __esModule on exports

[300] Fix | Delete

/******/ __webpack_require__.r = (exports) => {

[301] Fix | Delete

/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

[302] Fix | Delete

/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

[303] Fix | Delete

/******/ }

[304] Fix | Delete

/******/ Object.defineProperty(exports, '__esModule', { value: true });

[305] Fix | Delete

/******/ };

[306] Fix | Delete

/******/ })();

[307] Fix | Delete

/******/

[308] Fix | Delete

/************************************************************************/

[309] Fix | Delete

var __webpack_exports__ = {};

[310] Fix | Delete

// This entry need to be wrapped in an IIFE because it need to be in strict mode.

[311] Fix | Delete

(() => {

[312] Fix | Delete

"use strict";

[313] Fix | Delete

// ESM COMPAT FLAG

[314] Fix | Delete

__webpack_require__.r(__webpack_exports__);

[315] Fix | Delete

[316] Fix | Delete

// EXPORTS

[317] Fix | Delete

__webpack_require__.d(__webpack_exports__, {

[318] Fix | Delete

__: () => (/* reexport */ __),

[319] Fix | Delete

_n: () => (/* reexport */ _n),

[320] Fix | Delete

_nx: () => (/* reexport */ _nx),

[321] Fix | Delete

_x: () => (/* reexport */ _x),

[322] Fix | Delete

createI18n: () => (/* reexport */ createI18n),

[323] Fix | Delete

defaultI18n: () => (/* reexport */ default_i18n),

[324] Fix | Delete

getLocaleData: () => (/* reexport */ getLocaleData),

[325] Fix | Delete

hasTranslation: () => (/* reexport */ hasTranslation),

[326] Fix | Delete

isRTL: () => (/* reexport */ isRTL),

[327] Fix | Delete

resetLocaleData: () => (/* reexport */ resetLocaleData),

[328] Fix | Delete

setLocaleData: () => (/* reexport */ setLocaleData),

[329] Fix | Delete

sprintf: () => (/* reexport */ sprintf_sprintf),

[330] Fix | Delete

subscribe: () => (/* reexport */ subscribe)

[331] Fix | Delete

});

[332] Fix | Delete

[333] Fix | Delete

;// CONCATENATED MODULE: ./node_modules/memize/dist/index.js

[334] Fix | Delete

/**

[335] Fix | Delete

* Memize options object.

[336] Fix | Delete

[337] Fix | Delete

* @typedef MemizeOptions

[338] Fix | Delete

[339] Fix | Delete

* @property {number} [maxSize] Maximum size of the cache.

[340] Fix | Delete

[341] Fix | Delete

[342] Fix | Delete

/**

[343] Fix | Delete

* Internal cache entry.

[344] Fix | Delete

[345] Fix | Delete

* @typedef MemizeCacheNode

[346] Fix | Delete

[347] Fix | Delete

* @property {?MemizeCacheNode|undefined} [prev] Previous node.

[348] Fix | Delete

* @property {?MemizeCacheNode|undefined} [next] Next node.

[349] Fix | Delete

* @property {Array<*>} args Function arguments for cache

[350] Fix | Delete

* entry.

[351] Fix | Delete

* @property {*} val Function result.

[352] Fix | Delete

[353] Fix | Delete

[354] Fix | Delete

/**

[355] Fix | Delete

* Properties of the enhanced function for controlling cache.

[356] Fix | Delete

[357] Fix | Delete

* @typedef MemizeMemoizedFunction

[358] Fix | Delete

[359] Fix | Delete

* @property {()=>void} clear Clear the cache.

[360] Fix | Delete

[361] Fix | Delete

[362] Fix | Delete

/**

[363] Fix | Delete

* Accepts a function to be memoized, and returns a new memoized function, with

[364] Fix | Delete

* optional options.

[365] Fix | Delete

[366] Fix | Delete

* @template {(...args: any[]) => any} F

[367] Fix | Delete

[368] Fix | Delete

* @param {F} fn Function to memoize.

[369] Fix | Delete

* @param {MemizeOptions} [options] Options object.

[370] Fix | Delete

[371] Fix | Delete

* @return {((...args: Parameters<F>) => ReturnType<F>) & MemizeMemoizedFunction} Memoized function.

[372] Fix | Delete

[373] Fix | Delete

function memize(fn, options) {

[374] Fix | Delete

var size = 0;

[375] Fix | Delete

[376] Fix | Delete

/** @type {?MemizeCacheNode|undefined} */

[377] Fix | Delete

var head;

[378] Fix | Delete

[379] Fix | Delete

/** @type {?MemizeCacheNode|undefined} */

[380] Fix | Delete

var tail;

[381] Fix | Delete

[382] Fix | Delete

options = options || {};

[383] Fix | Delete

[384] Fix | Delete

function memoized(/* ...args */) {

[385] Fix | Delete

var node = head,

[386] Fix | Delete

len = arguments.length,

[387] Fix | Delete

args,

[388] Fix | Delete

[389] Fix | Delete

[390] Fix | Delete

searchCache: while (node) {

[391] Fix | Delete

// Perform a shallow equality test to confirm that whether the node

[392] Fix | Delete

// under test is a candidate for the arguments passed. Two arrays

[393] Fix | Delete

// are shallowly equal if their length matches and each entry is

[394] Fix | Delete

// strictly equal between the two sets. Avoid abstracting to a

[395] Fix | Delete

// function which could incur an arguments leaking deoptimization.

[396] Fix | Delete

[397] Fix | Delete

// Check whether node arguments match arguments length

[398] Fix | Delete

if (node.args.length !== arguments.length) {

[399] Fix | Delete

node = node.next;

[400] Fix | Delete

continue;

[401] Fix | Delete

}

[402] Fix | Delete

[403] Fix | Delete

// Check whether node arguments match arguments values

[404] Fix | Delete

for (i = 0; i < len; i++) {

[405] Fix | Delete

if (node.args[i] !== arguments[i]) {

[406] Fix | Delete

node = node.next;

[407] Fix | Delete

continue searchCache;

[408] Fix | Delete

}

[409] Fix | Delete

}

[410] Fix | Delete

[411] Fix | Delete

// At this point we can assume we've found a match

[412] Fix | Delete

[413] Fix | Delete

// Surface matched node to head if not already

[414] Fix | Delete

if (node !== head) {

[415] Fix | Delete

// As tail, shift to previous. Must only shift if not also

[416] Fix | Delete

// head, since if both head and tail, there is no previous.

[417] Fix | Delete

if (node === tail) {

[418] Fix | Delete

tail = node.prev;

[419] Fix | Delete

}

[420] Fix | Delete

[421] Fix | Delete

// Adjust siblings to point to each other. If node was tail,

[422] Fix | Delete

// this also handles new tail's empty `next` assignment.

[423] Fix | Delete

/** @type {MemizeCacheNode} */ (node.prev).next = node.next;

[424] Fix | Delete

if (node.next) {

[425] Fix | Delete

node.next.prev = node.prev;

[426] Fix | Delete

}

[427] Fix | Delete

[428] Fix | Delete

node.next = head;

[429] Fix | Delete

node.prev = null;

[430] Fix | Delete

/** @type {MemizeCacheNode} */ (head).prev = node;

[431] Fix | Delete

head = node;

[432] Fix | Delete

}

[433] Fix | Delete

[434] Fix | Delete

// Return immediately

[435] Fix | Delete

return node.val;

[436] Fix | Delete

}

[437] Fix | Delete

[438] Fix | Delete

// No cached value found. Continue to insertion phase:

[439] Fix | Delete

[440] Fix | Delete

// Create a copy of arguments (avoid leaking deoptimization)

[441] Fix | Delete

args = new Array(len);

[442] Fix | Delete

for (i = 0; i < len; i++) {

[443] Fix | Delete

args[i] = arguments[i];

[444] Fix | Delete

}

[445] Fix | Delete

[446] Fix | Delete

node = {

[447] Fix | Delete

args: args,

[448] Fix | Delete

[449] Fix | Delete

// Generate the result from original function

[450] Fix | Delete

val: fn.apply(null, args),

[451] Fix | Delete

};

[452] Fix | Delete

[453] Fix | Delete

// Don't need to check whether node is already head, since it would

[454] Fix | Delete

// have been returned above already if it was

[455] Fix | Delete

[456] Fix | Delete

// Shift existing head down list

[457] Fix | Delete

if (head) {

[458] Fix | Delete

head.prev = node;

[459] Fix | Delete

node.next = head;

[460] Fix | Delete

} else {

[461] Fix | Delete

// If no head, follows that there's no tail (at initial or reset)

[462] Fix | Delete

tail = node;

[463] Fix | Delete

}

[464] Fix | Delete

[465] Fix | Delete

// Trim tail if we're reached max size and are pending cache insertion

[466] Fix | Delete

if (size === /** @type {MemizeOptions} */ (options).maxSize) {

[467] Fix | Delete

tail = /** @type {MemizeCacheNode} */ (tail).prev;

[468] Fix | Delete

/** @type {MemizeCacheNode} */ (tail).next = null;

[469] Fix | Delete

} else {

[470] Fix | Delete

size++;

[471] Fix | Delete

}

[472] Fix | Delete

[473] Fix | Delete

head = node;

[474] Fix | Delete

[475] Fix | Delete

return node.val;

[476] Fix | Delete

}

[477] Fix | Delete

[478] Fix | Delete

memoized.clear = function () {

[479] Fix | Delete

head = null;

[480] Fix | Delete

tail = null;

[481] Fix | Delete

size = 0;

[482] Fix | Delete

};

[483] Fix | Delete

[484] Fix | Delete

// Ignore reason: There's not a clear solution to create an intersection of

[485] Fix | Delete

// the function with additional properties, where the goal is to retain the

[486] Fix | Delete

// function signature of the incoming argument and add control properties

[487] Fix | Delete

// on the return value.

[488] Fix | Delete

[489] Fix | Delete

// @ts-ignore

[490] Fix | Delete

return memoized;

[491] Fix | Delete

}

[492] Fix | Delete

[493] Fix | Delete

[494] Fix | Delete

[495] Fix | Delete

// EXTERNAL MODULE: ./node_modules/sprintf-js/src/sprintf.js

[496] Fix | Delete

var sprintf = __webpack_require__(2058);

[497] Fix | Delete

var sprintf_default = /*#__PURE__*/__webpack_require__.n(sprintf);

[498] Fix | Delete

;// CONCATENATED MODULE: ./node_modules/@wordpress/i18n/build-module/sprintf.js

[499] Fix | Delete

12 3 4