https://www.frandroid.com/wp-content/themes/humanoid-redesign/dist…umanoidfr-cash-dom-vD7AqXygL_cVzk_8zi3yt.js

1!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._posthogChunkIds=e._posthogChunkIds||{},e._posthogChunkIds[n]="01a0cd79-2a16-7d00-b365-fb2465d82c85")}catch(e){}}();import { d as domReady } from "./wordpress-dom-ready-va-j_DcZ-xxc3hbE_tB8c.js";
2const doc = document;
3const win = window;
4const docEle = doc.documentElement;
5const createElement = doc.createElement.bind(doc);
6const div = createElement("div");
7const table = createElement("table");
8const tbody = createElement("tbody");
9const tr = createElement("tr");
10const { isArray, prototype: ArrayPrototype } = Array;
11const { concat, filter, indexOf, map, push, slice, some, splice } = ArrayPrototype;
12const idRe = /^#(?:[\w-]|\\.|[^\x00-\xa0])*$/;
13const classRe = /^\.(?:[\w-]|\\.|[^\x00-\xa0])*$/;
14const htmlRe = /<.+>/;
15const tagRe = /^\w+$/;
16const input = {
17  ":input": "input, textarea, select, button",
18  ":button": "button"
19};
20function find(selector, context) {
21  return !selector || !isDocument(context) && !isElement(context) ? [] : classRe.test(selector) ? context.getElementsByClassName(selector.slice(1)) : tagRe.test(selector) ? context.getElementsByTagName(selector) : input[selector] ? context.querySelectorAll(input[selector]) : context.querySelectorAll(selector.replace(/(\[[^=]+=)([^"\]]+)(])/, '$1"$2"$3'));
22}
23class Cash {
24  constructor(selector, context) {
25    if (!selector)
26      return;
27    if (isCash(selector))
28      return selector;
29    let eles = selector;
30    if (isString(selector)) {
31      const ctx = context || doc;
32      eles = idRe.test(selector) && isDocument(ctx) ? ctx.getElementById(selector.slice(1).replace(/\\/g, "")) : htmlRe.test(selector) ? parseHTML(selector) : isCash(ctx) ? ctx.find(selector) : isString(ctx) ? cash(ctx).find(selector) : find(selector, ctx);
33      if (!eles)
34        return;
35    } else if (isFunction(selector)) {
36      return this.ready(selector);
37    }
38    if (eles.nodeType || eles === win)
39      eles = [eles];
40    this.length = eles.length;
41    for (let i = 0, l = this.length; i < l; i++) {
42      this[i] = eles[i];
43    }
44  }
45  init(selector, context) {
46    return new Cash(selector, context);
47  }
48}
49const fn = Cash.prototype;
50const cash = fn.init;
51cash.fn = cash.prototype = fn;
52fn.length = 0;
53fn.splice = splice;
54if (typeof Symbol === "function") {
55  fn[Symbol["iterator"]] = ArrayPrototype[Symbol["iterator"]];
56}
57function isCash(value) {
58  return value instanceof Cash;
59}
60function isWindow(value) {
61  return !!value && value === value.window;
62}
63function isDocument(value) {
64  return !!value && value.nodeType === 9;
65}
66function isElement(value) {
67  return !!value && value.nodeType === 1;
68}
69function isText(value) {
70  return !!value && value.nodeType === 3;
71}
72function isBoolean(value) {
73  return typeof value === "boolean";
74}
75function isFunction(value) {
76  return typeof value === "function";
77}
78function isString(value) {
79  return typeof value === "string";
80}
81function isUndefined(value) {
82  return value === void 0;
83}
84function isNull(value) {
85  return value === null;
86}
87function isNumeric(value) {
88  return !isNaN(parseFloat(value)) && isFinite(value);
89}
90function isPlainObject(value) {
91  if (typeof value !== "object" || value === null)
92    return false;
93  const proto = Object.getPrototypeOf(value);
94  return proto === null || proto === Object.prototype;
95}
96cash.isWindow = isWindow;
97cash.isFunction = isFunction;
98cash.isArray = isArray;
99cash.isNumeric = isNumeric;
100cash.isPlainObject = isPlainObject;
101function each(arr, callback, _reverse) {
102  if (_reverse) {
103    let i = arr.length;
104    while (i--) {
105      if (callback.call(arr[i], i, arr[i]) === false)
106        return arr;
107    }
108  } else if (isPlainObject(arr)) {
109    const keys = Object.keys(arr);
110    for (let i = 0, l = keys.length; i < l; i++) {
111      const key = keys[i];
112      if (callback.call(arr[key], key, arr[key]) === false)
113        return arr;
114    }
115  } else {
116    for (let i = 0, l = arr.length; i < l; i++) {
117      if (callback.call(arr[i], i, arr[i]) === false)
118        return arr;
119    }
120  }
121  return arr;
122}
123cash.each = each;
124fn.each = function(callback) {
125  return each(this, callback);
126};
127fn.empty = function() {
128  return this.each((i, ele) => {
129    while (ele.firstChild) {
130      ele.removeChild(ele.firstChild);
131    }
132  });
133};
134function extend(...sources) {
135  const deep = isBoolean(sources[0]) ? sources.shift() : false;

136  const target = sources.shift();
137  const length = sources.length;
138  if (!target)
139    return {};
140  if (!length)
141    return extend(deep, cash, target);
142  for (let i = 0; i < length; i++) {
143    const source = sources[i];
144    for (const key in source) {
145      if (deep && (isArray(source[key]) || isPlainObject(source[key]))) {
146        if (!target[key] || target[key].constructor !== source[key].constructor)
147          target[key] = new source[key].constructor();
148        extend(deep, target[key], source[key]);
149      } else {
150        target[key] = source[key];
151      }
152    }
153  }
154  return target;
155}
156cash.extend = extend;
157fn.extend = function(plugins) {
158  return extend(fn, plugins);
159};
160const splitValuesRe = /\S+/g;
161function getSplitValues(str) {
162  return isString(str) ? str.match(splitValuesRe) || [] : [];
163}
164fn.toggleClass = function(cls, force) {
165  const classes = getSplitValues(cls);
166  const isForce = !isUndefined(force);
167  return this.each((i, ele) => {
168    if (!isElement(ele))
169      return;
170    each(classes, (i2, c) => {
171      if (isForce) {
172        force ? ele.classList.add(c) : ele.classList.remove(c);
173      } else {
174        ele.classList.toggle(c);
175      }
176    });
177  });
178};
179fn.addClass = function(cls) {
180  return this.toggleClass(cls, true);
181};
182fn.removeAttr = function(attr2) {
183  const attrs = getSplitValues(attr2);
184  return this.each((i, ele) => {
185    if (!isElement(ele))
186      return;
187    each(attrs, (i2, a) => {
188      ele.removeAttribute(a);
189    });
190  });
191};
192function attr(attr2, value) {
193  if (!attr2)
194    return;
195  if (isString(attr2)) {
196    if (arguments.length < 2) {
197      if (!this[0] || !isElement(this[0]))
198        return;
199      const value2 = this[0].getAttribute(attr2);
200      return isNull(value2) ? void 0 : value2;
201    }
202    if (isUndefined(value))
203      return this;
204    if (isNull(value))
205      return this.removeAttr(attr2);
206    return this.each((i, ele) => {
207      if (!isElement(ele))
208        return;
209      ele.setAttribute(attr2, value);
210    });
211  }
212  for (const key in attr2) {
213    this.attr(key, attr2[key]);
214  }
215  return this;
216}
217fn.attr = attr;
218fn.removeClass = function(cls) {
219  if (arguments.length)
220    return this.toggleClass(cls, false);
221  return this.attr("class", "");
222};
223fn.hasClass = function(cls) {
224  return !!cls && some.call(this, (ele) => isElement(ele) && ele.classList.contains(cls));
225};
226fn.get = function(index) {
227  if (isUndefined(index))
228    return slice.call(this);
229  index = Number(index);
230  return this[index < 0 ? index + this.length : index];
231};
232fn.eq = function(index) {
233  return cash(this.get(index));
234};
235fn.first = function() {
236  return this.eq(0);
237};
238fn.last = function() {
239  return this.eq(-1);
240};
241function text(text2) {
242  if (isUndefined(text2)) {
243    return this.get().map((ele) => isElement(ele) || isText(ele) ? ele.textContent : "").join("");
244  }
245  return this.each((i, ele) => {
246    if (!isElement(ele))
247      return;
248    ele.textContent = text2;
249  });
250}
251fn.text = text;
252function computeStyle(ele, prop, isVariable) {
253  if (!isElement(ele))
254    return;
255  const style2 = win.getComputedStyle(ele, null);
256  return isVariable ? style2.getPropertyValue(prop) || void 0 : style2[prop] || ele.style[prop];
257}
258function computeStyleInt(ele, prop) {
259  return parseInt(computeStyle(ele, prop), 10) || 0;
260}
261function getExtraSpace(ele, xAxis) {
262  return computeStyleInt(ele, `border${xAxis ? "Left" : "Top"}Width`) + computeStyleInt(ele, `padding${xAxis ? "Left" : "Top"}`) + computeStyleInt(ele, `padding${xAxis ? "Right" : "Bottom"}`) + computeStyleInt(ele, `border${xAxis ? "Right" : "Bottom"}Width`);
263}
264const defaultDisplay = {};
265function getDefaultDisplay(tagName) {
266  if (defaultDisplay[tagName])
267    return defaultDisplay[tagName];
268  const ele = createElement(tagName);
269  doc.body.insertBefore(ele, null);
270  const display = computeStyle(ele, "display");
271  doc.body.removeChild(ele);
272  return defaultDisplay[tagName] = display !== "none" ? display : "block";
273}
274function isHidden(ele) {
275  return computeStyle(ele, "display") === "none";
276}
277function matches(ele, selector) {
278  const matches2 = ele && (ele["matches"] || ele["webkitMatchesSelector"] || ele["msMatchesSelector"]);
279  if (selector === ":visible") {
280    return !!(ele.offsetWidth || ele.offsetHeight || ele.getClientRects().length);
281  } else if (selector === ":hidden") {
282    return !(ele.offsetWidth || ele.offsetHeight || ele.getClientRects().length);
283  }
284  return !!matches2 && !!selector && matches2.call(ele, selector);
285}
286function getCompareFunction(comparator) {
287  return isString(comparator) ? (i, ele) => matches(ele, comparator) : isFunction(comparator) ? comparator : isCash(comparator) ? (i, ele) => comparator.is(ele) : !comparator ? () => false : (i, ele) => ele === comparator;
288}
289fn.filter = function(comparator) {
290  const compare = getCompareFunction(comparator);
291  return cash(filter.call(this, (ele, i) => compare.call(ele, i, ele)));
292};
293function filtered(collection, comparator) {
294  return !comparator ? collection : collection.filter(comparator);
295}
296fn.detach = function(comparator) {
297  filtered(this, comparator).each((i, ele) => {
298    if (ele.parentNode) {
299      ele.parentNode.removeChild(ele);
300    }
301  });
302  return this;
303};
304const fragmentRe = /^\s*<(\w+)[^>]*>/;
305const singleTagRe = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
306const containers = {
307  "*": div,
308  tr: tbody,
309  td: tr,
310  th: tr,
311  thead: table,
312  tbody: table,
313  tfoot: table
314};
315function parseHTML(html2) {
316  if (!isString(html2))
317    return [];
318  if (singleTagRe.test(html2))
319    return [createElement(RegExp.$1)];
320  const fragment = fragmentRe.test(html2) && RegExp.$1;
321  const container = containers[fragment] || containers["*"];
322  container.innerHTML = html2;
323  return cash(container.childNodes).detach().get();
324}
325cash.parseHTML = parseHTML;
326fn.has = function(selector) {
327  const comparator = isString(selector) ? (i, ele) =>

327 find(selector, ele).length : (i, ele) => ele.contains(selector);
328  return this.filter(comparator);
329};
330fn.not = function(comparator) {
331  const compare = getCompareFunction(comparator);
332  return this.filter((i, ele) => (!isString(comparator) || isElement(ele)) && !compare.call(ele, i, ele));
333};
334function pluck(arr, prop, deep, until) {
335  const plucked = [];
336  const isCallback = isFunction(prop);
337  const compare = until && getCompareFunction(until);
338  for (let i = 0, l = arr.length; i < l; i++) {
339    if (isCallback) {
340      const val2 = prop(arr[i]);
341      if (val2.length)
342        push.apply(plucked, val2);
343    } else {
344      let val2 = arr[i][prop];
345      while (val2 != null) {
346        if (until && compare(-1, val2))
347          break;
348        plucked.push(val2);
349        val2 = deep ? val2[prop] : null;
350      }
351    }
352  }
353  return plucked;
354}
355function getValue(ele) {
356  if (ele.multiple && ele.options)
357    return pluck(filter.call(ele.options, (option) => option.selected && !option.disabled && !option.parentNode.disabled), "value");
358  return ele.value || "";
359}
360function val(value) {
361  if (!arguments.length)
362    return this[0] && getValue(this[0]);
363  return this.each((i, ele) => {
364    const isSelect = ele.multiple && ele.options;
365    if (isSelect || checkableRe.test(ele.type)) {
366      const eleValue = isArray(value) ? map.call(value, String) : isNull(value) ? [] : [String(value)];
367      if (isSelect) {
368        each(ele.options, (i2, option) => {
369          option.selected = eleValue.indexOf(option.value) >= 0;
370        }, true);
371      } else {
372        ele.checked = eleValue.indexOf(ele.value) >= 0;
373      }
374    } else {
375      ele.value = isUndefined(value) || isNull(value) ? "" : value;
376    }
377  });
378}
379fn.val = val;
380fn.is = function(comparator) {
381  const compare = getCompareFunction(comparator);
382  return some.call(this, (ele, i) => compare.call(ele, i, ele));
383};
384cash.guid = 1;
385function unique(arr) {
386  return arr.length > 1 ? filter.call(arr, (item, index, self) => indexOf.call(self, item) === index) : arr;
387}
388cash.unique = unique;
389fn.add = function(selector, context) {
390  return cash(unique(this.get().concat(cash(selector, context).get())));
391};
392fn.children = function(comparator) {
393  return filtered(cash(unique(pluck(this, (ele) => ele.children))), comparator);
394};
395fn.parent = function(comparator) {
396  return filtered(cash(unique(pluck(this, "parentNode"))), comparator);
397};
398fn.index = function(selector) {
399  const child = selector ? cash(selector)[0] : this[0];
400  const collection = selector ? this : cash(child).parent().children();
401  return indexOf.call(collection, child);
402};
403fn.closest = function(comparator) {
404  const filtered2 = this.filter(comparator);
405  if (filtered2.length)
406    return filtered2;
407  const $parent = this.parent();
408  if (!$parent.length)
409    return filtered2;
410  return $parent.closest(comparator);
411};
412fn.siblings = function(comparator) {
413  return filtered(cash(unique(pluck(this, (ele) => cash(ele).parent().children().not(ele)))), comparator);
414};
415fn.find = function(selector) {
416  return cash(unique(pluck(this, (ele) => find(selector, ele))));
417};
418const HTMLCDATARe = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
419const scriptTypeRe = /^$|^module$|\/(java|ecma)script/i;
420const scriptAttributes = ["type", "src", "nonce", "noModule"];
421function evalScripts(node, doc2) {
422  const collection = cash(node);
423  collection.filter("script").add(collection.find("script")).each((i, ele) => {
424    if (scriptTypeRe.test(ele.type) && docEle.contains(ele)) {
425      const script = createElement("script");
426      script.text = ele.textContent.replace(HTMLCDATARe, "");
427      each(scriptAttributes, (i2, attr2) => {
428        if (ele[attr2])
429          script[attr2] = ele[attr2];
430      });
431      doc2.head.insertBefore(script, null);
432      doc2.head.removeChild(script);
433    }
434  });
435}
436function insertElement(anchor, target, left, inside, evaluate) {
437  if (inside) {
438    anchor.insertBefore(target, left ? anchor.firstChild : null);
439  } else {
440    if (anchor.nodeName === "HTML") {
441      anchor.parentNode.replaceChild(target, anchor);
442    } else {
443      anchor.parentNode.insertBefore(target, left ? anchor : anchor.nextSibling);
444    }
445  }
446  if (evaluate) {
447    evalScripts(target, anchor.ownerDocument);
448  }
449}
450function insertSelectors(selectors, anchors, inverse, left, inside, reverseLoop1, reverseLoop2, reverseLoop3) {
451  each(selectors, (si, selector) => {
452    each(cash(selector), (ti, target) => {
453      each(cash(anchors), (ai, anchor) => {
454        const anchorFinal = inverse ? target : anchor;
455        const targetFinal = inverse ? anchor : target;
456        const indexFinal = inverse ? ti : ai;
457        insertElement(anchorFinal, !indexFinal ? targetFinal : targetFinal.cloneNode(true), left, inside, !indexFinal);
458      }, reverseLoop3);
459    }, reverseLoop2);
460  }, reverseLoop1);
461  return anchors;
462}
463fn.after = function() {
464  return insertSelectors(arguments, this, false, false, false, true, true);
465};
466fn.append = function() {
467  return insertSelectors(arguments, this, false, false, true);
468};
469function html(html2) {
470  if (!arguments.length)
471    return this[0] && this[0].innerHTML;
472  if (isUndefined(html2))
473    return this;
474  const hasScript = /<script[\s>]/.test(html2);
475  return this.each((i, ele) => {
476    if (!isElement(ele))
477      return;
478    if (hasScript) {
479      cash(ele).empty().append(html2);
480    } else {
481      ele.innerHTML = html2;
482    }
483  });
484}
485fn.html = html;
486fn.appendTo = function(selector) {
487  return insertSelectors(arguments, this, true, false, true);
488};
489fn.wrapInner = function(selector) {
490  return this.each((i, ele) => {
491    const $ele = cash(ele);
492    const contents = $ele.contents();
493    contents.length ? contents.wrapAll(selector) : $ele.append(selector);
494  });
495};
496fn.before = function() {
497  return insertSelectors(arguments, this, false, true);
498};
499fn.wrapAll = function(selector) {
500  let structure = cash(selector);
501  let wrapper = structure[0];
502  while (wrapper.children.length)
503    wrapper = wrapper.firstElementChild;
504  this.first().before(structure);
505  return this.appendTo(wrapper);
506};
507fn.wrap = function(selector) {
508  return this.each((i, ele) => {
509    const wrapper = cash(selector)[0];
510    cash(ele).wrapAll(!i ? wrapper : wrapper.cloneNode(true));
511  });
512};
513fn.insertAfter = function(selector) {
514  return insertSelectors(arguments, this, true, false, false, false, false, true);
515};
516fn.insertBefore = function(selector) {
517  return insertSelectors(arguments, this, true, true);
518};
519fn.prepend = function() {
520  return insertSelectors(arguments, this, false, true, true, true, true);
521};
522fn.prependTo = function(selector) {
523  return insertSelectors(arguments, this, true, true, true, false, false, true);
524};
525fn.contents = function() {
526  return cash(unique(pluck(this, (ele) => ele.tagName === "IFRAME" ? [ele.contentDocument] : ele.tagName === "TEMPLATE" ? ele.content.childNodes : ele.childNodes)));
527};
528fn.next = function(comparator, _all, _until) {
529  return filtered(cash(unique(pluck(this, "nextElementSibling", _all, _until))), comparator);
530};
531fn.nextAll = function(comparator) {
532  return this.next(comparator, true);
533};
534fn.nextUntil = function(until, comparator) {
535  return this.next(comparator, true, until);
536};
537fn.parents = function(comparator, _until) {
538  return filtered(cash(unique(pluck(this, "parentElement", true, _until))), comparator);
539};
540fn.parentsUntil = function(until, comparator) {
541  return this.parents(comparator, until);
542};
543fn.prev = function(comparator, _all, _until) {
544  return filtered(cash(unique(pluck(this, "previousElementSibling", _all, _until))), comparator);
545};
546fn.prevAll = function(comparator) {
547  return this.prev(comparator, true);
548};
549fn.prevUntil = function(until, comparator) {
550  return this.prev(comparator, true, until);
551};
552fn.map = function(callback) {
553  return cash(concat.apply([], map.call(this, (ele, i) => callback.call(ele, i, ele))));
554};
555fn.clone = function() {
556  return this.map((i, ele) => ele.cloneNode(true));
557};
558fn.offsetParent = function() {
559  return this.map((i, ele) => {
560    let offsetParent = ele.offsetParent;
561    while (offsetParent && computeStyle(offsetParent, "position") === "static") {
562      offsetParent = offsetParent.offsetParent;
563    }
564    return offsetParent || docEle;
565  });
566};
567fn.slice = function(start, end) {
568  return cash(slice.call(this, start, end));
569};

570const dashAlphaRe = /-([a-z])/g;
571function camelCase(str) {
572  return str.replace(dashAlphaRe, (match, letter) => letter.toUpperCase());
573}
574fn.ready = function(callback) {
575  const cb = () => setTimeout(callback, 0, cash);
576  if (doc.readyState !== "loading") {
577    cb();
578  } else {
579    doc.addEventListener("DOMContentLoaded", cb);
580  }
581  return this;
582};
583fn.unwrap = function() {
584  this.parent().each((i, ele) => {
585    if (ele.tagName === "BODY")
586      return;
587    const $ele = cash(ele);
588    $ele.replaceWith($ele.children());
589  });
590  return this;
591};
592fn.offset = function() {
593  const ele = this[0];
594  if (!ele)
595    return;
596  const rect = ele.getBoundingClientRect();
597  return {
598    top: rect.top + win.pageYOffset,
599    left: rect.left + win.pageXOffset
600  };
601};
602fn.position = function() {
603  const ele = this[0];
604  if (!ele)
605    return;
606  const isFixed = computeStyle(ele, "position") === "fixed";
607  const offset = isFixed ? ele.getBoundingClientRect() : this.offset();
608  if (!isFixed) {
609    const doc2 = ele.ownerDocument;
610    let offsetParent = ele.offsetParent || doc2.documentElement;
611    while ((offsetParent === doc2.body || offsetParent === doc2.documentElement) && computeStyle(offsetParent, "position") === "static") {
612      offsetParent = offsetParent.parentNode;
613    }
614    if (offsetParent !== ele && isElement(offsetParent)) {
615      const parentOffset = cash(offsetParent).offset();
616      offset.top -= parentOffset.top + computeStyleInt(offsetParent, "borderTopWidth");
617      offset.left -= parentOffset.left + computeStyleInt(offsetParent, "borderLeftWidth");
618    }
619  }
620  return {
621    top: offset.top - computeStyleInt(ele, "marginTop"),
622    left: offset.left - computeStyleInt(ele, "marginLeft")
623  };
624};
625const propMap = {
626  /* GENERAL */
627  class: "className",
628  contenteditable: "contentEditable",
629  /* LABEL */
630  for: "htmlFor",
631  /* INPUT */
632  readonly: "readOnly",
633  maxlength: "maxLength",
634  tabindex: "tabIndex",
635  /* TABLE */
636  colspan: "colSpan",
637  rowspan: "rowSpan",
638  /* IMAGE */
639  usemap: "useMap"
640};
641fn.prop = function(prop, value) {
642  if (!prop)
643    return;
644  if (isString(prop)) {
645    prop = propMap[prop] || prop;
646    if (arguments.length < 2)
647      return this[0] && this[0][prop];
648    return this.each((i, ele) => {
649      ele[prop] = value;
650    });
651  }
652  for (const key in prop) {
653    this.prop(key, prop[key]);
654  }
655  return this;
656};
657fn.removeProp = function(prop) {
658  return this.each((i, ele) => {
659    delete ele[propMap[prop] || prop];
660  });
661};
662const cssVariableRe = /^--/;
663function isCSSVariable(prop) {
664  return cssVariableRe.test(prop);
665}
666const prefixedProps = {};
667const { style } = div;
668const vendorsPrefixes = ["webkit", "moz", "ms"];
669function getPrefixedProp(prop, isVariable = isCSSVariable(prop)) {
670  if (isVariable)
671    return prop;
672  if (!prefixedProps[prop]) {
673    const propCC = camelCase(prop);
674    const propUC = `${propCC[0].toUpperCase()}${propCC.slice(1)}`;
675    const props = `${propCC} ${vendorsPrefixes.join(`${propUC} `)}${propUC}`.split(" ");
676    each(props, (i, p) => {
677      if (p in style) {
678        prefixedProps[prop] = p;
679        return false;
680      }
681    });
682  }
683  return prefixedProps[prop];
684}
685const numericProps = {
686  animationIterationCount: true,
687  columnCount: true,
688  flexGrow: true,
689  flexShrink: true,
690  fontWeight: true,
691  gridArea: true,
692  gridColumn: true,
693  gridColumnEnd: true,
694  gridColumnStart: true,
695  gridRow: true,
696  gridRowEnd: true,
697  gridRowStart: true,
698  lineHeight: true,
699  opacity: true,
700  order: true,
701  orphans: true,
702  widows: true,
703  zIndex: true
704};
705function getSuffixedValue(prop, value, isVariable = isCSSVariable(prop)) {
706  return !isVariable && !numericProps[prop] && isNumeric(value) ? `${value}px` : value;
707}
708function css(prop, value) {
709  if (isString(prop)) {
710    const isVariable = isCSSVariable(prop);
711    prop = getPrefixedProp(prop, isVariable);
712    if (arguments.length < 2)
713      return this[0] && computeStyle(this[0], prop, isVariable);
714    if (!prop)
715      return this;
716    value = getSuffixedValue(prop, value, isVariable);
717    return this.each((i, ele) => {
718      if (!isElement(ele))
719        return;
720      if (isVariable) {
721        ele.style.setProperty(prop, value);
722      } else {
723        ele.style[prop] = value;
724      }
725    });
726  }
727  for (const key in prop) {
728    this.css(key, prop[key]);
729  }
730  return this;
731}
732fn.css = css;
733function attempt(fn2, arg) {
734  try {
735    return fn2(arg);
736  } catch (_a) {
737    return arg;
738  }
739}
740const JSONStringRe = /^\s+|\s+$/;
741function getData$1(ele, key) {
742  const value = ele.dataset[key] || ele.dataset[camelCase(key)];
743  if (JSONStringRe.test(value))
744    return value;
745  return attempt(JSON.parse, value);
746}
747function setData$1(ele, key, value) {
748  value = attempt(JSON.stringify, value);
749  ele.dataset[camelCase(key)] = value;
750}
751function data(name, value) {
752  if (!name) {
753    if (!this[0])
754      return;
755    const datas = {};
756    for (const key in this[0].dataset) {
757      datas[key] = getData$1(this[0], key);
758    }
759    return datas;
760  }
761  if (isString(name)) {
762    if (arguments.length < 2)
763      return this[0] && getData$1(this[0], name);
764    if (isUndefined(value))
765      return this;
766    return this.each((i, ele) => {
767      setData$1(ele, name, value);
768    });
769  }
770  for (const key in name) {
771    this.data(key, name[key]);
772  }
773  return this;
774}
775fn.data = data;
776function getDocumentDimension(doc2, dimension) {
777  const docEle2 = doc2.documentElement;
778  return Math.max(doc2.body[`scroll${dimension}`], docEle2[`scroll${dimension}`], doc2.body[`offset${dimension}`], docEle2[`offset${dimension}`], docEle2[`client${dimension}`]);
779}
780each([true, false], (i, outer) => {
781  each(["Width", "Height"], (i2, prop) => {
782    const name = `${outer ? "outer" : "inner"}${prop}`;
783    fn[name] = function(includeMargins) {
784      if (!this[0])
785        return;
786      if (isWindow(this[0]))
787        return outer ? this[0][`inner${prop}`] : this[0].document.documentElement[`client${prop}`];
788      if (isDocument(this[0]))
789        return getDocumentDimension(this[0], prop);
790      return this[0][`${outer ? "offset" : "client"}${prop}`] + (includeMargins && outer ? computeStyleInt(this[0], `margin${i2 ? "Top" : "Left"}`) + computeStyleInt(this[0], `margin${i2 ? "Bottom" : "Right"}`) : 0);
791    };
792  });
793});
794each(["Width", "Height"], (index, prop) => {
795  const propLC = prop.toLowerCase();
796  fn[propLC] = function(value) {
797    if (!this[0])
798      return isUndefined(value) ? void 0 : this;
799    if (!arguments.length) {
800      if (isWindow(this[0]))
801        return this[0].document.documentElement[`client${prop}`];
802      if (isDocument(this[0]))
803        return getDocumentDimension(this[0], prop);
804      return this[0].getBoundingClientRect()[propLC] - getExtraSpace(this[0], !index);
805    }
806    const valueNumber = parseInt(value, 10);
807    return this.each((i, ele) => {
808      if (!isElement(ele))
809        return;
810      const boxSizing = computeStyle(ele, "boxSizing");
811      ele.style[propLC] = getSuffixedValue(propLC, valueNumber + (boxSizing === "border-box" ? getExtraSpace(ele, !index) : 0));
812    });
813  };
814});
815const displayProperty = "___cd";
816fn.toggle = function(force) {
817  return this.each((i, ele) => {
818    if (!isElement(ele))
819      return;
820    const hidden = isHidden(ele);
821    const show = isUndefined(force) ? hidden : force;
822    if (show) {
823      ele.style.display = ele[displayProperty] || "";
824      if (isHidden(ele)) {
825        ele.style.display = getDefaultDisplay(ele.tagName);
826      }
827    }

827 else if (!hidden) {
828      ele[displayProperty] = computeStyle(ele, "display");
829      ele.style.display = "none";
830    }
831  });
832};
833fn.hide = function() {
834  return this.toggle(false);
835};
836fn.show = function() {
837  return this.toggle(true);
838};
839const eventsNamespace = "___ce";
840const eventsNamespacesSeparator = ".";
841const eventsFocus = { focus: "focusin", blur: "focusout" };
842const eventsHover = { mouseenter: "mouseover", mouseleave: "mouseout" };
843const eventsMouseRe = /^(mouse|pointer|contextmenu|drag|drop|click|dblclick)/i;
844function getEventNameBubbling(name) {
845  return eventsHover[name] || eventsFocus[name] || name;
846}
847function parseEventName(eventName) {
848  const parts = eventName.split(eventsNamespacesSeparator);
849  return [parts[0], parts.slice(1).sort()];
850}
851fn.trigger = function(event, data2) {
852  if (isString(event)) {
853    const [nameOriginal, namespaces] = parseEventName(event);
854    const name = getEventNameBubbling(nameOriginal);
855    if (!name)
856      return this;
857    const type = eventsMouseRe.test(name) ? "MouseEvents" : "HTMLEvents";
858    event = doc.createEvent(type);
859    event.initEvent(name, true, true);
860    event.namespace = namespaces.join(eventsNamespacesSeparator);
861    event.___ot = nameOriginal;
862  }
863  event.___td = data2;
864  event.___array = Array.isArray(data2);
865  const isEventFocus = event.___ot in eventsFocus;
866  return this.each((i, ele) => {
867    if (isEventFocus && isFunction(ele[event.___ot])) {
868      ele[`___i${event.type}`] = true;
869      ele[event.___ot]();
870      ele[`___i${event.type}`] = false;
871    }
872    ele.dispatchEvent(event);
873  });
874};
875function getEventsCache(ele) {
876  return ele[eventsNamespace] = ele[eventsNamespace] || {};
877}
878function addEvent(ele, name, namespaces, selector, callback) {
879  const eventCache = getEventsCache(ele);
880  eventCache[name] = eventCache[name] || [];
881  eventCache[name].push([namespaces, selector, callback]);
882  ele.addEventListener(name, callback);
883}
884function hasNamespaces(ns1, ns2) {
885  return !ns2 || !some.call(ns2, (ns) => ns1.indexOf(ns) < 0);
886}
887function removeEvent(ele, name, namespaces, selector, callback) {
888  const cache = getEventsCache(ele);
889  if (!name) {
890    for (name in cache) {
891      removeEvent(ele, name, namespaces, selector, callback);
892    }
893  } else if (cache[name]) {
894    cache[name] = cache[name].filter(([ns, sel, cb]) => {
895      if (callback && cb.guid !== callback.guid || !hasNamespaces(ns, namespaces) || selector && selector !== sel)
896        return true;
897      ele.removeEventListener(name, cb);
898    });
899  }
900}
901fn.off = function(eventFullName, selector, callback) {
902  if (isUndefined(eventFullName)) {
903    this.each((i, ele) => {
904      if (!isElement(ele) && !isDocument(ele) && !isWindow(ele))
905        return;
906      removeEvent(ele);
907    });
908  } else if (!isString(eventFullName)) {
909    for (const key in eventFullName) {
910      this.off(key, eventFullName[key]);
911    }
912  } else {
913    if (isFunction(selector)) {
914      callback = selector;
915      selector = "";
916    }
917    each(getSplitValues(eventFullName), (i, eventFullName2) => {
918      const [nameOriginal, namespaces] = parseEventName(eventFullName2);
919      const name = getEventNameBubbling(nameOriginal);
920      this.each((i2, ele) => {
921        if (!isElement(ele) && !isDocument(ele) && !isWindow(ele))
922          return;
923        removeEvent(ele, name, namespaces, selector, callback);
924      });
925    });
926  }
927  return this;
928};
929fn.remove = function(comparator) {
930  filtered(this, comparator).detach().off();
931  return this;
932};
933fn.replaceWith = function(selector) {
934  return this.before(selector).remove();
935};
936fn.replaceAll = function(selector) {
937  cash(selector).replaceWith(this);
938  return this;
939};
940function on(eventFullName, selector, data2, callback, _one) {
941  if (!isString(eventFullName)) {
942    for (const key in eventFullName) {
943      this.on(key, selector, data2, eventFullName[key], _one);
944    }
945    return this;
946  }
947  if (!isString(selector)) {
948    if (isUndefined(selector) || isNull(selector)) {
949      selector = "";
950    } else if (isUndefined(data2)) {
951      data2 = selector;
952      selector = "";
953    } else {
954      callback = data2;
955      data2 = selector;
956      selector = "";
957    }
958  }
959  if (!isFunction(callback)) {
960    callback = data2;
961    data2 = void 0;
962  }
963  if (!callback)
964    return this;
965  each(getSplitValues(eventFullName), (i, eventFullName2) => {
966    const [nameOriginal, namespaces] = parseEventName(eventFullName2);
967    const name = getEventNameBubbling(nameOriginal);
968    const isEventHover = nameOriginal in eventsHover;
969    const isEventFocus = nameOriginal in eventsFocus;
970    if (!name)
971      return;
972    this.each((i2, ele) => {
973      if (!isElement(ele) && !isDocument(ele) && !isWindow(ele))
974        return;
975      const finalCallback = function(event) {
976        if (event.target[`___i${event.type}`])
977          return event.stopImmediatePropagation();
978        if (event.namespace && !hasNamespaces(namespaces, event.namespace.split(eventsNamespacesSeparator)))
979          return;
980        if (!selector && (isEventFocus && (event.target !== ele || event.___ot === name) || isEventHover && event.relatedTarget && ele.contains(event.relatedTarget)))
981          return;
982        let thisArg = ele;
983        if (selector) {
984          let target = event.target;
985          while (!matches(target, selector)) {
986            if (target === ele)
987              return;
988            target = target.parentNode;
989            if (!target)
990              return;
991          }
992          thisArg = target;
993        }
994        Object.defineProperty(event, "currentTarget", {
995          configurable: true,
996          get() {
997            return thisArg;
998          }
999        });
1000        Object.defineProperty(event, "delegateTarget", {
1001          configurable: true,
1002          get() {
1003            return ele;
1004          }
1005        });
1006        Object.defineProperty(event, "data", {
1007          configurable: true,
1008          get() {
1009            return data2;
1010          }
1011        });
1012        let returnValue = null;
1013        if (Array.isArray(event.___td) && event.___array) {
1014          returnValue = callback.call(thisArg, event, ...event.___td);
1015        } else {
1016          returnValue = callback.call(thisArg, event, event.___td);
1017        }
1018        if (_one) {
1019          removeEvent(ele, name, namespaces, selector, finalCallback);
1020        }
1021        if (returnValue === false) {
1022          event.preventDefault();
1023          event.stopPropagation();
1024        }
1025      };
1026      finalCallback.guid = callback.guid = callback.guid || cash.guid++;
1027      addEvent(ele, name, namespaces, selector, finalCallback);
1028    });
1029  });
1030  return this;
1031}
1032fn.on = on;
1033function one(eventFullName, selector, data2, callback) {
1034  return this.on(eventFullName, selector, data2, callback, true);
1035}
1036fn.one = one;
1037const queryEncodeCRLFRe = /\r?\n/g;
1038function queryEncode(prop, value) {
1039  return `&${encodeURIComponent(prop)}=${encodeURIComponent(value.replace(queryEncodeCRLFRe, "\r\n"))}`;
1040}
1041const skippableRe = /file|reset|submit|button|image/i;
1042const checkableRe = /radio|checkbox/i;
1043fn.serialize = function() {
1044  let query = "";
1045  this.each((i, ele) => {
1046    each(ele.elements || [ele], (i2, ele2) => {
1047      if (ele2.disabled || !ele2.name || ele2.tagName === "FIELDSET" || skippableRe.test(ele2.type) || checkableRe.test(ele2.type) && !ele2.checked)
1048        return;
1049      const value = getValue(ele2);
1050      if (!isUndefined(value)) {
1051        const values = isArray(value) ? value : [value];
1052        each(values, (i3, value2) => {
1053          query += queryEncode(ele2.name, value2);
1054        });
1055      }
1056    });
1057  });
1058  return query.slice(1);
1059};
1060const ledger = /* @__PURE__ */ new WeakMap();
1061function editLedger(wanted, baseElement, callback, setup) {
1062  if (!wanted && !ledger.has(baseElement)) {
1063    return false;

1064  }
1065  const elementMap = ledger.get(baseElement) ?? /* @__PURE__ */ new WeakMap();
1066  ledger.set(baseElement, elementMap);
1067  const setups = elementMap.get(callback) ?? /* @__PURE__ */ new Set();
1068  elementMap.set(callback, setups);
1069  const existed = setups.has(setup);
1070  if (wanted) {
1071    setups.add(setup);
1072  } else {
1073    setups.delete(setup);
1074  }
1075  return existed && wanted;
1076}
1077function safeClosest(event, selector) {
1078  let target = event.target;
1079  if (target instanceof Text) {
1080    target = target.parentElement;
1081  }
1082  if (target instanceof Element && event.currentTarget instanceof Node) {
1083    const closest = target.closest(selector);
1084    if (closest && event.currentTarget.contains(closest)) {
1085      return closest;
1086    }
1087  }
1088}
1089function delegate(selector, type, callback, options = {}) {
1090  if (Array.isArray(type)) {
1091    for (const t of type) {
1092      delegate(selector, t, callback, options);
1093    }
1094    return;
1095  }
1096  const singleType = type;
1097  const { signal, base = document } = options;
1098  if (signal?.aborted) {
1099    return;
1100  }
1101  const { once, ...nativeListenerOptions } = options;
1102  const baseElement = base instanceof Document ? base.documentElement : base;
1103  const capture = Boolean(typeof options === "object" ? options.capture : options);
1104  const listenerFunction = (event) => {
1105    const delegateTarget = safeClosest(event, String(selector));
1106    if (delegateTarget) {
1107      const delegateEvent = Object.assign(event, { delegateTarget });
1108      callback.call(baseElement, delegateEvent);
1109      if (once) {
1110        baseElement.removeEventListener(singleType, listenerFunction, nativeListenerOptions);
1111        editLedger(false, baseElement, callback, setup);
1112      }
1113    }
1114  };
1115  const setup = JSON.stringify({ selector, type: singleType, capture });
1116  const isAlreadyListening = editLedger(true, baseElement, callback, setup);
1117  if (!isAlreadyListening) {
1118    baseElement.addEventListener(singleType, listenerFunction, nativeListenerOptions);
1119  }
1120  signal?.addEventListener("abort", () => {
1121    editLedger(false, baseElement, callback, setup);
1122  });
1123}
1124const runningOnBrowser = typeof window !== "undefined";
1125const isBot = runningOnBrowser && !("onscroll" in window) || typeof navigator !== "undefined" && /(gle|ing|ro)bot|crawl|spider/i.test(navigator.userAgent);
1126const supportsIntersectionObserver = runningOnBrowser && "IntersectionObserver" in window;
1127const supportsClassList = runningOnBrowser && "classList" in document.createElement("p");
1128const isHiDpi = runningOnBrowser && window.devicePixelRatio > 1;
1129const defaultSettings = {
1130  elements_selector: ".lazy",
1131  container: isBot || runningOnBrowser ? document : null,
1132  threshold: 300,
1133  thresholds: null,
1134  data_src: "src",
1135  data_srcset: "srcset",
1136  data_sizes: "sizes",
1137  data_bg: "bg",
1138  data_bg_hidpi: "bg-hidpi",
1139  data_bg_multi: "bg-multi",
1140  data_bg_multi_hidpi: "bg-multi-hidpi",
1141  data_bg_set: "bg-set",
1142  data_poster: "poster",
1143  class_applied: "applied",
1144  class_loading: "loading",
1145  class_loaded: "loaded",
1146  class_error: "error",
1147  class_entered: "entered",
1148  class_exited: "exited",
1149  unobserve_completed: true,
1150  unobserve_entered: false,
1151  cancel_on_exit: true,
1152  callback_enter: null,
1153  callback_exit: null,
1154  callback_applied: null,
1155  callback_loading: null,
1156  callback_loaded: null,
1157  callback_error: null,
1158  callback_finish: null,
1159  callback_cancel: null,
1160  use_native: false,
1161  restore_on_error: false
1162};
1163const getExtendedSettings = (customSettings) => {
1164  return Object.assign({}, defaultSettings, customSettings);
1165};
1166const createInstance = function(classObj, options) {
1167  let event;
1168  const eventString = "LazyLoad::Initialized";
1169  const instance = new classObj(options);
1170  try {
1171    event = new CustomEvent(eventString, { detail: { instance } });
1172  } catch (err) {
1173    event = document.createEvent("CustomEvent");
1174    event.initCustomEvent(eventString, false, false, { instance });
1175  }
1176  window.dispatchEvent(event);
1177};
1178const autoInitialize = (classObj, options) => {
1179  if (!options) {
1180    return;
1181  }
1182  if (!options.length) {
1183    createInstance(classObj, options);
1184  } else {
1185    for (let i = 0, optionsItem; optionsItem = options[i]; i += 1) {
1186      createInstance(classObj, optionsItem);
1187    }
1188  }
1189};
1190const SRC = "src";
1191const SRCSET = "srcset";
1192const SIZES = "sizes";
1193const POSTER = "poster";
1194const ORIGINALS = "llOriginalAttrs";
1195const DATA = "data";
1196const statusLoading = "loading";
1197const statusLoaded = "loaded";
1198const statusApplied = "applied";
1199const statusEntered = "entered";
1200const statusError = "error";
1201const statusNative = "native";
1202const dataPrefix = "data-";
1203const statusDataName = "ll-status";
1204const getData = (element, attribute) => {
1205  return element.getAttribute(dataPrefix + attribute);
1206};
1207const setData = (element, attribute, value) => {
1208  const attrName = dataPrefix + attribute;
1209  if (value === null) {
1210    element.removeAttribute(attrName);
1211    return;
1212  }
1213  element.setAttribute(attrName, value);
1214};
1215const getStatus = (element) => getData(element, statusDataName);
1216const setStatus = (element, status) => setData(element, statusDataName, status);
1217const resetStatus = (element) => setStatus(element, null);
1218const hasEmptyStatus = (element) => getStatus(element) === null;
1219const hasStatusLoading = (element) => getStatus(element) === statusLoading;
1220const hasStatusError = (element) => getStatus(element) === statusError;
1221const hasStatusNative = (element) => getStatus(element) === statusNative;
1222const statusesAfterLoading = [statusLoading, statusLoaded, statusApplied, statusError];
1223const hadStartedLoading = (element) =>

1223 statusesAfterLoading.indexOf(getStatus(element)) >= 0;
1224const safeCallback = (callback, arg1, arg2, arg3) => {
1225  if (!callback || typeof callback !== "function") {
1226    return;
1227  }
1228  if (arg3 !== void 0) {
1229    callback(arg1, arg2, arg3);
1230    return;
1231  }
1232  if (arg2 !== void 0) {
1233    callback(arg1, arg2);
1234    return;
1235  }
1236  callback(arg1);
1237};
1238const addClass = (element, className) => {
1239  if (className === "") {
1240    return;
1241  }
1242  if (supportsClassList) {
1243    element.classList.add(className);
1244    return;
1245  }
1246  element.className += (element.className ? " " : "") + className;
1247};
1248const removeClass = (element, className) => {
1249  if (className === "") {
1250    return;
1251  }
1252  if (supportsClassList) {
1253    element.classList.remove(className);
1254    return;
1255  }
1256  element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ").replace(/^\s+/, "").replace(/\s+$/, "");
1257};
1258const addTempImage = (element) => {
1259  element.llTempImage = document.createElement("IMG");
1260};
1261const deleteTempImage = (element) => {
1262  delete element.llTempImage;
1263};
1264const getTempImage = (element) => element.llTempImage;
1265const unobserve = (element, instance) => {
1266  if (!instance) return;
1267  const observer = instance._observer;
1268  if (!observer) return;
1269  observer.unobserve(element);
1270};
1271const resetObserver = (observer) => {
1272  observer.disconnect();
1273};
1274const unobserveEntered = (element, settings, instance) => {
1275  if (settings.unobserve_entered) unobserve(element, instance);
1276};
1277const updateLoadingCount = (instance, delta) => {
1278  if (!instance) return;
1279  instance.loadingCount += delta;
1280};
1281const decreaseToLoadCount = (instance) => {
1282  if (!instance) return;
1283  instance.toLoadCount -= 1;
1284};
1285const setToLoadCount = (instance, value) => {
1286  if (!instance) return;
1287  instance.toLoadCount = value;
1288};
1289const isSomethingLoading = (instance) => instance.loadingCount > 0;
1290const haveElementsToLoad = (instance) => instance.toLoadCount > 0;
1291const getSourceTags = (parentTag) => {
1292  let sourceTags = [];
1293  for (let i = 0, childTag; childTag = parentTag.children[i]; i += 1) {
1294    if (childTag.tagName === "SOURCE") {
1295      sourceTags.push(childTag);
1296    }
1297  }
1298  return sourceTags;
1299};
1300const forEachPictureSource = (element, fn2) => {
1301  const parent = element.parentNode;
1302  if (!parent || parent.tagName !== "PICTURE") {
1303    return;
1304  }
1305  let sourceTags = getSourceTags(parent);
1306  sourceTags.forEach(fn2);
1307};
1308const forEachVideoSource = (element, fn2) => {
1309  let sourceTags = getSourceTags(element);
1310  sourceTags.forEach(fn2);
1311};
1312const attrsSrc = [SRC];
1313const attrsSrcPoster = [SRC, POSTER];
1314const attrsSrcSrcsetSizes = [SRC, SRCSET, SIZES];
1315const attrsData = [DATA];
1316const hasOriginalAttrs = (element) => !!element[ORIGINALS];
1317const getOriginalAttrs = (element) => element[ORIGINALS];
1318const deleteOriginalAttrs = (element) => delete element[ORIGINALS];
1319const setOriginalsObject = (element, attributes) => {
1320  if (hasOriginalAttrs(element)) {
1321    return;
1322  }
1323  const originals = {};
1324  attributes.forEach((attribute) => {
1325    originals[attribute] = element.getAttribute(attribute);
1326  });
1327  element[ORIGINALS] = originals;
1328};
1329const saveOriginalBackgroundStyle = (element) => {
1330  if (hasOriginalAttrs(element)) {
1331    return;
1332  }
1333  element[ORIGINALS] = { backgroundImage: element.style.backgroundImage };
1334};
1335const setOrResetAttribute = (element, attrName, value) => {
1336  if (!value) {
1337    element.removeAttribute(attrName);
1338    return;
1339  }
1340  element.setAttribute(attrName, value);
1341};
1342const restoreOriginalAttrs = (element, attributes) => {
1343  if (!hasOriginalAttrs(element)) {
1344    return;
1345  }
1346  const originals = getOriginalAttrs(element);
1347  attributes.forEach((attribute) => {
1348    setOrResetAttribute(element, attribute, originals[attribute]);
1349  });
1350};
1351const restoreOriginalBgImage = (element) => {
1352  if (!hasOriginalAttrs(element)) {
1353    return;
1354  }
1355  const originals = getOriginalAttrs(element);
1356  element.style.backgroundImage = originals.backgroundImage;
1357};
1358const manageApplied = (element, settings, instance) => {
1359  addClass(element, settings.class_applied);
1360  setStatus(element, statusApplied);
1361  if (!instance) return;
1362  if (settings.unobserve_completed) {
1363    unobserve(element, settings);
1364  }
1365  safeCallback(settings.callback_applied, element, instance);
1366};
1367const manageLoading = (element, settings, instance) => {
1368  addClass(element, settings.class_loading);
1369  setStatus(element, statusLoading);
1370  if (!instance) return;
1371  updateLoadingCount(instance, 1);
1372  safeCallback(settings.callback_loading, element, instance);
1373};
1374const setAttributeIfValue = (element, attrName, value) => {
1375  if (!value) {
1376    return;
1377  }
1378  element.setAttribute(attrName, value);
1379};
1380const setImageAttributes = (element, settings) => {
1381  setAttributeIfValue(element, SIZES, getData(element, settings.data_sizes));
1382  setAttributeIfValue(element, SRCSET, getData(element, settings.data_srcset));
1383  setAttributeIfValue(element, SRC, getData(element, settings.data_src));
1384};
1385const setSourcesImg = (imgEl, settings) => {
1386  forEachPictureSource(imgEl, (sourceTag) => {
1387    setOriginalsObject(sourceTag, attrsSrcSrcsetSizes);
1388    setImageAttributes(sourceTag, settings);
1389  });
1390  setOriginalsObject(imgEl, attrsSrcSrcsetSizes);
1391  setImageAttributes(imgEl, settings);
1392};
1393const setSourcesIframe = (iframe, settings) => {
1394  setOriginalsObject(iframe, attrsSrc);
1395  setAttributeIfValue(iframe, SRC, getData(iframe, settings.data_src));
1396};
1397const setSourcesVideo = (videoEl, settings) => {
1398  forEachVideoSource(videoEl, (sourceEl) => {
1399    setOriginalsObject(sourceEl, attrsSrc);
1400    setAttributeIfValue(sourceEl, SRC, getData(sourceEl, settings.data_src));
1401  });
1402  setOriginalsObject(videoEl, attrsSrcPoster);
1403  setAttributeIfValue(videoEl, POSTER, getData(videoEl, settings.data_poster));
1404  setAttributeIfValue(videoEl, SRC, getData(videoEl, settings.data_src));
1405  videoEl.load();
1406};
1407const setSourcesObject = (object, settings) => {
1408  setOriginalsObject(object, attrsData);
1409  setAttributeIfValue(object, DATA, getData(object, settings.data_src));
1410};

1411const setBackground = (element, settings, instance) => {
1412  const bg1xValue = getData(element, settings.data_bg);
1413  const bgHiDpiValue = getData(element, settings.data_bg_hidpi);
1414  const bgDataValue = isHiDpi && bgHiDpiValue ? bgHiDpiValue : bg1xValue;
1415  if (!bgDataValue) return;
1416  element.style.backgroundImage = `url("${bgDataValue}")`;
1417  getTempImage(element).setAttribute(SRC, bgDataValue);
1418  manageLoading(element, settings, instance);
1419};
1420const setMultiBackground = (element, settings, instance) => {
1421  const bg1xValue = getData(element, settings.data_bg_multi);
1422  const bgHiDpiValue = getData(element, settings.data_bg_multi_hidpi);
1423  const bgDataValue = isHiDpi && bgHiDpiValue ? bgHiDpiValue : bg1xValue;
1424  if (!bgDataValue) {
1425    return;
1426  }
1427  element.style.backgroundImage = bgDataValue;
1428  manageApplied(element, settings, instance);
1429};
1430const setImgsetBackground = (element, settings, instance) => {
1431  const bgImgSetDataValue = getData(element, settings.data_bg_set);
1432  if (!bgImgSetDataValue) {
1433    return;
1434  }
1435  const imgSetValues = bgImgSetDataValue.split("|");
1436  let bgImageValues = imgSetValues.map((value) => `image-set(${value})`);
1437  element.style.backgroundImage = bgImageValues.join();
1438  if (element.style.backgroundImage === "") {
1439    bgImageValues = imgSetValues.map((value) => `-webkit-image-set(${value})`);
1440    element.style.backgroundImage = bgImageValues.join();
1441  }
1442  manageApplied(element, settings, instance);
1443};
1444const setSourcesFunctions = {
1445  IMG: setSourcesImg,
1446  IFRAME: setSourcesIframe,
1447  VIDEO: setSourcesVideo,
1448  OBJECT: setSourcesObject
1449};
1450const setSourcesNative = (element, settings) => {
1451  const setSourcesFunction = setSourcesFunctions[element.tagName];
1452  if (!setSourcesFunction) {
1453    return;
1454  }
1455  setSourcesFunction(element, settings);
1456};
1457const setSources = (element, settings, instance) => {
1458  const setSourcesFunction = setSourcesFunctions[element.tagName];
1459  if (!setSourcesFunction) {
1460    return;
1461  }
1462  setSourcesFunction(element, settings);
1463  manageLoading(element, settings, instance);
1464};
1465const elementsWithLoadEvent = ["IMG", "IFRAME", "VIDEO", "OBJECT"];
1466const hasLoadEvent = (element) => elementsWithLoadEvent.indexOf(element.tagName) > -1;
1467const checkFinish = (settings, instance) => {
1468  if (instance && !isSomethingLoading(instance) && !haveElementsToLoad(instance)) {
1469    safeCallback(settings.callback_finish, instance);
1470  }
1471};
1472const addEventListener = (element, eventName, handler) => {
1473  element.addEventListener(eventName, handler);
1474  element.llEvLisnrs[eventName] = handler;
1475};
1476const removeEventListener = (element, eventName, handler) => {
1477  element.removeEventListener(eventName, handler);
1478};
1479const hasEventListeners = (element) => {
1480  return !!element.llEvLisnrs;
1481};
1482const addEventListeners = (element, loadHandler2, errorHandler2) => {
1483  if (!hasEventListeners(element)) element.llEvLisnrs = {};
1484  const loadEventName = element.tagName === "VIDEO" ? "loadeddata" : "load";
1485  addEventListener(element, loadEventName, loadHandler2);
1486  addEventListener(element, "error", errorHandler2);
1487};
1488const removeEventListeners = (element) => {
1489  if (!hasEventListeners(element)) {
1490    return;
1491  }
1492  const eventListeners = element.llEvLisnrs;
1493  for (let eventName in eventListeners) {
1494    const handler = eventListeners[eventName];
1495    removeEventListener(element, eventName, handler);
1496  }
1497  delete element.llEvLisnrs;
1498};
1499const doneHandler = (element, settings, instance) => {
1500  deleteTempImage(element);
1501  updateLoadingCount(instance, -1);
1502  decreaseToLoadCount(instance);
1503  removeClass(element, settings.class_loading);
1504  if (settings.unobserve_completed) {
1505    unobserve(element, instance);
1506  }
1507};
1508const loadHandler = (event, element, settings, instance) => {
1509  const goingNative = hasStatusNative(element);
1510  doneHandler(element, settings, instance);
1511  addClass(element, settings.class_loaded);
1512  setStatus(element, statusLoaded);
1513  safeCallback(settings.callback_loaded, element, instance);
1514  if (!goingNative) checkFinish(settings, instance);
1515};
1516const errorHandler = (event, element, settings, instance) => {
1517  const goingNative = hasStatusNative(element);
1518  doneHandler(element, settings, instance);
1519  addClass(element, settings.class_error);
1520  setStatus(element, statusError);
1521  safeCallback(settings.callback_error, element, instance);
1522  if (settings.restore_on_error) restoreOriginalAttrs(element, attrsSrcSrcsetSizes);
1523  if (!goingNative) checkFinish(settings, instance);
1524};
1525const addOneShotEventListeners = (element, settings, instance) => {
1526  const elementToListenTo = getTempImage(element) || element;
1527  if (hasEventListeners(elementToListenTo)) {
1528    return;
1529  }
1530  const _loadHandler = (event) => {
1531    loadHandler(event, element, settings, instance);
1532    removeEventListeners(elementToListenTo);
1533  };
1534  const _errorHandler = (event) => {
1535    errorHandler(event, element, settings, instance);
1536    removeEventListeners(elementToListenTo);
1537  };
1538  addEventListeners(elementToListenTo, _loadHandler, _errorHandler);
1539};

1540const loadBackground = (element, settings, instance) => {
1541  addTempImage(element);
1542  addOneShotEventListeners(element, settings, instance);
1543  saveOriginalBackgroundStyle(element);
1544  setBackground(element, settings, instance);
1545  setMultiBackground(element, settings, instance);
1546  setImgsetBackground(element, settings, instance);
1547};
1548const loadRegular = (element, settings, instance) => {
1549  addOneShotEventListeners(element, settings, instance);
1550  setSources(element, settings, instance);
1551};
1552const load = (element, settings, instance) => {
1553  if (hasLoadEvent(element)) {
1554    loadRegular(element, settings, instance);
1555  } else {
1556    loadBackground(element, settings, instance);
1557  }
1558};
1559const loadNative = (element, settings, instance) => {
1560  element.setAttribute("loading", "lazy");
1561  addOneShotEventListeners(element, settings, instance);
1562  setSourcesNative(element, settings);
1563  setStatus(element, statusNative);
1564};
1565const removeImageAttributes = (element) => {
1566  element.removeAttribute(SRC);
1567  element.removeAttribute(SRCSET);
1568  element.removeAttribute(SIZES);
1569};
1570const resetSourcesImg = (element) => {
1571  forEachPictureSource(element, (sourceTag) => {
1572    removeImageAttributes(sourceTag);
1573  });
1574  removeImageAttributes(element);
1575};
1576const restoreImg = (imgEl) => {
1577  forEachPictureSource(imgEl, (sourceEl) => {
1578    restoreOriginalAttrs(sourceEl, attrsSrcSrcsetSizes);
1579  });
1580  restoreOriginalAttrs(imgEl, attrsSrcSrcsetSizes);
1581};
1582const restoreVideo = (videoEl) => {
1583  forEachVideoSource(videoEl, (sourceEl) => {
1584    restoreOriginalAttrs(sourceEl, attrsSrc);
1585  });
1586  restoreOriginalAttrs(videoEl, attrsSrcPoster);
1587  videoEl.load();
1588};
1589const restoreIframe = (iframeEl) => {
1590  restoreOriginalAttrs(iframeEl, attrsSrc);
1591};
1592const restoreObject = (objectEl) => {
1593  restoreOriginalAttrs(objectEl, attrsData);
1594};
1595const restoreFunctions = {
1596  IMG: restoreImg,
1597  IFRAME: restoreIframe,
1598  VIDEO: restoreVideo,
1599  OBJECT: restoreObject
1600};
1601const restoreAttributes = (element) => {
1602  const restoreFunction = restoreFunctions[element.tagName];
1603  if (!restoreFunction) {
1604    restoreOriginalBgImage(element);
1605    return;
1606  }
1607  restoreFunction(element);
1608};
1609const resetClasses = (element, settings) => {
1610  if (hasEmptyStatus(element) || hasStatusNative(element)) {
1611    return;
1612  }
1613  removeClass(element, settings.class_entered);
1614  removeClass(element, settings.class_exited);
1615  removeClass(element, settings.class_applied);
1616  removeClass(element, settings.class_loading);
1617  removeClass(element, settings.class_loaded);
1618  removeClass(element, settings.class_error);
1619};
1620const restore = (element, settings) => {
1621  restoreAttributes(element);
1622  resetClasses(element, settings);
1623  resetStatus(element);
1624  deleteOriginalAttrs(element);
1625};
1626const cancelLoading = (element, entry, settings, instance) => {
1627  if (!settings.cancel_on_exit) return;
1628  if (!hasStatusLoading(element)) return;
1629  if (element.tagName !== "IMG") return;
1630  removeEventListeners(element);
1631  resetSourcesImg(element);
1632  restoreImg(element);
1633  removeClass(element, settings.class_loading);
1634  updateLoadingCount(instance, -1);
1635  resetStatus(element);
1636  safeCallback(settings.callback_cancel, element, entry, instance);
1637};
1638const onEnter = (element, entry, settings, instance) => {
1639  const dontLoad = hadStartedLoading(element);
1640  setStatus(element, statusEntered);
1641  addClass(element, settings.class_entered);
1642  removeClass(element, settings.class_exited);
1643  unobserveEntered(element, settings, instance);
1644  safeCallback(settings.callback_enter, element, entry, instance);
1645  if (dontLoad) return;
1646  load(element, settings, instance);
1647};
1648const onExit = (element, entry, settings, instance) => {
1649  if (hasEmptyStatus(element)) return;
1650  addClass(element, settings.class_exited);
1651  cancelLoading(element, entry, settings, instance);
1652  safeCallback(settings.callback_exit, element, entry, instance);
1653};
1654const tagsWithNativeLazy = ["IMG", "IFRAME", "VIDEO"];
1655const shouldUseNative = (settings) => settings.use_native && "loading" in HTMLImageElement.prototype;
1656const loadAllNative = (elements, settings, instance) => {
1657  elements.forEach((element) => {
1658    if (tagsWithNativeLazy.indexOf(element.tagName) === -1) {
1659      return;
1660    }
1661    loadNative(element, settings, instance);
1662  });
1663  setToLoadCount(instance, 0);
1664};
1665const isIntersecting = (entry) => entry.isIntersecting || entry.intersectionRatio > 0;
1666const getObserverSettings = (settings) => ({
1667  root: settings.container === document ? null : settings.container,
1668  rootMargin: settings.thresholds || settings.threshold + "px"
1669});
1670const intersectionHandler = (entries, settings, instance) => {

1671  entries.forEach(
1672    (entry) => isIntersecting(entry) ? onEnter(entry.target, entry, settings, instance) : onExit(entry.target, entry, settings, instance)
1673  );
1674};
1675const observeElements = (observer, elements) => {
1676  elements.forEach((element) => {
1677    observer.observe(element);
1678  });
1679};
1680const updateObserver = (observer, elementsToObserve) => {
1681  resetObserver(observer);
1682  observeElements(observer, elementsToObserve);
1683};
1684const setObserver = (settings, instance) => {
1685  if (!supportsIntersectionObserver || shouldUseNative(settings)) {
1686    return;
1687  }
1688  instance._observer = new IntersectionObserver((entries) => {
1689    intersectionHandler(entries, settings, instance);
1690  }, getObserverSettings(settings));
1691};
1692const toArray = (nodeSet) => Array.prototype.slice.call(nodeSet);
1693const queryElements = (settings) => settings.container.querySelectorAll(settings.elements_selector);
1694const excludeManagedElements = (elements) => toArray(elements).filter(hasEmptyStatus);
1695const hasError = (element) => hasStatusError(element);
1696const filterErrorElements = (elements) => toArray(elements).filter(hasError);
1697const getElementsToLoad = (elements, settings) => excludeManagedElements(elements || queryElements(settings));
1698const retryLazyLoad = (settings, instance) => {
1699  const errorElements = filterErrorElements(queryElements(settings));
1700  errorElements.forEach((element) => {
1701    removeClass(element, settings.class_error);
1702    resetStatus(element);
1703  });
1704  instance.update();
1705};
1706const setOnlineCheck = (settings, instance) => {
1707  if (!runningOnBrowser) {
1708    return;
1709  }
1710  instance._onlineHandler = () => {
1711    retryLazyLoad(settings, instance);
1712  };
1713  window.addEventListener("online", instance._onlineHandler);
1714};
1715const resetOnlineCheck = (instance) => {
1716  if (!runningOnBrowser) {
1717    return;
1718  }
1719  window.removeEventListener("online", instance._onlineHandler);
1720};
1721const LazyLoad = function(customSettings, elements) {
1722  const settings = getExtendedSettings(customSettings);
1723  this._settings = settings;
1724  this.loadingCount = 0;
1725  setObserver(settings, this);
1726  setOnlineCheck(settings, this);
1727  this.update(elements);
1728};
1729LazyLoad.prototype = {
1730  update: function(givenNodeset) {
1731    const settings = this._settings;
1732    const elementsToLoad = getElementsToLoad(givenNodeset, settings);
1733    setToLoadCount(this, elementsToLoad.length);
1734    if (isBot || !supportsIntersectionObserver) {
1735      this.loadAll(elementsToLoad);
1736      return;
1737    }
1738    if (shouldUseNative(settings)) {
1739      loadAllNative(elementsToLoad, settings, this);
1740      return;
1741    }
1742    updateObserver(this._observer, elementsToLoad);
1743  },
1744  destroy: function() {
1745    if (this._observer) {
1746      this._observer.disconnect();
1747    }
1748    resetOnlineCheck(this);
1749    queryElements(this._settings).forEach((element) => {
1750      deleteOriginalAttrs(element);
1751    });
1752    delete this._observer;
1753    delete this._settings;
1754    delete this._onlineHandler;
1755    delete this.loadingCount;
1756    delete this.toLoadCount;
1757  },
1758  loadAll: function(elements) {
1759    const settings = this._settings;
1760    const elementsToLoad = getElementsToLoad(elements, settings);
1761    elementsToLoad.forEach((element) => {
1762      unobserve(element, this);
1763      load(element, settings, this);
1764    });
1765  },
1766  restoreAll: function() {
1767    const settings = this._settings;
1768    queryElements(settings).forEach((element) => {
1769      restore(element, settings);
1770    });
1771  }
1772};
1773LazyLoad.load = (element, customSettings) => {
1774  const settings = getExtendedSettings(customSettings);
1775  load(element, settings);
1776};
1777LazyLoad.resetStatus = (element) => {
1778  resetStatus(element);
1779};
1780if (runningOnBrowser) {
1781  autoInitialize(LazyLoad, window.lazyLoadOptions);
1782}
1783document.getElementById("optidigital-adslot-hum_ad");
1784function _extends() {
1785  return _extends = Object.assign ? Object.assign.bind() : function(n) {
1786    for (var e = 1; e < arguments.length; e++) {
1787      var t = arguments[e];
1788      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
1789    }
1790    return n;
1791  }, _extends.apply(null, arguments);
1792}
1793function _objectWithoutPropertiesLoose(r, e) {
1794  if (null == r) return {};
1795  var t = {};
1796  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
1797    if (-1 !== e.indexOf(n)) continue;
1798    t[n] = r[n];
1799  }
1800  return t;
1801}
1802var _excluded$1 = ["type", "data", "headers", "processData", "url", "contentType"];
1803var parseJSON = function parseJSON2(response) {
1804  var contentType = response.headers.get("content-type");
1805  if (contentType && contentType.indexOf("application/json") !== -1) {
1806    return response.json();
1807  }
1808  return response.text();
1809};
1810var AJAX_URL = "/wp-content/mu-plugins/humanoid-core/includes/Core/Ajax/AjaxEndpoint.php";
1811var Ajax = {
1812  // POST method
1813  post: function post(url, data2, cb) {
1814    if (cb === void 0) {
1815      cb = null;
1816    }
1817    return this.ajax({
1818      url,
1819      data: data2,
1820      success: cb,
1821      type: "POST"
1822    });
1823  },
1824  // GET method
1825  get: function get(url, data2, cb) {
1826    if (cb === void 0) {
1827      cb = null;
1828    }
1829    return this.ajax({
1830      url,
1831      data: data2,
1832      success: cb
1833    });
1834  },
1835  ajax: function ajax(params) {
1836    if (params === void 0) {
1837      params = {};
1838    }
1839    var _params = params, _params$type = _params.type, type = _params$type === void 0 ? "GET" : _params$type, data2 = _params.data, _params$headers = _params.headers, headers = _params$headers === void 0 ? {}

1839 : _params$headers, _params$processData = _params.processData, processData = _params$processData === void 0 ? true : _params$processData, url = _params.url, _params$contentType = _params.contentType, contentType = _params$contentType === void 0 ? null : _params$contentType, rest = _objectWithoutPropertiesLoose(_params, _excluded$1);
1840    var body = null;
1841    if (type === "GET" && data2) {
1842      var args = [];
1843      var _loop = function _loop2(key2) {
1844        if (data2[key2] !== void 0) {
1845          if (Array.isArray(data2[key2])) {
1846            data2[key2].forEach(function(e) {
1847              args.push(key2 + "[]=" + encodeURIComponent(e));
1848            });
1849          } else if (typeof data2[key2] !== "string") {
1850            args.push(key2 + "=" + encodeURIComponent(JSON.stringify(data2[key2])));
1851          } else {
1852            args.push(key2 + "=" + encodeURIComponent(data2[key2]));
1853          }
1854        }
1855      };
1856      for (var key in data2) {
1857        _loop(key);
1858      }
1859      url += "?" + args.join("&");
1860    } else if (data2) {
1861      body = data2;
1862      if (contentType === null) {
1863        contentType = "application/x-www-form-urlencoded;charset=UTF-8";
1864      }
1865      if (processData) {
1866        if (typeof data2 === "object" && !(data2 instanceof FormData)) {
1867          contentType = null;
1868          body = new FormData();
1869          var keys = Object.keys(data2);
1870          for (var i = 0; i < keys.length; i += 1) {
1871            body.append(keys[i], data2[keys[i]]);
1872          }
1873        }
1874      }
1875    }
1876    if (contentType) {
1877      headers["Content-Type"] = contentType;
1878    }
1879    var fetchParams = _extends({
1880      method: type || "GET",
1881      body,
1882      headers
1883    }, rest);
1884    var promise = window.fetch(url, fetchParams).then(parseJSON).then(function(res) {
1885      if (params.success) {
1886        params.success(res);
1887      }
1888      return res;
1889    })["catch"](function(err) {
1890      if (params.error) {
1891        params.error(err);
1892      }
1893      throw err;
1894    });
1895    promise.done = function(e) {
1896      promise.then(e);
1897      return promise;
1898    };
1899    promise.fail = function(e) {
1900      promise["catch"](e);
1901      return promise;
1902    };
1903    return promise;
1904  }
1905};
1906var GTM_DATA_ATTRIBUTE_LEGACY = "data-push-event";
1907var GTM_DATA_ATTRIBUTE = "data-gtm";
1908var GTM_DATA_ATTRIBUTE_ON = "data-gtm-on";
1909function getDataLayer() {
1910  window.dataLayer = window.dataLayer || [];
1911  return window.dataLayer;
1912}
1913function pushDataLayer(event) {
1914  window.dataLayer = window.dataLayer || [];
1915  window.dataLayer.push(event);
1916}
1917function newPageView(title, url, objectStats) {
1918  var layer = getDataLayer();
1919  var relativeUrl = url;
1920  if (relativeUrl.indexOf("http://") !== -1) {
1921    relativeUrl = "/" + relativeUrl.split("/").slice(3).join("/");
1922  }
1923  if (layer.some(function(f) {
1924    return f.virtualPageURL === relativeUrl;
1925  })) {
1926    return;
1927  }
1928  var data2 = {};
1929  data2 = {
1930    event: "VirtualPageview",
1931    virtualPageURL: relativeUrl,
1932    virtualPageTitle: title,
1933    theme: document.documentElement.getAttribute("data-scheme")
1934  };
1935  pushDataLayer(data2);
1936}
1937function newsletterEvent() {
1938  pushDataLayer({
1939    event: "NewsLetterInterArticleBox"
1940  });
1941}
1942function onGtmClick(event) {
1943  var link = event.delegateTarget;
1944  var dataPushEvents = link.getAttribute(GTM_DATA_ATTRIBUTE_LEGACY);
1945  if (dataPushEvents) {
1946    var eventArray = dataPushEvents.split(",");
1947    for (var j = 0; j < eventArray.length; j += 1) {
1948      pushDataLayer({
1949        event: eventArray[j]
1950      });
1951    }
1952  }
1953  if (link) {
1954    pushElementGtm(link);
1955  }
1956}
1957function pushElementGtm(element) {
1958  var gtmJsonEncodedData = element.getAttribute(GTM_DATA_ATTRIBUTE);
1959  if (!gtmJsonEncodedData) {
1960    return;
1961  }
1962  try {
1963    var dataJson = JSON.parse(gtmJsonEncodedData);
1964    pushDataLayer(dataJson);
1965  } catch (e) {
1966    console.error(e);
1967  }
1968}
1969function initPushEventInClick() {
1970  var selectorOnClick = ["[" + GTM_DATA_ATTRIBUTE_LEGACY + "]", "[" + GTM_DATA_ATTRIBUTE + "]:not(" + GTM_DATA_ATTRIBUTE_ON + ")"].join(",");
1971  var selectorOnCustomEvent = ["[" + GTM_DATA_ATTRIBUTE + "][" + GTM_DATA_ATTRIBUTE_ON + "]"].join(",");
1972  delegate(selectorOnClick, "click", onGtmClick, {
1973    capture: true
1974  });
1975  document.querySelectorAll(selectorOnCustomEvent).forEach(function(element) {
1976    var eventType = element.getAttribute(GTM_DATA_ATTRIBUTE_ON);
1977    if (eventType === "ready") {
1978      domReady(function() {
1979        return pushElementGtm(element);
1980      });
1981    }
1982  });
1983}
1984var _excluded = ["html"];
1985var NO_MORE_ITEMS = "no_more_items";
1986var MORE_LINK = "more_link";
1987var ON_ERROR = "on_error";
1988var AJAX_LOADER = "ajax_loader";
1989var AJAX_LOADER_CLASS = "ajax-loader";
1990var Feed = /* @__PURE__ */ (function() {
1991  function Feed2(ajaxUrl, siteUrl, elementsCallbacks) {
1992    var _this = this;
1993    if (elementsCallbacks === void 0) {
1994      elementsCallbacks = {};
1995    }
1996    this.ajaxUrl = ajaxUrl;
1997    this.siteUrl = siteUrl;
1998    this.elementsCallbacks = elementsCallbacks;
1999    this.filters = document.querySelectorAll("[data-filter]");
2000    this.filtersList = document.querySelector(".filters__list");
2001    this.noAjaxClass = "js-no-ajax";
2002    this.infiniteScrollClass = "js-infinite-scroll";
2003    this.$filterWrapper = $(".js-feed-filters-wrapper");
2004    this.$footer = $('#footer, footer[role="contentinfo"]').first();
2005    this.loadEventStarted = false;

2006    this.pageLoaded = 1;
2007    this.canAjax = true;
2008    this.oldDatas = {};
2009    this.currentDataKey = null;
2010    this.abortController = new AbortController();
2011    this.timeoutId = null;
2012    this.searchPostsBlocks();
2013    if (this.$postsBlocks.length > 0) {
2014      $(window).on("scroll", this.bindScrollEvent.bind(this));
2015    }
2016    this.filters.forEach(function(filter2) {
2017      filter2.addEventListener("click", function(ev) {
2018        var $currentTarget = $(ev.currentTarget);
2019        if ($currentTarget.hasClass("active")) {
2020          return;
2021        }
2022        var filterData = $currentTarget.data("filter");
2023        _this.getAjaxPostsFiltered(filterData, $currentTarget);
2024      });
2025      if (window.location.hash === "" + filter2.getAttribute("href")) {
2026        filter2.click();
2027        if (filter2.offsetLeft + filter2.offsetWidth > _this.filtersList.offsetWidth) {
2028          _this.filtersList.scrollLeft = filter2.offsetLeft - 40;
2029        }
2030      }
2031    });
2032  }
2033  var _proto = Feed2.prototype;
2034  _proto.searchPostsBlocks = function searchPostsBlocks() {
2035    this.$postsBlocks = $(".js-feed-posts");
2036    this.$lastBlock = this.$postsBlocks.last();
2037  };
2038  _proto.updateDomData = function updateDomData(data2) {
2039    var currentOldData = {};
2040    if (data2.url && data2.url !== window.location.href) {
2041      currentOldData.url = window.location.href;
2042      window.history.pushState({
2043        urlPath: data2.url
2044      }, "", data2.url);
2045      $("a[data-page-url]").attr("href", data2.url);
2046    }
2047    if (data2.title && data2.title !== document.title) {
2048      currentOldData.title = document.title;
2049      document.title = data2.title;
2050      $('meta[property="og:title"]').attr("content", data2.title);
2051    }
2052    if (data2.heading) {
2053      currentOldData.heading = $("[data-page-title],h1").html();
2054      $("[data-page-title],h1").html(data2.heading);
2055    }
2056    if (data2.description) {
2057      currentOldData.description = $("[data-page-description]").html();
2058      $("[data-page-description]").html(data2.description);
2059      $('meta[name="description"]').attr("content", data2.description);
2060      $('meta[property="og:description"]').attr("content", data2.description);
2061    }
2062    if (data2.breadcrumb) {
2063      currentOldData.breadcrumb = $("[data-page-breadcrumb]").html();
2064      $("[data-page-breadcrumb]").html(data2.breadcrumb);
2065    }
2066    return currentOldData;
2067  };
2068  _proto.bindScrollEvent = function bindScrollEvent() {
2069    if (!this.loadEventStarted && this.canAjax && !this.$lastBlock.hasClass(this.noAjaxClass)) {
2070      if (window.scrollY + $(window).height() > document.body.scrollHeight - $(window).height() - this.$footer.height() / 2) {
2071        this.loadEventStarted = true;
2072        this.getAjaxPosts();
2073        return;
2074      }
2075    }
2076    var keys = Object.keys(this.oldDatas);
2077    if (keys.length === 0) {
2078      return;
2079    }
2080    var nearestOldData = null;
2081    var nearestOldDataKey = null;
2082    var scrollKey = window.scrollY + $(window).height();
2083    for (var i = 0; i < keys.length; i += 1) {
2084      var key = keys[i];
2085      if (scrollKey < key) {
2086        nearestOldData = this.oldDatas[key];
2087        nearestOldDataKey = key;
2088        break;
2089      }
2090    }
2091    if (nearestOldData && nearestOldDataKey !== this.currentDataKey) {
2092      this.currentDataKey = nearestOldDataKey;
2093      this.updateDomData(nearestOldData);
2094    }
2095  };
2096  _proto.getData = function getData2() {
2097    return this.$lastBlock.data("feed") || {};
2098  };
2099  _proto.buildEsiAjaxConfig = function buildEsiAjaxConfig(params) {
2100    var esiParams = {
2101      feed_type: params.feed_type,
2102      term_id: params.term_id,
2103      paged: params.paged
2104    };
2105    if (params.page_slug) {
2106      esiParams.page_slug = params.page_slug;
2107    }
2108    var query = Object.entries(esiParams).filter(function(_ref) {
2109      var v = _ref[1];
2110      return v !== void 0 && v !== null;
2111    }).map(function(_ref2) {
2112      var k = _ref2[0], v = _ref2[1];
2113      return k + "=" + encodeURIComponent(v);
2114    }).join("&");
2115    return {
2116      url: "/_fragment/" + params.esi_fragment + "?" + query,
2117      headers: {
2118        "X-Fragment": "1"
2119      }
2120    };
2121  };
2122  _proto.getAjaxPostsFiltered = function getAjaxPostsFiltered(filter2, filterTarget) {
2123    var params = this.getData();
2124    params.paged = 1;

2125    params.filter = filter2;
2126    this.$lastBlock.data("feed", params);
2127    this.oldDatas = {};
2128    return this.getAjaxPosts(filterTarget);
2129  };
2130  _proto.getAjaxPosts = function getAjaxPosts(filterTarget) {
2131    var _this2 = this;
2132    if (filterTarget === void 0) {
2133      filterTarget = null;
2134    }
2135    var params = this.getData();
2136    if (!filterTarget) {
2137      params.paged += 1;
2138    } else {
2139      this.abortController.abort();
2140      this.abortController = new AbortController();
2141    }
2142    $(".ajax-error").remove();
2143    var $wrapper = params.filters_wrapper ? $(params.filters_wrapper) : null;
2144    var $loaderWrapper = params.loader_wrapper ? $(params.loader_wrapper) : $wrapper;
2145    this.injectAjaxLoader(!!filterTarget, $loaderWrapper);
2146    var ajaxConfig = params.esi_fragment ? this.buildEsiAjaxConfig(params) : {
2147      url: this.ajaxUrl,
2148      data: _extends({
2149        action: "getNextPage"
2150      }, params)
2151    };
2152    return Ajax.ajax(_extends({}, ajaxConfig, {
2153      signal: this.abortController.signal
2154    })).then(function(data2) {
2155      var html2;
2156      var otherData;
2157      if (params.esi_fragment) {
2158        html2 = data2;
2159        otherData = {};
2160      } else {
2161        var _data = data2;
2162        html2 = _data.html;
2163        otherData = _objectWithoutPropertiesLoose(_data, _excluded);
2164      }
2165      var fragments = document.createRange().createContextualFragment(html2);
2166      var feeds = fragments.querySelectorAll(".js-feed-posts");
2167      var feed = Array.from(feeds).pop();
2168      var content = feed.innerHTML.trim();
2169      var dataAttributes = $(feed).data();
2170      var currentOldData = _this2.updateDomData(otherData);
2171      if (_this2.loadEventStarted) {
2172        var key = document.body.scrollHeight - $(window).height();
2173        _this2.oldDatas[key] = currentOldData;
2174      }
2175      var _ref3 = dataAttributes.feed || {}, layout = _ref3.layout;
2176      if (layout && layout.length && _this2.elementsCallbacks[layout]) {
2177        _this2.elementsCallbacks[layout](content, !!filterTarget);
2178      } else if (filterTarget) {
2179        if ($wrapper && $wrapper.length) {
2180          $wrapper.html($(html2.trim()).html());
2181          _this2.searchPostsBlocks();
2182        } else {
2183          _this2.$lastBlock.html(content);
2184        }
2185        $(".ajax-no-posts").remove();
2186      } else {
2187        _this2.$lastBlock.append(content);
2188      }
2189      _this2.currentDataKey = document.body.scrollHeight - $(window).height();
2190      _this2.oldDatas[_this2.currentDataKey] = otherData;
2191      _this2.$lastBlock.data(dataAttributes);
2192      _this2.$lastBlock.attr("class", feed.className);
2193      document.dispatchEvent(new Event("updateLazyload"));
2194      if (_this2.$ajaxLoader) {
2195        _this2.$ajaxLoader.remove();
2196        _this2.$ajaxLoader = null;
2197      }
2198      if (_this2.pageLoaded === 4 && !_this2.$lastBlock.hasClass(_this2.noAjaxClass) && !_this2.$postsBlocks.hasClass(_this2.infiniteScrollClass)) {
2199        var url = _this2.getUrl(params.redirect_path, params.paged, params.paged_as_get);
2200        if (url.length > 0) {
2201          _this2.injectMoreLink(url + "#derniers-articles");
2202        }
2203        _this2.canAjax = false;
2204      } else if (_this2.$lastBlock.hasClass(_this2.noAjaxClass)) {
2205        _this2.injectNoMoreItems(!!filterTarget);
2206        _this2.canAjax = false;
2207      } else if (filterTarget) {
2208        _this2.canAjax = true;
2209      }
2210      if (!filterTarget) {
2211        _this2.pageLoaded += 1;
2212      } else {
2213        _this2.pageLoaded = 0;
2214        $("[data-filter], .is-feed-filter").removeClass("active");
2215        if (filterTarget !== true) {
2216          filterTarget.addClass("active");
2217        }
2218      }
2219      _this2.loadEventStarted = false;
2220      if (params.slug !== "single") {
2221        _this2.pushVirtualPageView();
2222      }
2223      return otherData;
2224    })["catch"](function(err) {
2225      if (err.name === "AbortError") {
2226        return;
2227      }
2228      console.error(err);
2229      if (_this2.$ajaxLoader) {
2230        _this2.$ajaxLoader.remove();
2231        _this2.$ajaxLoader = null;
2232      }
2233      var $onError = null;
2234      if (!_this2.elementsCallbacks[ON_ERROR]) {
2235        $onError = $('<div class="ajax-error has-text-weight-semibold has-text-primary has-text-centered mt-3 mb-3">Oups, une erreur est survenue !</div>');
2236      } else {
2237        $onError = _this2.elementsCallbacks[ON_ERROR](!!filterTarget);
2238      }
2239      if (filterTarget) {
2240        _this2.$lastBlock.html($onError.html());
2241      } else {
2242        _this2.$lastBlock.after($onError);
2243      }
2244    });
2245  };
2246  _proto.getUrl = function getUrl(slug, pageNumber, pagedAsGet) {
2247    if (pagedAsGet === void 0) {
2248      pagedAsGet = false;

2249    }
2250    if (!slug && slug !== "") {
2251      return false;
2252    }
2253    var nextPage = pageNumber + 1;
2254    var baseURL = this.siteUrl;
2255    if (slug !== "" && slug !== "/") {
2256      baseURL += "/" + slug;
2257    }
2258    if (pagedAsGet === true || pagedAsGet === "true") {
2259      var url = new URL(baseURL);
2260      url.searchParams.set("page", nextPage);
2261      return url.href;
2262    }
2263    return baseURL + "/page/" + nextPage + "/";
2264  };
2265  _proto.injectAjaxLoader = function injectAjaxLoader(isFiltering, $wrapper) {
2266    var _this3 = this;
2267    if (isFiltering === void 0) {
2268      isFiltering = false;
2269    }
2270    if ($wrapper === void 0) {
2271      $wrapper = null;
2272    }
2273    if (this.timeoutId) {
2274      clearTimeout(this.timeoutId);
2275      this.timeoutId = null;
2276    }
2277    if (!this.$ajaxLoader) {
2278      var $ajaxLoader = $("<div>");
2279      if (!this.elementsCallbacks[AJAX_LOADER]) {
2280        $ajaxLoader.append($("<div>").addClass(AJAX_LOADER_CLASS));
2281      } else {
2282        var $loader = this.elementsCallbacks[AJAX_LOADER](isFiltering);
2283        if (!$loader) {
2284          return;
2285        }
2286        $ajaxLoader.append($loader);
2287      }
2288      if (isFiltering) {
2289        if ($wrapper && $wrapper.length) {
2290          $ajaxLoader.hide().insertBefore($wrapper).slideDown(150);
2291        } else {
2292          $ajaxLoader.hide().insertBefore(this.$lastBlock).slideDown(150);
2293        }
2294      } else {
2295        this.$lastBlock.after($ajaxLoader);
2296      }
2297      this.$ajaxLoader = $ajaxLoader;
2298    }
2299    this.timeoutId = setTimeout(function() {
2300      if (_this3.$ajaxLoader && _this3.$ajaxLoader.length) {
2301        _this3.$ajaxLoader.append('<p class="ajax-text has-text-weight-semibold has-text-primary has-text-centered">Encore un petit instant...</p>');
2302      }
2303    }, 2500);
2304  };
2305  _proto.injectNoMoreItems = function injectNoMoreItems(isFiltering) {
2306    if (isFiltering === void 0) {
2307      isFiltering = false;
2308    }
2309    var $noMoreItems = null;
2310    if (!this.elementsCallbacks[NO_MORE_ITEMS]) {
2311      $noMoreItems = $(`<div class="ajax-no-posts has-text-weight-semibold has-text-primary has-text-centered mt-3 mb-3">Il n'y a pas d'autres articles` + (isFiltering ? " pour ce filtre" : "") + "...</div>");
2312    } else {
2313      $noMoreItems = this.elementsCallbacks[NO_MORE_ITEMS](isFiltering);
2314    }
2315    if ($noMoreItems) {
2316      this.$lastBlock.after($noMoreItems);
2317    }
2318  };
2319  _proto.injectMoreLink = function injectMoreLink(url) {
2320    var $moreLink = null;
2321    if (!this.elementsCallbacks[MORE_LINK]) {
2322      $moreLink = $('<div class="has-text-centered mt-3 mb-3"><a href="' + url + `" class="button">Voir plus d'articles</a></div>`);
2323    } else {
2324      $moreLink = this.elementsCallbacks[MORE_LINK](url);
2325    }
2326    if ($moreLink) {
2327      this.$lastBlock.after($moreLink);
2328    }
2329  };
2330  _proto.pushVirtualPageView = function pushVirtualPageView() {
2331    var currentUrl = window.location.href.split("#")[0];
2332    var siteTitle = document.title;
2333    newPageView(siteTitle, currentUrl + "page/" + this.pageLoaded);
2334  };
2335  return Feed2;
2336})();
2337window.lazyFunctions = {};
2338window.lazyPendings = {};
2339var Lazyload = {
2340  add: function add(funcName, cb, context) {
2341    if (context === void 0) {
2342      context = "default";
2343    }
2344    if (!window.lazyFunctions) {
2345      var _window$lazyFunctions;
2346      window.lazyFunctions = (_window$lazyFunctions = {}, _window$lazyFunctions[context] = {}, _window$lazyFunctions);
2347    } else if (!window.lazyFunctions[context]) {
2348      window.lazyFunctions[context] = {};
2349    }
2350    window.lazyFunctions[context][funcName] = cb;
2351    if (window.lazyPendings && window.lazyPendings[context]) {
2352      var lazyPendings = window.lazyPendings[context][funcName];
2353      if (lazyPendings && lazyPendings.length) {
2354        var lazyFunc = window.lazyFunctions[context][funcName];
2355        if (lazyFunc) {
2356          lazyPendings.map(lazyFunc);
2357          delete window.lazyPendings[context][funcName];
2358        }
2359      }
2360    }
2361  },
2362  init: function init4(_temp) {
2363    var _ref = _temp === void 0 ? {} : _temp, _ref$errorImg = _ref.errorImg, errorImg = _ref$errorImg === void 0 ? null : _ref$errorImg, _ref$threshold = _ref.threshold, threshold = _ref$threshold === void 0 ? 600 : _ref$threshold, _ref$context = _ref.context, context = _ref$context === void 0 ? "default" : _ref$context;
2364    errorImg = errorImg || window.theme_config.theme + "/assets/images/error.png";
2365    if (!window.lazyPendings) {
2366      var _window$lazyPendings;
2367      window.lazyPendings = (_window$lazyPendings = {}, _window$lazyPendings[context] = {}, _window$lazyPendings);
2368    } else {
2369      window.lazyPendings[context] = {};
2370    }
2371    var instance = new LazyLoad({
2372      threshold,
2373      elements_selector: context === "default" ? "img[data-src], [data-bg], [data-lazy-func]" : "[data-lazy-func]",
2374      unobserve_entered: true,
2375      callback_enter: function callback_enter(el) {
2376        var funcName = el.getAttribute("data-lazy-func");
2377        if (!funcName) return;
2378        var lazyFunc = (window.lazyFunctions[context] || {})[funcName];
2379        if (!lazyFunc) {
2380          if (window.lazyPendings[context] && window.lazyPendings[context][funcName]) {
2381            window.lazyPendings[context][funcName] = [].concat(window.lazyPendings[context][funcName], [el]);
2382          } else if (window.lazyPendings[context]) {
2383            window.lazyPendings[context][funcName] = [el];
2384          } else {
2385            var _window$lazyPendings$;
2386            window.lazyPendings[context] = (_window$lazyPendings$ = {}, _window$lazyPendings$[funcName] = [el], _window$lazyPendings$);
2387          }
2388          return;
2389        }
2390        lazyFunc(el);
2391      },
2392      callback_error: function callback_error(el) {
2393        if (el.tagName !== "IMG") {
2394          return;
2395        }
2396        if (el.dataset.fallback && el.src !== el.dataset.fallback) {
2397          el.src = el.dataset.fallback;
2398        } else if (el.src) {
2399          el.src = errorImg;
2400        }

2401        if (el.dataset.fallback && el.srcset !== el.dataset.fallback) {
2402          el.srcset = el.dataset.fallback;
2403        } else if (el.srcset) {
2404          el.srcset = errorImg;
2405        }
2406      }
2407    });
2408    document.addEventListener("updateLazyload", function() {
2409      instance.update();
2410    });
2411    return instance;
2412  }
2413};
2414var ThemeManifest = {
2415  manifest: null,
2416  /**
2417   * @returns {Promise<Ajax>}
2418   */
2419  fetch: function fetch() {
2420    try {
2421      var _this = this;
2422      if (_this.manifest !== null) {
2423        return Promise.resolve(_this.manifest);
2424      }
2425      return Promise.resolve(Ajax.get(window.theme_config.themeManifest).then(function(data2) {
2426        _this.manifest = data2;
2427        return data2;
2428      }));
2429    } catch (e) {
2430      return Promise.reject(e);
2431    }
2432  }
2433};
2434var VideosUtils = {
2435  /**
2436   * Load the video iframe on click on the image placeholder.
2437   * @param ev Event
2438   * @param player query selector for the player
2439   */
2440  loadYouTubeIframe: function loadYouTubeIframe(e, player) {
2441    e.preventDefault();
2442    var $video = $(e.target).closest(player);
2443    var videoID = $video.data("videoId");
2444    $video.removeClass("placeholder");
2445    var iframe = '<iframe width="' + $video.width() + '" height="' + $video.height() + '" src="';
2446    iframe += "https://www.youtube.com/embed/" + videoID;
2447    iframe += '?autoplay=1" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>';
2448    $video.html(iframe);
2449  }
2450};
2451var getNonce = function getNonce2(action) {
2452  try {
2453    return Promise.resolve(Ajax.post(AJAX_URL, {
2454      action: "getNonce",
2455      value: action
2456    }).then(function(response) {
2457      return response.nonce;
2458    }));
2459  } catch (e) {
2460    return Promise.reject(e);
2461  }
2462};
2463export {
2464  Feed as F,
2465  Lazyload as L,
2466  NO_MORE_ITEMS as N,
2467  ThemeManifest as T,
2468  VideosUtils as V,
2469  newPageView as a,
2470  getNonce as g,
2471  initPushEventInClick as i,
2472  newsletterEvent as n,
2473  pushDataLayer as p
2474};
2475
2476//# chunkId=01a0cd79-2a16-7d00-b365-fb2465d82c85