https://leefmilieu.brussels/themes/custom/ocelot_baseline/assets/js/print.js?v=1.3

1(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
2'use strict';
3var isCallable = require('../internals/is-callable');
4var tryToString = require('../internals/try-to-string');
5
6var $TypeError = TypeError;
7
8// `Assert: IsCallable(argument) is true`
9module.exports = function (argument) {
10  if (isCallable(argument)) return argument;
11  throw new $TypeError(tryToString(argument) + ' is not a function');
12};
13
14},{"../internals/is-callable":37,"../internals/try-to-string":61}],2:[function(require,module,exports){
15'use strict';
16var isObject = require('../internals/is-object');
17
18var $String = String;
19var $TypeError = TypeError;
20
21// `Assert: Type(argument) is Object`
22module.exports = function (argument) {
23  if (isObject(argument)) return argument;
24  throw new $TypeError($String(argument) + ' is not an object');
25};
26
27},{"../internals/is-object":40}],3:[function(require,module,exports){
28'use strict';
29var $forEach = require('../internals/array-iteration').forEach;
30var arrayMethodIsStrict = require('../internals/array-method-is-strict');
31
32var STRICT_METHOD = arrayMethodIsStrict('forEach');
33
34// `Array.prototype.forEach` method implementation
35// https://tc39.es/ecma262/#sec-array.prototype.foreach
36module.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {
37  return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
38// eslint-disable-next-line es/no-array-prototype-foreach -- safe
39} : [].forEach;
40
41},{"../internals/array-iteration":4,"../internals/array-method-is-strict":5}],4:[function(require,module,exports){
42'use strict';
43var bind = require('../internals/function-bind-context');
44var uncurryThis = require('../internals/function-uncurry-this');
45var IndexedObject = require('../internals/indexed-object');
46var toObject = require('../internals/to-object');
47var lengthOfArrayLike = require('../internals/length-of-array-like');
48var arraySpeciesCreate = require('../internals/array-species-create');
49
50var push = uncurryThis([].push);
51
52// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
53var createMethod = function (TYPE) {
54  var IS_MAP = TYPE === 1;
55  var IS_FILTER = TYPE === 2;
56  var IS_SOME = TYPE === 3;
57  var IS_EVERY = TYPE === 4;
58  var IS_FIND_INDEX = TYPE === 6;
59  var IS_FILTER_REJECT = TYPE === 7;
60  var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;
61  return function ($this, callbackfn, that, specificCreate) {
62    var O = toObject($this);
63    var self = IndexedObject(O);
64    var length = lengthOfArrayLike(self);
65    var boundFunction = bind(callbackfn, that);
66    var index = 0;
67    var create = specificCreate || arraySpeciesCreate;
68    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
69    var value, result;
70    for (;length > index; index++) if (NO_HOLES || index in self) {
71      value = self[index];
72      result = boundFunction(value, index, O);
73      if (TYPE) {
74        if (IS_MAP) target[index] = result; // map
75        else if (result) switch (TYPE) {
76          case 3: return true;              // some
77          case 5: return value;             // find
78          case 6: return index;             // findIndex
79          case 2: push(target, value);      // filter
80        } else switch (TYPE) {
81          case 4: return false;             // every
82          case 7: push(target, value);      // filterReject
83        }
84      }
85    }
86    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
87  };
88};
89
90module.exports = {
91  // `Array.prototype.forEach` method
92  // https://tc39.es/ecma262/#sec-array.prototype.foreach
93  forEach: createMethod(0),
94  // `Array.prototype.map` method
95  // https://tc39.es/ecma262/#sec-array.prototype.map
96  map: createMethod(1),
97  // `Array.prototype.filter` method
98  // https://tc39.es/ecma262/#sec-array.prototype.filter
99  filter: createMethod(2),
100  // `Array.prototype.some` method
101  // https://tc39.es/ecma262/#sec-array.prototype.some
102  some: createMethod(3),
103  // `Array.prototype.every` method
104  // https://tc39.es/ecma262/#sec-array.prototype.every
105  every: createMethod(4),
106  // `Array.prototype.find` method
107  // https://tc39.es/ecma262/#sec-array.prototype.find
108  find: createMethod(5),
109  // `Array.prototype.findIndex` method
110  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
111  findIndex: createMethod(6),
112  // `Array.prototype.filterReject` method
113  // https://github.com/tc39/proposal-array-filtering
114  filterReject: createMethod(7)
115};
116
117},{"../internals/array-species-create":7,"../internals/function-bind-context":21,"../internals/function-uncurr

117y-this":26,"../internals/indexed-object":33,"../internals/length-of-array-like":43,"../internals/to-object":57}],5:[function(require,module,exports){
118'use strict';
119var fails = require('../internals/fails');
120
121module.exports = function (METHOD_NAME, argument) {
122  var method = [][METHOD_NAME];
123  return !!method && fails(function () {
124    // eslint-disable-next-line no-useless-call -- required for testing
125    method.call(null, argument || function () { return 1; }, 1);
126  });
127};
128
129},{"../internals/fails":20}],6:[function(require,module,exports){
130'use strict';
131var isArray = require('../internals/is-array');
132var isConstructor = require('../internals/is-constructor');
133var isObject = require('../internals/is-object');
134var wellKnownSymbol = require('../internals/well-known-symbol');
135
136var SPECIES = wellKnownSymbol('species');
137var $Array = Array;
138
139// a part of `ArraySpeciesCreate` abstract operation
140// https://tc39.es/ecma262/#sec-arrayspeciescreate
141module.exports = function (originalArray) {
142  var C;
143  if (isArray(originalArray)) {
144    C = originalArray.constructor;
145    // cross-realm fallback
146    if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;
147    else if (isObject(C)) {
148      C = C[SPECIES];
149      if (C === null) C = undefined;
150    }
151  } return C === undefined ? $Array : C;
152};
153
154},{"../internals/is-array":36,"../internals/is-constructor":38,"../internals/is-object":40,"../internals/well-known-symbol":66}],7:[function(require,module,exports){
155'use strict';
156var arraySpeciesConstructor = require('../internals/array-species-constructor');
157
158// `ArraySpeciesCreate` abstract operation
159// https://tc39.es/ecma262/#sec-arrayspeciescreate
160module.exports = function (originalArray, length) {
161  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
162};
163
164},{"../internals/array-species-constructor":6}],8:[function(require,module,exports){
165'use strict';
166var uncurryThis = require('../internals/function-uncurry-this');
167
168var toString = uncurryThis({}.toString);
169var stringSlice = uncurryThis(''.slice);
170
171module.exports = function (it) {
172  return stringSlice(toString(it), 8, -1);
173};
174
175},{"../internals/function-uncurry-this":26}],9:[function(require,module,exports){
176'use strict';
177var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');
178var isCallable = require('../internals/is-callable');
179var classofRaw = require('../internals/classof-raw');
180var wellKnownSymbol = require('../internals/well-known-symbol');
181
182var TO_STRING_TAG = wellKnownSymbol('toStringTag');
183var $Object = Object;
184
185// ES3 wrong here
186var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
187
188// fallback for IE11 Script Access Denied error
189var tryGet = function (it, key) {
190  try {
191    return it[key];
192  } catch (error) { /* empty */ }
193};
194
195// getting tag from ES6+ `Object.prototype.toString`
196module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
197  var O, tag, result;
198  return it === undefined ? 'Undefined' : it === null ? 'Null'
199    // @@toStringTag case
200    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
201    // builtinTag case
202    : CORRECT_ARGUMENTS ? classofRaw(O)
203    // ES3 arguments fallback
204    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
205};
206
207},{"../internals/classof-raw":8,"../internals/is-callable":37,"../internals/to-string-tag-support":60,"../internals/well-known-symbol":66}],10:[function(require,module,exports){
208'use strict';
209var DESCRIPTORS = require('../internals/descriptors');
210var definePropertyModule = require('../internals/object-define-property');
211var createPropertyDescriptor = require('../internals/create-property-descriptor');
212
213module.exports = DESCRIPTORS ? function (object, key, value) {
214  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
215} : function (object, key, value) {
216  object[key] = value;
217  return object;
218};
219
220},{"../internals/create-property-descriptor":11,"../internals/descriptors":14,"../internals/object-define-property":46}],11:[function(require,module,exports){
221'use strict';
222module.exports = function (bitmap, value) {
223  return {
224    enumerable: !(bitmap & 1),
225    configurable: !(bitmap & 2),
226    writable: !(bitmap & 4),
227    value: value
228  };
229};
230
231},{}],12:[function(require,module,exports){
232'use strict';
233var isCallable = require('../internals/is-callable');
234var definePropertyModule = require('../internals/object-define-property');
235var makeBuiltIn = require('../internals/make-built-in');
236var defineGlobalProperty = require('../internals/define-global-property');
237
238module.exports = function (O, key, value, options) {
239  if (!options) options = {};
240  var simple = options.enumerable;
241  var name = options.name !== undefined ? options.name : key;
242  if (isCallable(value)) makeBuiltIn(value, name, options);
243  if (options.global) {
244    if (simple) O[key] = value;
245    else defineGlobalProperty(key, value);
246  } else {
247    try {
248      if (!options.unsafe) delete O[key];
249      else if (O[key]) simple = true;
250    } catch (error) { /* empty */ }
251    if (simple) O[key] = value;
252    else definePropertyModule.f(O, key, {
253      value: value,
254      enumerable: false,
255      configurable: !options.nonConfigurable,
256      writable: !options.nonWritable
257    });
258  } return O;
259};
260
261},{"../internals/define-global-property":13,"../internals/is-callable":37,"../internals/make-built-in":44,"../internals/object-define-property":46}],13:[function(require,module,exports){
262'use strict';
263var globalThis = require('../internals/global-this');
264
265// eslint-disable-next-line es/no-object-defineproperty -- safe
266var defineProperty = Object.defineProperty;
267
268module.exports = function (key, value) {
269  try {
270    defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
271  } catch (error) {
272    globalThis[key] = value;
273  } return value;
274};
275
276},{"../internals/global-this":29}],14:[function(require,module,exports){
277'use strict';
278var fails = require('../internals/fails');
279
280// Detect IE8's incomplete defineProperty implementation
281module.exports = !fails(function () {
282  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
283  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
284});
285
286},{"../internals/fails":20}],15:[function(require,module,exports){
287'use strict';
288var globalThis = require('../internals/global-this');
289var isObject = require('../internals/is-object');
290
291var document = globalThis.document;
292// typeof document.createElement is 'object' in old IE
293var EXISTS = isObject(document) && isObject(document.createElement);
294
295module.exports = function (it) {
296  return EXISTS ? document.createElement(it) : {};
297};
298
299},{"../internals/global-this":29,"../internals/is-object":40}],16:[function(require,module,exports){
300'use strict';
301// iterable DOM collections
302// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
303module.exports = {
304  CSSRuleList: 0,
305  CSSStyleDeclaration: 0,
306  CSSValueList: 0,
307  ClientRectList: 0,
308  DOMRectList: 0,
309  DOMStringList: 0,
310  DOMTokenList: 1,
311  DataTransferItemList: 0,
312  FileList: 0,
313  HTMLAllCollection: 0,
314  HTMLCollection: 0,
315  HTMLFormElement: 0,
316  HTMLSelectElement: 0,
317  MediaList: 0,
318  MimeTypeArray: 0,
319  NamedNodeMap: 0,
320  NodeList: 1,
321  PaintRequestList: 0,
322  Plugin: 0,
323  PluginArray: 0,
324  SVGLengthList: 0,
325  SVGNumberList: 0,
326  SVGPathSegList: 0,
327  SVGPointList: 0,
328  SVGStringList: 0,
329  SVGTransformList: 0,
330  SourceBufferList: 0,
331  StyleSheetList: 0,
332  TextTrackCueList: 0,
333  TextTrackList: 0,
334  TouchList: 0
335};
336
337},{}],17:[function(require,module,exports){
338'use strict';
339// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
340var documentCreateElement = require('../internals/document-create-element');
341
342var classList = documentCreateElement('span').classList;
343var DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;
344
345module.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;
346
347},{"../internals/document-create-element":15}],18:[function(require,module,exports){
348'use strict';
349var globalThis = require('../internals/global-this');
350
351var navigator = globalThis.navigator;
352var userAgent = navigator && navigator.userAgent;
353
354module.exports = userAgent ? String(userAgent) : '';
355
356},{"../internals/global-this":29}],19:[function(require,module,exports){
357'use strict';
358var globalThis = require('../internals/global-this');
359var userAgent = require('../internals/environment-user-agent');
360
361var process = globalThis.process;
362var Deno = globalThis.Deno;
363var versions = process && process.versions || Deno && Deno.version;
364var v8 = versions && versions.v8;
365var match, version;
366
367if (v8) {
368  match = v8.split('.');
369  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
370  // but their correct versions are not interesting for us
371  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
372}
373
374// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
375// so check `userAgent` even if `.v8` exists, but 0
376if (!version && userAgent) {
377  match = userAgent.match(/Edge\/(\d+)/);
378  if (!match || match[1] >= 74) {
379    match = userAgent.match(/Chrome\/(\d+)/);
380    if (match) version = +match[1];
381  }
382}
383
384module.exports = version;
385
386},{"../internals/environment-user-agent":18,"../internals/global-this":29}],20:[function(require,module,exports){
387'use strict';
388module.exports = function (exec) {
389  try {
390    return !!exec();
391  } catch (error) {
392    return true;
393  }
394};
395
396},{}],21:[function(require,module,exports){
397'use strict';

398var uncurryThis = require('../internals/function-uncurry-this-clause');
399var aCallable = require('../internals/a-callable');
400var NATIVE_BIND = require('../internals/function-bind-native');
401
402var bind = uncurryThis(uncurryThis.bind);
403
404// optional / simple context binding
405module.exports = function (fn, that) {
406  aCallable(fn);
407  return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
408    return fn.apply(that, arguments);
409  };
410};
411
412},{"../internals/a-callable":1,"../internals/function-bind-native":22,"../internals/function-uncurry-this-clause":25}],22:[function(require,module,exports){
413'use strict';
414var fails = require('../internals/fails');
415
416module.exports = !fails(function () {
417  // eslint-disable-next-line es/no-function-prototype-bind -- safe
418  var test = (function () { /* empty */ }).bind();
419  // eslint-disable-next-line no-prototype-builtins -- safe
420  return typeof test != 'function' || test.hasOwnProperty('prototype');
421});
422
423},{"../internals/fails":20}],23:[function(require,module,exports){
424'use strict';
425var NATIVE_BIND = require('../internals/function-bind-native');
426
427var call = Function.prototype.call;
428// eslint-disable-next-line es/no-function-prototype-bind -- safe
429module.exports = NATIVE_BIND ? call.bind(call) : function () {
430  return call.apply(call, arguments);
431};
432
433},{"../internals/function-bind-native":22}],24:[function(require,module,exports){
434'use strict';
435var DESCRIPTORS = require('../internals/descriptors');
436var hasOwn = require('../internals/has-own-property');
437
438var FunctionPrototype = Function.prototype;
439// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
440var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
441
442var EXISTS = hasOwn(FunctionPrototype, 'name');
443// additional protection from minified / mangled / dropped function names
444var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
445var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
446
447module.exports = {
448  EXISTS: EXISTS,
449  PROPER: PROPER,
450  CONFIGURABLE: CONFIGURABLE
451};
452
453},{"../internals/descriptors":14,"../internals/has-own-property":30}],25:[function(require,module,exports){
454'use strict';
455var classofRaw = require('../internals/classof-raw');
456var uncurryThis = require('../internals/function-uncurry-this');
457
458module.exports = function (fn) {
459  // Nashorn bug:
460  //   https://github.com/zloirock/core-js/issues/1128
461  //   https://github.com/zloirock/core-js/issues/1130
462  if (classofRaw(fn) === 'Function') return uncurryThis(fn);
463};
464
465},{"../internals/classof-raw":8,"../internals/function-uncurry-this":26}],26:[function(require,module,exports){
466'use strict';
467var NATIVE_BIND = require('../internals/function-bind-native');
468
469var FunctionPrototype = Function.prototype;
470var call = FunctionPrototype.call;
471// eslint-disable-next-line es/no-function-prototype-bind -- safe
472var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
473
474module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
475  return function () {
476    return call.apply(fn, arguments);
477  };
478};
479
480},{"../internals/function-bind-native":22}],27:[function(require,module,exports){
481'use strict';
482var globalThis = require('../internals/global-this');
483var isCallable = require('../internals/is-callable');
484
485var aFunction = function (argument) {
486  return isCallable(argument) ? argument : undefined;
487};
488
489module.exports = function (namespace, method) {
490  return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
491};
492
493},{"../internals/global-this":29,"../internals/is-callable":37}],28:[function(require,module,exports){
494'use strict';
495var aCallable = require('../internals/a-callable');
496var isNullOrUndefined = require('../internals/is-null-or-undefined');
497
498// `GetMethod` abstract operation
499// https://tc39.es/ecma262/#sec-getmethod
500module.exports = function (V, P) {
501  var func = V[P];
502  return isNullOrUndefined(func) ? undefined : aCallable(func);
503};
504
505},{"../internals/a-callable":1,"../internals/is-null-or-undefined":39}],29:[function(require,module,exports){
506(function (global){(function (){
507'use strict';
508var check = function (it) {
509  return it && it.Math === Math && it;
510};
511
512// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
513module.exports =
514  // eslint-disable-next-line es/no-global-this -- safe
515  check(typeof globalThis == 'object' && globalThis) ||
516  check(typeof window == 'object' && window) ||
517  // eslint-disable-next-line no-restricted-globals -- safe
518  check(typeof self == 'object' && self) ||
519  check(typeof global == 'object' && global) ||
520  check(typeof this == 'object' && this) ||
521  // eslint-disable-next-line no-new-func -- fallback
522  (function () { return this; })() || Function('return this')();
523
524}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
525},{}],30:[function(require,module,exports){
526'use strict';

527var uncurryThis = require('../internals/function-uncurry-this');
528var toObject = require('../internals/to-object');
529
530var hasOwnProperty = uncurryThis({}.hasOwnProperty);
531
532// `HasOwnProperty` abstract operation
533// https://tc39.es/ecma262/#sec-hasownproperty
534// eslint-disable-next-line es/no-object-hasown -- safe
535module.exports = Object.hasOwn || function hasOwn(it, key) {
536  return hasOwnProperty(toObject(it), key);
537};
538
539},{"../internals/function-uncurry-this":26,"../internals/to-object":57}],31:[function(require,module,exports){
540'use strict';
541module.exports = {};
542
543},{}],32:[function(require,module,exports){
544'use strict';
545var DESCRIPTORS = require('../internals/descriptors');
546var fails = require('../internals/fails');
547var createElement = require('../internals/document-create-element');
548
549// Thanks to IE8 for its funny defineProperty
550module.exports = !DESCRIPTORS && !fails(function () {
551  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
552  return Object.defineProperty(createElement('div'), 'a', {
553    get: function () { return 7; }
554  }).a !== 7;
555});
556
557},{"../internals/descriptors":14,"../internals/document-create-element":15,"../internals/fails":20}],33:[function(require,module,exports){
558'use strict';
559var uncurryThis = require('../internals/function-uncurry-this');
560var fails = require('../internals/fails');
561var classof = require('../internals/classof-raw');
562
563var $Object = Object;
564var split = uncurryThis(''.split);
565
566// fallback for non-array-like ES3 and non-enumerable old V8 strings
567module.exports = fails(function () {
568  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
569  // eslint-disable-next-line no-prototype-builtins -- safe
570  return !$Object('z').propertyIsEnumerable(0);
571}) ? function (it) {
572  return classof(it) === 'String' ? split(it, '') : $Object(it);
573} : $Object;
574
575},{"../internals/classof-raw":8,"../internals/fails":20,"../internals/function-uncurry-this":26}],34:[function(require,module,exports){
576'use strict';
577var uncurryThis = require('../internals/function-uncurry-this');
578var isCallable = require('../internals/is-callable');
579var store = require('../internals/shared-store');
580
581var functionToString = uncurryThis(Function.toString);
582
583// this helper broken in `[email protected]`, so we can't use `shared` helper
584if (!isCallable(store.inspectSource)) {
585  store.inspectSource = function (it) {
586    return functionToString(it);
587  };
588}
589
590module.exports = store.inspectSource;
591
592},{"../internals/function-uncurry-this":26,"../internals/is-callable":37,"../internals/shared-store":52}],35:[function(require,module,exports){
593'use strict';
594var NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');
595var globalThis = require('../internals/global-this');
596var isObject = require('../internals/is-object');
597var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
598var hasOwn = require('../internals/has-own-property');
599var shared = require('../internals/shared-store');
600var sharedKey = require('../internals/shared-key');
601var hiddenKeys = require('../internals/hidden-keys');
602
603var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
604var TypeError = globalThis.TypeError;
605var WeakMap = globalThis.WeakMap;
606var set, get, has;
607
608var enforce = function (it) {
609  return has(it) ? get(it) : set(it, {});
610};
611
612var getterFor = function (TYPE) {
613  return function (it) {
614    var state;
615    if (!isObject(it) || (state = get(it)).type !== TYPE) {
616      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
617    } return state;
618  };
619};
620
621if (NATIVE_WEAK_MAP || shared.state) {
622  var store = shared.state || (shared.state = new WeakMap());
623  /* eslint-disable no-self-assign -- prototype methods protection */
624  store.get = store.get;
625  store.has = store.has;
626  store.set = store.set;
627  /* eslint-enable no-self-assign -- prototype methods protection */
628  set = function (it, metadata) {
629    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
630    metadata.facade = it;
631    store.set(it, metadata);
632    return metadata;
633  };
634  get = function (it) {
635    return store.get(it) || {};
636  };
637  has = function (it) {
638    return store.has(it);
639  };
640} else {
641  var STATE = sharedKey('state');
642  hiddenKeys[STATE] = true;
643  set = function (it, metadata) {
644    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
645    metadata.facade = it;
646    createNonEnumerableProperty(it, STATE, metadata);
647    return metadata;
648  };
649  get = function (it) {
650    return hasOwn(it, STATE) ? it[STATE] : {};
651  };
652  has = function (it) {
653    return hasOwn(it, STATE);
654  };
655}
656
657module.exports = {
658  set: set,
659  get: get,
660  has: has,
661  enforce: enforce,
662  getterFor: getterFor
663};
664
665},{"../internals/create-non-enumerable-property":10,"../internals/global-this":29,"../internals/has-own-property":30,"../internals/hidden-keys":31,"../internals/is-object":40,"../internals/shared-key":51,"../internals/shared-store":52,"../internals/weak-map-basic-detection":65}],36:[function(require,module,exports){
666'use strict';
667var classof = require('../internals/classof-raw');
668
669// `IsArray` abstract operation
670// https://tc39.es/ecma262/#sec-isarray
671// eslint-disable-next-line es/no-array-isarray -- safe
672module.exports = Array.isArray || function isArray(argument) {
673  return classof(argument) === 'Array';
674};
675
676},{"../internals/classof-raw":8}],37:[function(require,module,exports){
677'use strict';

678// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
679var documentAll = typeof document == 'object' && document.all;
680
681// `IsCallable` abstract operation
682// https://tc39.es/ecma262/#sec-iscallable
683// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
684module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
685  return typeof argument == 'function' || argument === documentAll;
686} : function (argument) {
687  return typeof argument == 'function';
688};
689
690},{}],38:[function(require,module,exports){
691'use strict';
692var uncurryThis = require('../internals/function-uncurry-this');
693var fails = require('../internals/fails');
694var isCallable = require('../internals/is-callable');
695var classof = require('../internals/classof');
696var getBuiltIn = require('../internals/get-built-in');
697var inspectSource = require('../internals/inspect-source');
698
699var noop = function () { /* empty */ };
700var construct = getBuiltIn('Reflect', 'construct');
701var constructorRegExp = /^\s*(?:class|function)\b/;
702var exec = uncurryThis(constructorRegExp.exec);
703var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
704
705var isConstructorModern = function isConstructor(argument) {
706  if (!isCallable(argument)) return false;
707  try {
708    construct(noop, [], argument);
709    return true;
710  } catch (error) {
711    return false;
712  }
713};
714
715var isConstructorLegacy = function isConstructor(argument) {
716  if (!isCallable(argument)) return false;
717  switch (classof(argument)) {
718    case 'AsyncFunction':
719    case 'GeneratorFunction':
720    case 'AsyncGeneratorFunction': return false;
721  }
722  try {
723    // we can't check .prototype since constructors produced by .bind haven't it
724    // `Function#toString` throws on some built-it function in some legacy engines
725    // (for example, `DOMQuad` and similar in FF41-)
726    return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
727  } catch (error) {
728    return true;
729  }
730};
731
732isConstructorLegacy.sham = true;
733
734// `IsConstructor` abstract operation
735// https://tc39.es/ecma262/#sec-isconstructor
736module.exports = !construct || fails(function () {
737  var called;
738  return isConstructorModern(isConstructorModern.call)
739    || !isConstructorModern(Object)
740    || !isConstructorModern(function () { called = true; })
741    || called;
742}) ? isConstructorLegacy : isConstructorModern;
743
744},{"../internals/classof":9,"../internals/fails":20,"../internals/function-uncurry-this":26,"../internals/get-built-in":27,"../internals/inspect-source":34,"../internals/is-callable":37}],39:[function(require,module,exports){
745'use strict';
746// we can't use just `it == null` since of `document.all` special case
747// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
748module.exports = function (it) {
749  return it === null || it === undefined;
750};
751
752},{}],40:[function(require,module,exports){
753'use strict';
754var isCallable = require('../internals/is-callable');
755
756module.exports = function (it) {
757  return typeof it == 'object' ? it !== null : isCallable(it);
758};
759
760},{"../internals/is-callable":37}],41:[function(require,module,exports){
761'use strict';
762module.exports = false;
763
764},{}],42:[function(require,module,exports){
765'use strict';
766var getBuiltIn = require('../internals/get-built-in');
767var isCallable = require('../internals/is-callable');
768var isPrototypeOf = require('../internals/object-is-prototype-of');
769var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');
770
771var $Object = Object;
772
773module.exports = USE_SYMBOL_AS_UID ? function (it) {
774  return typeof it == 'symbol';
775} : function (it) {
776  var $Symbol = getBuiltIn('Symbol');
777  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
778};
779
780},{"../internals/get-built-in":27,"../internals/is-callable":37,"../internals/object-is-prototype-of":47,"../internals/use-symbol-as-uid":63}],43:[function(require,module,exports){
781'use strict';
782var toLength = require('../internals/to-length');
783
784// `LengthOfArrayLike` abstract operation
785// https://tc39.es/ecma262/#sec-lengthofarraylike
786module.exports = function (obj) {
787  return toLength(obj.length);
788};
789
790},{"../internals/to-length":56}],44:[function(require,module,exports){
791'use strict';

792var uncurryThis = require('../internals/function-uncurry-this');
793var fails = require('../internals/fails');
794var isCallable = require('../internals/is-callable');
795var hasOwn = require('../internals/has-own-property');
796var DESCRIPTORS = require('../internals/descriptors');
797var CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;
798var inspectSource = require('../internals/inspect-source');
799var InternalStateModule = require('../internals/internal-state');
800
801var enforceInternalState = InternalStateModule.enforce;
802var getInternalState = InternalStateModule.get;
803var $String = String;
804// eslint-disable-next-line es/no-object-defineproperty -- safe
805var defineProperty = Object.defineProperty;
806var stringSlice = uncurryThis(''.slice);
807var replace = uncurryThis(''.replace);
808var join = uncurryThis([].join);
809
810var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
811  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
812});
813
814var TEMPLATE = String(String).split('String');
815
816var makeBuiltIn = module.exports = function (value, name, options) {
817  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
818    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
819  }
820  if (options && options.getter) name = 'get ' + name;
821  if (options && options.setter) name = 'set ' + name;
822  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
823    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
824    else value.name = name;
825  }
826  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
827    defineProperty(value, 'length', { value: options.arity });
828  }
829  try {
830    if (options && hasOwn(options, 'constructor') && options.constructor) {
831      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
832    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
833    } else if (value.prototype) value.prototype = undefined;
834  } catch (error) { /* empty */ }
835  var state = enforceInternalState(value);
836  if (!hasOwn(state, 'source')) {
837    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
838  } return value;
839};
840
841// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
842// eslint-disable-next-line no-extend-native -- required
843Function.prototype.toString = makeBuiltIn(function toString() {
844  return isCallable(this) && getInternalState(this).source || inspectSource(this);
845}, 'toString');
846
847},{"../internals/descriptors":14,"../internals/fails":20,"../internals/function-name":24,"../internals/function-uncurry-this":26,"../internals/has-own-property":30,"../internals/inspect-source":34,"../internals/internal-state":35,"../internals/is-callable":37}],45:[function(require,module,exports){
848'use strict';
849var ceil = Math.ceil;
850var floor = Math.floor;
851
852// `Math.trunc` method
853// https://tc39.es/ecma262/#sec-math.trunc
854// eslint-disable-next-line es/no-math-trunc -- safe
855module.exports = Math.trunc || function trunc(x) {
856  var n = +x;
857  return (n > 0 ? floor : ceil)(n);
858};
859
860},{}],46:[function(require,module,exports){
861'use strict';
862var DESCRIPTORS = require('../internals/descriptors');
863var IE8_DOM_DEFINE = require('../internals/ie8-dom-define');
864var V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');
865var anObject = require('../internals/an-object');
866var toPropertyKey = require('../internals/to-property-key');
867
868var $TypeError = TypeError;
869// eslint-disable-next-line es/no-object-defineproperty -- safe
870var $defineProperty = Object.defineProperty;
871// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
872var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
873var ENUMERABLE = 'enumerable';
874var CONFIGURABLE = 'configurable';
875var WRITABLE = 'writable';
876
877// `Object.defineProperty` method
878// https://tc39.es/ecma262/#sec-object.defineproperty
879exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
880  anObject(O);
881  P = toPropertyKey(P);
882  anObject(Attributes);
883  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
884    var current = $getOwnPropertyDescriptor(O, P);
885    if (current && current[WRITABLE]) {
886      O[P] = Attributes.value;
887      Attributes = {
888        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
889        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
890        writable: false
891      };
892    }
893  } return $defineProperty(O, P, Attributes);
894} : $defineProperty : function defineProperty(O, P, Attributes) {
895  anObject(O);
896  P = toPropertyKey(P);
897  anObject(Attributes);
898  if (IE8_DOM_DEFINE) try {
899    return $defineProperty(O, P, Attributes);
900  } catch (error) { /* empty */ }
901  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
902  if ('value' in Attributes) O[P] = Attributes.value;
903  return O;
904};
905
906},{"../internals/an-object":2,"../internals/descriptors":14,"../internals/ie8-d

906om-define":32,"../internals/to-property-key":59,"../internals/v8-prototype-define-bug":64}],47:[function(require,module,exports){
907'use strict';
908var uncurryThis = require('../internals/function-uncurry-this');
909
910module.exports = uncurryThis({}.isPrototypeOf);
911
912},{"../internals/function-uncurry-this":26}],48:[function(require,module,exports){
913'use strict';
914var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');
915var classof = require('../internals/classof');
916
917// `Object.prototype.toString` method implementation
918// https://tc39.es/ecma262/#sec-object.prototype.tostring
919module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
920  return '[object ' + classof(this) + ']';
921};
922
923},{"../internals/classof":9,"../internals/to-string-tag-support":60}],49:[function(require,module,exports){
924'use strict';
925var call = require('../internals/function-call');
926var isCallable = require('../internals/is-callable');
927var isObject = require('../internals/is-object');
928
929var $TypeError = TypeError;
930
931// `OrdinaryToPrimitive` abstract operation
932// https://tc39.es/ecma262/#sec-ordinarytoprimitive
933module.exports = function (input, pref) {
934  var fn, val;
935  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
936  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
937  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
938  throw new $TypeError("Can't convert object to primitive value");
939};
940
941},{"../internals/function-call":23,"../internals/is-callable":37,"../internals/is-object":40}],50:[function(require,module,exports){
942'use strict';
943var isNullOrUndefined = require('../internals/is-null-or-undefined');
944
945var $TypeError = TypeError;
946
947// `RequireObjectCoercible` abstract operation
948// https://tc39.es/ecma262/#sec-requireobjectcoercible
949module.exports = function (it) {
950  if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
951  return it;
952};
953
954},{"../internals/is-null-or-undefined":39}],51:[function(require,module,exports){
955'use strict';
956var shared = require('../internals/shared');
957var uid = require('../internals/uid');
958
959var keys = shared('keys');
960
961module.exports = function (key) {
962  return keys[key] || (keys[key] = uid(key));
963};
964
965},{"../internals/shared":53,"../internals/uid":62}],52:[function(require,module,exports){
966'use strict';
967var IS_PURE = require('../internals/is-pure');
968var globalThis = require('../internals/global-this');
969var defineGlobalProperty = require('../internals/define-global-property');
970
971var SHARED = '__core-js_shared__';
972var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
973
974(store.versions || (store.versions = [])).push({
975  version: '3.41.0',
976  mode: IS_PURE ? 'pure' : 'global',
977  copyright: '© 2014-2025 Denis Pushkarev (zloirock.ru)',
978  license: 'https://github.com/zloirock/core-js/blob/v3.41.0/LICENSE',
979  source: 'https://github.com/zloirock/core-js'
980});
981
982},{"../internals/define-global-property":13,"../internals/global-this":29,"../internals/is-pure":41}],53:[function(require,module,exports){
983'use strict';
984var store = require('../internals/shared-store');
985
986module.exports = function (key, value) {
987  return store[key] || (store[key] = value || {});
988};
989
990},{"../internals/shared-store":52}],54:[function(require,module,exports){
991'use strict';
992/* eslint-disable es/no-symbol -- required for testing */
993var V8_VERSION = require('../internals/environment-v8-version');
994var fails = require('../internals/fails');
995var globalThis = require('../internals/global-this');
996
997var $String = globalThis.String;
998
999// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
1000module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
1001  var symbol = Symbol('symbol detection');
1002  // Chrome 38 Symbol has incorrect toString conversion
1003  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
1004  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
1005  // of course, fail.
1006  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
1007    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
1008    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
1009});
1010
1011},{"../internals/environment-v8-version":19,"../internals/fails":20,"../internals/global-this":29}],55:[function(require,module,exports){
1012'use strict';
1013var trunc = require('../internals/math-trunc');
1014
1015// `ToIntegerOrInfinity` abstract operation
1016// https://tc39.es/ecma262/#sec-tointegerorinfinity
1017module.exports = function (argument) {
1018  var number = +argument;
1019  // eslint-disable-next-line no-self-compare -- NaN check
1020  return number !== number || number === 0 ? 0 : trunc(number);
1021};
1022
1023},{"../internals/math-trunc":45}],56:[function(require,module,exports){
1024'use strict';
1025var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');
1026
1027var min = Math.min;
1028
1029// `ToLength` abstract operation
1030// https://tc39.es/ecma262/#sec-tolength
1031module.exports = function (argument) {
1032  var len = toIntegerOrInfinity(argument);
1033  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
1034};
1035
1036},{"../internals/to-integer-or-infinity":55}],57:[function(require,module,exports){
1037'use strict';
1038var requireObjectCoercible = require('../internals/require-object-coercible');
1039
1040var $Object = Object;
1041
1042// `ToObject` abstract operation
1043// https://tc39.es/ecma262/#sec-toobject
1044module.exports = function (argument) {
1045  return $Object(requireObjectCoercible(argument));
1046};
1047
1048},{"../internals/require-object-coercible":50}],58:[function(require,module,exports){
1049'use strict';
1050var call = require('../internals/function-call');
1051var isObject = require('../internals/is-object');
1052var isSymbol = require('../internals/is-symbol');
1053var getMethod = require('../internals/get-method');
1054var ordinaryToPrimitive = require('../internals/ordinary-to-primitive');
1055var wellKnownSymbol = require('../internals/well-known-symbol');
1056
1057var $TypeError = TypeError;
1058var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
1059
1060// `ToPrimitive` abstract operation
1061// https://tc39.es/ecma262/#sec-toprimitive
1062module.exports = function (input, pref) {
1063  if (!isObject(input) || isSymbol(input)) return input;
1064  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
1065  var result;
1066  if (exoticToPrim) {
1067    if (pref === undefined) pref = 'default';
1068    result = call(exoticToPrim, input, pref);
1069    if (!isObject(result) || isSymbol(result)) return result;
1070    throw new $TypeError("Can't convert object to primitive value");
1071  }
1072  if (pref === undefined) pref = 'number';
1073  return ordinaryToPrimitive(input, pref);
1074};
1075
1076},{"../internals/function-call":23,"../internals/get-method":28,"../internals/is-object":40,"../internals/is-symbol":42,"../internals/ordinary-to-primitive":49,"../internals/well-known-symbol":66}],59:[function(require,module,exports){
1077'use strict';
1078var toPrimitive = require('../internals/to-primitive');
1079var isSymbol = require('../internals/is-symbol');
1080
1081// `ToPropertyKey` abstract operation
1082// https://tc39.es/ecma262/#sec-topropertykey
1083module.exports = function (argument) {
1084  var key = toPrimitive(argument, 'string');
1085  return isSymbol(key) ? key : key + '';
1086};
1087
1088},{"../internals/is-symbol":42,"../internals/to-primitive":58}],60:[function(require,module,exports){
1089'use strict';
1090var wellKnownSymbol = require('../internals/well-known-symbol');
1091
1092var TO_STRING_TAG = wellKnownSymbol('toStringTag');
1093var test = {};
1094
1095test[TO_STRING_TAG] = 'z';
1096
1097module.exports = String(test) === '[object z]';
1098
1099},{"../internals/well-known-symbol":66}],61:[function(require,module,exports){
1100'use strict';
1101var $String = String;
1102
1103module.exports = function (argument) {
1104  try {
1105    return $String(argument);
1106  } catch (error) {
1107    return 'Object';
1108  }
1109};
1110
1111},{}],62:[function(require,module,exports){
1112'use strict';