@swisspost/internet-header 1.17.0 → 10.1.0

package/dist/esm/fr-DlMHXJTg.js

@@ -0,0 +1,54 @@
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BFTU3MAI.js';
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var fr$2 = {};
+
+var hasRequiredFr;
+
+function requireFr () {
+	if (hasRequiredFr) return fr$2;
+	hasRequiredFr = 1;
+
+	Object.defineProperty(fr$2, "__esModule", {
+	  value: true
+	});
+	fr$2.default = void 0;
+	var _default = {
+	  days: ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'],
+	  daysShort: ['Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'],
+	  daysMin: ['Di', 'Lu', 'Ma', 'Me', 'Je', 'Ve', 'Sa'],
+	  months: ['Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Août', 'Septembre', 'Octobre', 'Novembre', 'Décembre'],
+	  monthsShort: ['Jan', 'Fév', 'Mars', 'Avr', 'Mai', 'Juin', 'Juil', 'Août', 'Sep', 'Oct', 'Nov', 'Dec'],
+	  today: "Aujourd'hui",
+	  clear: 'Effacer',
+	  dateFormat: 'dd/MM/yyyy',
+	  timeFormat: 'HH:mm',
+	  firstDay: 1
+	};
+	fr$2.default = _default;
+	return fr$2;
+}
+
+var frExports = requireFr();
+var fr = /*@__PURE__*/getDefaultExportFromCjs(frExports);
+
+var fr$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: fr
+}, [frExports]);
+
+export { fr$1 as f };

package/dist/esm/get-focusable-children-DxYnH2ye.js

@@ -0,0 +1,90 @@
+import { g as getRoot } from './get-root-08F-DB-d.js';
+
+const focusableSelector = `:where(${[
+    'button',
+    'input:not([type="hidden"])',
+    '[tabindex]',
+    'select',
+    'textarea',
+    '[contenteditable]',
+    'a[href]',
+    'iframe',
+    'audio[controls]',
+    'video[controls]',
+    'area[href]',
+    'details > summary:first-of-type',
+].join(',')})`;
+const focusDisablingSelector = `:where(${[
+    '[inert]',
+    '[inert] *',
+    ':disabled',
+    'dialog:not([open]) *',
+    '[popover]:not(:popover-open) *',
+    'details:not([open]) > *:not(details > summary:first-of-type)',
+    'details:not([open]) > *:not(details > summary:first-of-type) *',
+    '[tabindex^="-"]',
+    '[hidden]:not([hidden="false"])',
+].join(',')})`;
+function getFocusableChildren(element) {
+    const focusableChildren = element.querySelectorAll(`${focusableSelector}:not(${focusDisablingSelector})`);
+    return Array.from(focusableChildren).filter(el => !isFocusBlockedByCSS(el));
+}
+// Searches deeper across shadow DOM
+function getDeepFocusableChildren(el, filter, visited = new Set()) {
+    if (visited.has(el))
+        return [];
+    visited.add(el);
+    let nodes = [];
+    // SLOT
+    if (el instanceof HTMLSlotElement) {
+        const assigned = el.assignedElements({ flatten: true });
+        nodes = assigned.length > 0 ? assigned : Array.from(el.children);
+    }
+    // SHADOW ROOT
+    else if (el instanceof HTMLElement && el.shadowRoot) {
+        nodes = Array.from(el.shadowRoot.children);
+    }
+    // NORMAL ELEMENT
+    else if (el instanceof Element) {
+        nodes = Array.from(el.children);
+    }
+    if (filter) {
+        nodes = nodes.filter(filter);
+    }
+    const focusableElements = [];
+    for (const node of nodes) {
+        if (isElementFocusable(node)) {
+            focusableElements.push(node);
+            continue;
+        }
+        focusableElements.push(...getDeepFocusableChildren(node, filter, visited));
+    }
+    return focusableElements;
+}
+function isFocusBlockedByCSS(el) {
+    if (el instanceof Document) {
+        return false;
+    }
+    if (el instanceof ShadowRoot) {
+        return isFocusBlockedByCSS(el.host);
+    }
+    if (typeof el.checkVisibility === 'function') {
+        return !el.checkVisibility({ visibilityProperty: true });
+    }
+    const style = el.ownerDocument?.defaultView?.getComputedStyle(el);
+    if (!style || style.display === 'none' || style.visibility !== 'visible') {
+        return true;
+    }
+    if (el.parentElement) {
+        return isFocusBlockedByCSS(el.parentElement);
+    }
+    const root = getRoot(el);
+    return isFocusBlockedByCSS(root);
+}
+function isElementFocusable(node) {
+    return (node instanceof HTMLElement &&
+        node.matches(`${focusableSelector}:not(${focusDisablingSelector})`) &&
+        !isFocusBlockedByCSS(node));
+}
+
+export { getFocusableChildren as a, getDeepFocusableChildren as g };

package/dist/esm/get-root-08F-DB-d.js

@@ -0,0 +1,13 @@
+/**
+ * getRootNode() can only be used after the element has been attached to the document!
+ * So use it for example in the componentDidLoad lifecycle hook.
+ */
+function getRoot(element) {
+    const root = element.getRootNode ? element.getRootNode() : element;
+    if (root instanceof Document || root instanceof ShadowRoot) {
+        return root;
+    }
+    throw new Error('Attempting to access root node before the element is attached to the document or shadow tree.');
+}
+
+export { getRoot as g };

package/dist/esm/hr-BZdkBqJE.js

@@ -0,0 +1,54 @@
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BFTU3MAI.js';
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var hr$2 = {};
+
+var hasRequiredHr;
+
+function requireHr () {
+	if (hasRequiredHr) return hr$2;
+	hasRequiredHr = 1;
+
+	Object.defineProperty(hr$2, "__esModule", {
+	  value: true
+	});
+	hr$2.default = void 0;
+	var _default = {
+	  days: ['Nedjelja', 'Ponedjeljak', 'Utorak', 'Srijeda', 'Četvrtak', 'Petak', 'Subota'],
+	  daysShort: ['Ned', 'Pon', 'Uto', 'Sri', 'Čet', 'Pet', 'Sub'],
+	  daysMin: ['Ne', 'Po', 'Ut', 'Sr', 'Če', 'Pe', 'Su'],
+	  months: ['Siječanj', 'Veljača', 'Ožujak', 'Travanj', 'Svibanj', 'Lipanj', 'Srpanj', 'Kolovoz', 'Rujan', 'Listopad', 'Studeni', 'Prosinac'],
+	  monthsShort: ['Sij', 'Velj', 'Ožu', 'Tra', 'Svi', 'Lip', 'Srp', 'Kol', 'Ruj', 'Lis', 'Stu', 'Pro'],
+	  today: 'Danas',
+	  clear: 'Očisti',
+	  dateFormat: 'dd.MM.yyyy',
+	  timeFormat: 'HH:mm',
+	  firstDay: 1
+	};
+	hr$2.default = _default;
+	return hr$2;
+}
+
+var hrExports = requireHr();
+var hr = /*@__PURE__*/getDefaultExportFromCjs(hrExports);
+
+var hr$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: hr
+}, [hrExports]);
+
+export { hr$1 as h };

package/dist/esm/hu-BlwH1sUP.js

@@ -0,0 +1,54 @@
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BFTU3MAI.js';
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var hu$2 = {};
+
+var hasRequiredHu;
+
+function requireHu () {
+	if (hasRequiredHu) return hu$2;
+	hasRequiredHu = 1;
+
+	Object.defineProperty(hu$2, "__esModule", {
+	  value: true
+	});
+	hu$2.default = void 0;
+	var _default = {
+	  days: ['Vasárnap', 'Hétfő', 'Kedd', 'Szerda', 'Csütörtök', 'Péntek', 'Szombat'],
+	  daysShort: ['Va', 'Hé', 'Ke', 'Sze', 'Cs', 'Pé', 'Szo'],
+	  daysMin: ['V', 'H', 'K', 'Sz', 'Cs', 'P', 'Sz'],
+	  months: ['Január', 'Február', 'Március', 'Április', 'Május', 'Június', 'Július', 'Augusztus', 'Szeptember', 'Október', 'November', 'December'],
+	  monthsShort: ['Jan', 'Feb', 'Már', 'Ápr', 'Máj', 'Jún', 'Júl', 'Aug', 'Szep', 'Okt', 'Nov', 'Dec'],
+	  today: 'Ma',
+	  clear: 'Törlés',
+	  dateFormat: 'yyyy-MM-dd',
+	  timeFormat: 'hh:mm aa',
+	  firstDay: 1
+	};
+	hu$2.default = _default;
+	return hu$2;
+}
+
+var huExports = requireHu();
+var hu = /*@__PURE__*/getDefaultExportFromCjs(huExports);
+
+var hu$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: hu
+}, [huExports]);
+
+export { hu$1 as h };

package/dist/esm/id-BCexutvr.js

@@ -0,0 +1,54 @@
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BFTU3MAI.js';
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var id$2 = {};
+
+var hasRequiredId;
+
+function requireId () {
+	if (hasRequiredId) return id$2;
+	hasRequiredId = 1;
+
+	Object.defineProperty(id$2, "__esModule", {
+	  value: true
+	});
+	id$2.default = void 0;
+	var _default = {
+	  days: ['Minggu', 'Senin', 'Selasa', 'Rabu', 'Kamis', 'Jumat', 'Sabtu'],
+	  daysShort: ['Min', 'Sen', 'Sel', 'Rab', 'Kam', 'Jum', 'Sab'],
+	  daysMin: ['Min', 'Sen', 'Sel', 'Rab', 'Kam', 'Jum', 'Sab'],
+	  months: ['Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember'],
+	  monthsShort: ['Jan', 'Feb', 'Mar', 'Apr', 'Mei', 'Jun', 'Jul', 'Agt', 'Sep', 'Okt', 'Nov', 'Des'],
+	  today: 'Hari ini',
+	  clear: 'Hapus',
+	  dateFormat: 'dd/MM/yyyy',
+	  timeFormat: 'hh:mm aa',
+	  firstDay: 1
+	};
+	id$2.default = _default;
+	return id$2;
+}
+
+var idExports = requireId();
+var id = /*@__PURE__*/getDefaultExportFromCjs(idExports);
+
+var id$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: id
+}, [idExports]);
+
+export { id$1 as i };

package/dist/esm/index-bR8vy6-s.js

@@ -0,0 +1,161 @@
+/* eslint-disable no-undefined,no-param-reassign,no-shadow */
+
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+ *                                            are most useful.
+ * @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+ *                                            as-is, to `callback` when the throttled-function is executed.
+ * @param {object} [options] -              An object to configure options.
+ * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+ *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+ *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+ *                                            `delay` milliseconds, the internal counter is reset).
+ * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+ *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+ *                                            callback will never executed if both noLeading = true and noTrailing = true.
+ * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+ *                                            false (at end), schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Function} A new, throttled, function.
+ */
+function throttle (delay, callback, options) {
+  var _ref = options || {},
+    _ref$noTrailing = _ref.noTrailing,
+    noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing,
+    _ref$noLeading = _ref.noLeading,
+    noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading,
+    _ref$debounceMode = _ref.debounceMode,
+    debounceMode = _ref$debounceMode === void 0 ? undefined : _ref$debounceMode;
+  /*
+   * After wrapper has stopped being called, this timeout ensures that
+   * `callback` is executed at the proper times in `throttle` and `end`
+   * debounce modes.
+   */
+  var timeoutID;
+  var cancelled = false;
+
+  // Keep track of the last time `callback` was executed.
+  var lastExec = 0;
+
+  // Function to clear existing timeout
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+  }
+
+  // Function to cancel next exec
+  function cancel(options) {
+    var _ref2 = options || {},
+      _ref2$upcomingOnly = _ref2.upcomingOnly,
+      upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
+    clearExistingTimeout();
+    cancelled = !upcomingOnly;
+  }
+
+  /*
+   * The `wrapper` function encapsulates all of the throttling / debouncing
+   * functionality and when executed will limit the rate at which `callback`
+   * is executed.
+   */
+  function wrapper() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    var self = this;
+    var elapsed = Date.now() - lastExec;
+    if (cancelled) {
+      return;
+    }
+
+    // Execute `callback` and update the `lastExec` timestamp.
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(self, arguments_);
+    }
+
+    /*
+     * If `debounceMode` is true (at begin) this is used to clear the flag
+     * to allow future `callback` executions.
+     */
+    function clear() {
+      timeoutID = undefined;
+    }
+    if (!noLeading && debounceMode && !timeoutID) {
+      /*
+       * Since `wrapper` is being called for the first time and
+       * `debounceMode` is true (at begin), execute `callback`
+       * and noLeading != true.
+       */
+      exec();
+    }
+    clearExistingTimeout();
+    if (debounceMode === undefined && elapsed > delay) {
+      if (noLeading) {
+        /*
+         * In throttle mode with noLeading, if `delay` time has
+         * been exceeded, update `lastExec` and schedule `callback`
+         * to execute after `delay` ms.
+         */
+        lastExec = Date.now();
+        if (!noTrailing) {
+          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+        }
+      } else {
+        /*
+         * In throttle mode without noLeading, if `delay` time has been exceeded, execute
+         * `callback`.
+         */
+        exec();
+      }
+    } else if (noTrailing !== true) {
+      /*
+       * In trailing throttle mode, since `delay` time has not been
+       * exceeded, schedule `callback` to execute `delay` ms after most
+       * recent execution.
+       *
+       * If `debounceMode` is true (at begin), schedule `clear` to execute
+       * after `delay` ms.
+       *
+       * If `debounceMode` is false (at end), schedule `callback` to
+       * execute after `delay` ms.
+       */
+      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+    }
+  }
+  wrapper.cancel = cancel;
+
+  // Return the wrapper function.
+  return wrapper;
+}
+
+/* eslint-disable no-undefined */
+
+/**
+ * Debounce execution of a function. Debouncing, unlike throttling,
+ * guarantees that a function is only executed a single time, either at the
+ * very beginning of a series of calls, or at the very end.
+ *
+ * @param {number} delay -               A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.
+ * @param {Function} callback -          A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,
+ *                                        to `callback` when the debounced-function is executed.
+ * @param {object} [options] -           An object to configure options.
+ * @param {boolean} [options.atBegin] -  Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds
+ *                                        after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.
+ *                                        (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).
+ *
+ * @returns {Function} A new, debounced function.
+ */
+function debounce (delay, callback, options) {
+  var _ref = {},
+    _ref$atBegin = _ref.atBegin,
+    atBegin = _ref$atBegin === void 0 ? false : _ref$atBegin;
+  return throttle(delay, callback, {
+    debounceMode: atBegin !== false
+  });
+}
+
+export { debounce as d, throttle as t };